From: Jim C. <jim...@gm...> - 2012-04-23 08:26:14
|
hi Oliver, heres a large batch of patches to merge various duplicated functions from mem.c and pci.c to merge.c Most of them are reasonably disciplined, but 0002 was a overzealous mess, that I got compiling and working in patches 5,6. Patch 4 was originally done after 6, but I rebased it back in an attempt to clean up the mess. I couldnt get them back to 3, so I rebased again, and split 2 into everything up to the hw-ops, then committed hw-ops and rest as 3. Ick. After all that, I punted on further rebasing cleanups, and moved ahead. Because of all this, I added a "no-bisect: compile errs" tag on the problem patches. I dont think git-bisect knows to avoid those commits during a bisection, but at least it will help hackers who land there. Maybe git-bisect can (or soon will be able to) read annotations to avoid bad commits. I also added Tested-by: notes to many other commits, though I probably missed a few. TODO has some notes on whats DONE, and whats left wrt merging. Have the appropriate amount of fun ! thanks ~jimc |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:15
|
IO_ACX defns are needed in merge.c (in next patch) split them out of mem.c, and include them. Signed-off-by: Jim Cromie <jim...@gm...> --- io-acx.h | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ mem.c | 83 +----------------------------------------------------------- 2 files changed, 87 insertions(+), 82 deletions(-) create mode 100644 io-acx.h diff --git a/io-acx.h b/io-acx.h new file mode 100644 index 0000000..6213832 --- /dev/null +++ b/io-acx.h @@ -0,0 +1,86 @@ + +// ick: shouldnt declare things in headers +// cuz including it 2x is bad + +static const u16 IO_ACX100[] = { + 0x0000, /* IO_ACX_SOFT_RESET */ + + 0x0014, /* IO_ACX_SLV_MEM_ADDR */ + 0x0018, /* IO_ACX_SLV_MEM_DATA */ + 0x001c, /* IO_ACX_SLV_MEM_CTL */ + 0x0020, /* IO_ACX_SLV_END_CTL */ + + 0x0034, /* IO_ACX_FEMR */ + + 0x007c, /* IO_ACX_INT_TRIG */ + 0x0098, /* IO_ACX_IRQ_MASK */ + 0x00a4, /* IO_ACX_IRQ_STATUS_NON_DES */ + 0x00a8, /* IO_ACX_IRQ_REASON */ + 0x00ac, /* IO_ACX_IRQ_ACK */ + 0x00b0, /* IO_ACX_HINT_TRIG */ + + 0x0104, /* IO_ACX_ENABLE */ + + 0x0250, /* IO_ACX_EEPROM_CTL */ + 0x0254, /* IO_ACX_EEPROM_ADDR */ + 0x0258, /* IO_ACX_EEPROM_DATA */ + 0x025c, /* IO_ACX_EEPROM_CFG */ + + 0x0268, /* IO_ACX_PHY_ADDR */ + 0x026c, /* IO_ACX_PHY_DATA */ + 0x0270, /* IO_ACX_PHY_CTL */ + + 0x0290, /* IO_ACX_GPIO_OE */ + + 0x0298, /* IO_ACX_GPIO_OUT */ + + 0x02a4, /* IO_ACX_CMD_MAILBOX_OFFS */ + 0x02a8, /* IO_ACX_INFO_MAILBOX_OFFS */ + 0x02ac, /* IO_ACX_EEPROM_INFORMATION */ + + 0x02d0, /* IO_ACX_EE_START */ + 0x02d4, /* IO_ACX_SOR_CFG */ + 0x02d8 /* IO_ACX_ECPU_CTRL */ +}; + +static const u16 IO_ACX111[] = { + 0x0000, /* IO_ACX_SOFT_RESET */ + + 0x0014, /* IO_ACX_SLV_MEM_ADDR */ + 0x0018, /* IO_ACX_SLV_MEM_DATA */ + 0x001c, /* IO_ACX_SLV_MEM_CTL */ + 0x0020, /* IO_ACX_SLV_END_CTL */ + + 0x0034, /* IO_ACX_FEMR */ + + 0x00b4, /* IO_ACX_INT_TRIG */ + 0x00d4, /* IO_ACX_IRQ_MASK */ + /* we do mean NON_DES (0xf0), not NON_DES_MASK which is at 0xe0: */ + 0x00f0, /* IO_ACX_IRQ_STATUS_NON_DES */ + 0x00e4, /* IO_ACX_IRQ_REASON */ + 0x00e8, /* IO_ACX_IRQ_ACK */ + 0x00ec, /* IO_ACX_HINT_TRIG */ + + 0x01d0, /* IO_ACX_ENABLE */ + + 0x0338, /* IO_ACX_EEPROM_CTL */ + 0x033c, /* IO_ACX_EEPROM_ADDR */ + 0x0340, /* IO_ACX_EEPROM_DATA */ + 0x0344, /* IO_ACX_EEPROM_CFG */ + + 0x0350, /* IO_ACX_PHY_ADDR */ + 0x0354, /* IO_ACX_PHY_DATA */ + 0x0358, /* IO_ACX_PHY_CTL */ + + 0x0374, /* IO_ACX_GPIO_OE */ + + 0x037c, /* IO_ACX_GPIO_OUT */ + + 0x0388, /* IO_ACX_CMD_MAILBOX_OFFS */ + 0x038c, /* IO_ACX_INFO_MAILBOX_OFFS */ + 0x0390, /* IO_ACX_EEPROM_INFORMATION */ + + 0x0100, /* IO_ACX_EE_START */ + 0x0104, /* IO_ACX_SOR_CFG */ + 0x0108, /* IO_ACX_ECPU_CTRL */ +}; diff --git a/mem.c b/mem.c index cc99b3d..126954b 100644 --- a/mem.c +++ b/mem.c @@ -264,88 +264,7 @@ void __exit acxmem_cleanup_module(void); #define RX_BUFFER_SIZE (sizeof(rxbuffer_t) + 32) -static const u16 IO_ACX100[] = { -0x0000, /* IO_ACX_SOFT_RESET */ - -0x0014, /* IO_ACX_SLV_MEM_ADDR */ -0x0018, /* IO_ACX_SLV_MEM_DATA */ -0x001c, /* IO_ACX_SLV_MEM_CTL */ -0x0020, /* IO_ACX_SLV_END_CTL */ - -0x0034, /* IO_ACX_FEMR */ - -0x007c, /* IO_ACX_INT_TRIG */ -0x0098, /* IO_ACX_IRQ_MASK */ -0x00a4, /* IO_ACX_IRQ_STATUS_NON_DES */ -0x00a8, /* IO_ACX_IRQ_REASON */ -0x00ac, /* IO_ACX_IRQ_ACK */ -0x00b0, /* IO_ACX_HINT_TRIG */ - -0x0104, /* IO_ACX_ENABLE */ - -0x0250, /* IO_ACX_EEPROM_CTL */ -0x0254, /* IO_ACX_EEPROM_ADDR */ -0x0258, /* IO_ACX_EEPROM_DATA */ -0x025c, /* IO_ACX_EEPROM_CFG */ - -0x0268, /* IO_ACX_PHY_ADDR */ -0x026c, /* IO_ACX_PHY_DATA */ -0x0270, /* IO_ACX_PHY_CTL */ - -0x0290, /* IO_ACX_GPIO_OE */ - -0x0298, /* IO_ACX_GPIO_OUT */ - -0x02a4, /* IO_ACX_CMD_MAILBOX_OFFS */ -0x02a8, /* IO_ACX_INFO_MAILBOX_OFFS */ -0x02ac, /* IO_ACX_EEPROM_INFORMATION */ - -0x02d0, /* IO_ACX_EE_START */ -0x02d4, /* IO_ACX_SOR_CFG */ -0x02d8 /* IO_ACX_ECPU_CTRL */ -}; - -static const u16 IO_ACX111[] = { 0x0000, /* IO_ACX_SOFT_RESET */ - -0x0014, /* IO_ACX_SLV_MEM_ADDR */ -0x0018, /* IO_ACX_SLV_MEM_DATA */ -0x001c, /* IO_ACX_SLV_MEM_CTL */ -0x0020, /* IO_ACX_SLV_END_CTL */ - -0x0034, /* IO_ACX_FEMR */ - -0x00b4, /* IO_ACX_INT_TRIG */ -0x00d4, /* IO_ACX_IRQ_MASK */ -/* we do mean NON_DES (0xf0), not NON_DES_MASK which is at 0xe0: */ -0x00f0, /* IO_ACX_IRQ_STATUS_NON_DES */ -0x00e4, /* IO_ACX_IRQ_REASON */ -0x00e8, /* IO_ACX_IRQ_ACK */ -0x00ec, /* IO_ACX_HINT_TRIG */ - -0x01d0, /* IO_ACX_ENABLE */ - -0x0338, /* IO_ACX_EEPROM_CTL */ -0x033c, /* IO_ACX_EEPROM_ADDR */ -0x0340, /* IO_ACX_EEPROM_DATA */ -0x0344, /* IO_ACX_EEPROM_CFG */ - -0x0350, /* IO_ACX_PHY_ADDR */ -0x0354, /* IO_ACX_PHY_DATA */ -0x0358, /* IO_ACX_PHY_CTL */ - -0x0374, /* IO_ACX_GPIO_OE */ - -0x037c, /* IO_ACX_GPIO_OUT */ - -0x0388, /* IO_ACX_CMD_MAILBOX_OFFS */ -0x038c, /* IO_ACX_INFO_MAILBOX_OFFS */ -0x0390, /* IO_ACX_EEPROM_INFORMATION */ - -0x0100, /* IO_ACX_EE_START */ -0x0104, /* IO_ACX_SOR_CFG */ -0x0108, /* IO_ACX_ECPU_CTRL */ -}; - +#include "io-acx.h" /* * BOM Logging -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:18
|
copied lots of common-looking code from pci.c, mem.c no-bisect: compile errs Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 2909 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 2909 insertions(+), 0 deletions(-) diff --git a/merge.c b/merge.c index 0a0be8d..71a5a50 100644 --- a/merge.c +++ b/merge.c @@ -269,3 +269,2912 @@ void acx_log_txbuffer(acx_device_t *adev) } printk("\n"); } + + +//####################################################################### + + + +/* + * acxmem_read_eeprom_byte + * + * Function called to read an octet in the EEPROM. + * + * This function is used by acxmem_e_probe to check if the + * connected card is a legal one or not. + * + * Arguments: + * adev ptr to acx_device structure + * addr address to read in the EEPROM + * charbuf ptr to a char. This is where the read octet + * will be stored + */ +int acxmem_read_eeprom_byte(acx_device_t *adev, u32 addr, u8 *charbuf) +{ + int result; + int count; + + FN_ENTER; + + write_reg32(adev, IO_ACX_EEPROM_CFG, 0); + write_reg32(adev, IO_ACX_EEPROM_ADDR, addr); + write_flush(adev); + write_reg32(adev, IO_ACX_EEPROM_CTL, 2); + + count = 0xffff; + while (read_reg16(adev, IO_ACX_EEPROM_CTL)) { + /* scheduling away instead of CPU burning loop + * doesn't seem to work here at all: + * awful delay, sometimes also failure. + * Doesn't matter anyway (only small delay). */ + if (unlikely(!--count)) { + pr_acx("%s: timeout waiting for EEPROM read\n", + wiphy_name(adev->ieee->wiphy)); + result = NOT_OK; + goto fail; + } + cpu_relax(); + } + + *charbuf = read_reg8(adev, IO_ACX_EEPROM_DATA); + log(L_DEBUG, "EEPROM at 0x%04X = 0x%02X\n", addr, *charbuf); + result = OK; + +fail: + FN_EXIT1(result); + return result; +} + +/* + * We don't lock hw accesses here since we never r/w eeprom in IRQ + * Note: this function sleeps only because of GFP_KERNEL alloc + */ +// unused in mem, used in pci +int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, + const u8 *charbuf) +{ + u8 *data_verify = NULL; + unsigned long flags; + int count, i; + int result = NOT_OK; + u16 gpio_orig; + + pr_acx("WARNING! I would write to EEPROM now. " + "Since I really DON'T want to unless you know " + "what you're doing (THIS CODE WILL PROBABLY " + "NOT WORK YET!), I will abort that now. And " + "definitely make sure to make a " + "/proc/driver/acx_wlan0_eeprom backup copy first!!! " + "(the EEPROM content includes the PCI config header!! " + "If you kill important stuff, then you WILL " + "get in trouble and people DID get in trouble already)\n"); + return OK; + + FN_ENTER; + + // TODO - move malloc down + data_verify = kmalloc(len, GFP_KERNEL); + if (!data_verify) { + goto end; + } + + /* first we need to enable the OE (EEPROM Output Enable) GPIO line + * to be able to write to the EEPROM. + * NOTE: an EEPROM writing success has been reported, + * but you probably have to modify GPIO_OUT, too, + * and you probably need to activate a different GPIO + * line instead! */ + gpio_orig = read_reg16(adev, IO_ACX_GPIO_OE); + write_reg16(adev, IO_ACX_GPIO_OE, gpio_orig & ~1); + write_flush(adev); + + /* ok, now start writing the data out */ + for (i = 0; i < len; i++) { + write_reg32(adev, IO_ACX_EEPROM_CFG, 0); + write_reg32(adev, IO_ACX_EEPROM_ADDR, addr + i); + write_reg32(adev, IO_ACX_EEPROM_DATA, *(charbuf + i)); + write_flush(adev); + write_reg32(adev, IO_ACX_EEPROM_CTL, 1); + + count = 0xffff; + while (read_reg16(adev, IO_ACX_EEPROM_CTL)) { + if (unlikely(!--count)) { + pr_acx("WARNING, DANGER!!! " + "Timeout waiting for EEPROM write\n"); + goto end; + } + cpu_relax(); + } + } + + /* disable EEPROM writing */ + write_reg16(adev, IO_ACX_GPIO_OE, gpio_orig); + write_flush(adev); + + /* now start a verification run */ + // kmalloc here. + + for (i = 0; i < len; i++) { + write_reg32(adev, IO_ACX_EEPROM_CFG, 0); + write_reg32(adev, IO_ACX_EEPROM_ADDR, addr + i); + write_flush(adev); + write_reg32(adev, IO_ACX_EEPROM_CTL, 2); + + count = 0xffff; + while (read_reg16(adev, IO_ACX_EEPROM_CTL)) { + if (unlikely(!--count)) { + pr_acx("timeout waiting for EEPROM read\n"); + goto end; + } + cpu_relax(); + } + + data_verify[i] = read_reg16(adev, IO_ACX_EEPROM_DATA); + } + + if (0 == memcmp(charbuf, data_verify, len)) + result = OK; /* read data matches, success */ + + end: + kfree(data_verify); + FN_EXIT1(result); + return result; +} + +static inline void acxmem_read_eeprom_area(acx_device_t *adev) +{ +#if ACX_DEBUG > 1 + int offs; + u8 tmp; + + FN_ENTER; + + if (IS_MEM(adev)) + for (offs = 0x8c; offs < 0xb9; offs++) + acxmem_read_eeprom_byte(adev, offs, &tmp); + else if (IS_PCI(adev)) + for (offs = 0x8c; offs < 0xb9; offs++) + acxpci_read_eeprom_byte(adev, offs, &tmp); + else BUG(); + + FN_EXIT0; + +#endif +} + +#if 1 // port soon to merge.c +/* + * acxmem_s_read_phy_reg + * + * Messing with rx/tx disabling and enabling here + * (write_reg32(adev, IO_ACX_ENABLE, 0b000000xx)) kills traffic + */ +int acxmem_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf) +{ + int result = NOT_OK; + int count; + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + write_reg32(adev, IO_ACX_PHY_ADDR, reg); + write_flush(adev); + write_reg32(adev, IO_ACX_PHY_CTL, 2); + + count = 0xffff; + // todo moe while to fn, reuse + while (read_reg32(adev, IO_ACX_PHY_CTL)) { + /* scheduling away instead of CPU burning loop + * doesn't seem to work here at all: + * awful delay, sometimes also failure. + * Doesn't matter anyway (only small delay). */ + if (unlikely(!--count)) { + pr_acx("%s: timeout waiting for phy read\n", + wiphy_name(adev->ieee->wiphy)); + *charbuf = 0; + goto fail; + } + cpu_relax(); + } + + log(L_DEBUG, "the count was %u\n", count); + *charbuf = read_reg8(adev, IO_ACX_PHY_DATA); + + log(L_DEBUG, "radio PHY at 0x%04X = 0x%02X\n", *charbuf, reg); + result = OK; + goto fail; /* silence compiler warning */ +fail: + acxmem_unlock(); + FN_EXIT1(result); + return result; +} + +int acxmem_write_phy_reg(acx_device_t *adev, u32 reg, u8 value) { + int count; + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + /* mprusko said that 32bit accesses result in distorted sensitivity + * on his card. Unconfirmed, looks like it's not true (most likely since we + * now properly flush writes). */ + write_reg32(adev, IO_ACX_PHY_DATA, value); + write_reg32(adev, IO_ACX_PHY_ADDR, reg); + write_flush(adev); + write_reg32(adev, IO_ACX_PHY_CTL, 1); + write_flush(adev); + + // todo recode as fn + // this not present for pci + count = 0xffff; + while (read_reg32(adev, IO_ACX_PHY_CTL)) { + /* scheduling away instead of CPU burning loop + * doesn't seem to work here at all: + * awful delay, sometimes also failure. + * Doesn't matter anyway (only small delay). */ + if (unlikely(!--count)) { + pr_acx("%s: timeout waiting for phy read\n", wiphy_name( + adev->ieee->wiphy)); + goto fail; + } + cpu_relax(); + } + + log(L_DEBUG, "radio PHY write 0x%02X at 0x%04X\n", value, reg); +fail: + + acxmem_unlock(); + FN_EXIT1(OK); // FN_EXIT0 in pci + return OK; +} +#endif // port soon + +/* + * acxmem_s_write_fw + * + * Write the firmware image into the card. + * + * Arguments: + * adev wlan device structure + * fw_image firmware image. + * + * Returns: + * 1 firmware image corrupted + * 0 success + */ +// static +int acxmem_write_fw(acx_device_t *adev, + const firmware_image_t *fw_image, u32 offset) { + int len, size; + u32 sum, v32; + // mem.c ars + int checkMismatch = -1; + u32 tmp, id; + + /* we skip the first four bytes which contain the control sum */ + const u8 *p = (u8*) fw_image + 4; + + FN_ENTER; + + /* start the image checksum by adding the image size value */ + sum = p[0] + p[1] + p[2] + p[3]; + p += 4; + +#ifdef NOPE // mem.c only, all else same +#if FW_NO_AUTO_INCREMENT + write_reg32(adev, IO_ACX_SLV_MEM_CTL, 0); /* use basic mode */ +#else + write_reg32(adev, IO_ACX_SLV_MEM_CTL, 1); /* use autoincrement mode */ + write_reg32(adev, IO_ACX_SLV_MEM_ADDR, offset); /* configure start address */ + write_flush(adev); +#endif +#endif + len = 0; + size = le32_to_cpu(fw_image->size) & (~3); + + while (likely(len < size)) { + v32 = be32_to_cpu(*(u32*)p); + sum += p[0] + p[1] + p[2] + p[3]; + p += 4; + len += 4; + +#ifdef NOPE // mem.c +#if FW_NO_AUTO_INCREMENT + write_reg32(adev, IO_ACX_SLV_MEM_ADDR, offset + len - 4); + write_flush(adev); +#endif + write_reg32(adev, IO_ACX_SLV_MEM_DATA, v32); + write_flush(adev); +#endif +// mem.c only, til .. + write_slavemem32(adev, offset + len - 4, v32); + + id = read_id_register(adev); + + /* + * check the data written + */ + tmp = read_slavemem32(adev, offset + len - 4); + if (checkMismatch && (tmp != v32)) { + pr_info("first data mismatch at 0x%08x good 0x%08x" + " bad 0x%08x id 0x%08x\n", + offset + len - 4, v32, tmp, id); + checkMismatch = 0; + } + } +// ... here + log(L_DEBUG, "firmware written, size:%d sum1:%x sum2:%x\n", + size, sum, le32_to_cpu(fw_image->chksum)); + + /* compare our checksum with the stored image checksum */ + FN_EXIT1(sum != le32_to_cpu(fw_image->chksum)); + return (sum != le32_to_cpu(fw_image->chksum)); +} + +/* + * acxmem_s_validate_fw + * + * Compare the firmware image given with + * the firmware image written into the card. + * + * Arguments: + * adev wlan device structure + * fw_image firmware image. + * + * Returns: + * NOT_OK firmware image corrupted or not correctly written + * OK success + */ +// static +int acxmem_validate_fw(acx_device_t *adev, + const firmware_image_t *fw_image, u32 offset) +{ + u32 sum, v32, w32; + int len, size; + int result = OK; + /* we skip the first four bytes which contain the control sum */ + const u8 *p = (u8*) fw_image + 4; + + FN_ENTER; + + /* start the image checksum by adding the image size value */ + sum = p[0] + p[1] + p[2] + p[3]; + p += 4; + + write_reg32(adev, IO_ACX_SLV_END_CTL, 0); + +#if FW_NO_AUTO_INCREMENT + write_reg32(adev, IO_ACX_SLV_MEM_CTL, 0); /* use basic mode */ +#else + write_reg32(adev, IO_ACX_SLV_MEM_CTL, 1); /* use autoincrement mode */ + write_reg32(adev, IO_ACX_SLV_MEM_ADDR, offset); /* configure start address */ +#endif + + len = 0; + size = le32_to_cpu(fw_image->size) & (~3); + + while (likely(len < size)) { + v32 = be32_to_cpu(*(u32*)p); + p += 4; + len += 4; + + +#ifdef NOPE // mem.c only +#if FW_NO_AUTO_INCREMENT + write_reg32(adev, IO_ACX_SLV_MEM_ADDR, offset + len - 4); +#endif + udelay(10); + w32 = read_reg32(adev, IO_ACX_SLV_MEM_DATA); +#endif + + w32 = read_slavemem32(adev, offset + len - 4); + + if (unlikely(w32 != v32)) { + pr_acx("FATAL: firmware upload: " + "data parts at offset %d don't match\n(0x%08X vs. 0x%08X)!\n" + "I/O timing issues or defective memory, with DWL-xx0+? " + "ACX_IO_WIDTH=16 may help. Please report\n", len, v32, w32); + result = NOT_OK; + break; + } + + sum += (u8) w32 + + (u8) (w32 >> 8) + + (u8) (w32 >> 16) + + (u8) (w32 >> 24); + } + + /* sum control verification */ + if (result != NOT_OK) { + if (sum != le32_to_cpu(fw_image->chksum)) { + pr_acx("FATAL: firmware upload: " + "checksums don't match!\n"); + result = NOT_OK; + } + } + + FN_EXIT1(result); + return result; +} + +#if 0 // defer, +static int acxmem_upload_fw(acx_device_t *adev, char *filename) +{ + firmware_image_t *fw_image = NULL; + int res = NOT_OK; + int try; + u32 file_size; + char *filename = "WLANGEN.BIN"; + + acxmem_lock_flags; + +#ifdef PATCH_AROUND_BAD_SPOTS + u32 offset; + int i; + /* + * arm-linux-objdump -d patch.bin, or + * od -Ax -t x4 patch.bin after finding the bounds + * of the .text section with arm-linux-objdump -s patch.bin + */ + u32 patch[] = { 0xe584c030, 0xe59fc008, 0xe92d1000, 0xe59fc004, 0xe8bd8000, + 0x0000080c, 0x0000aa68, 0x605a2200, 0x2c0a689c, 0x2414d80a, + 0x2f00689f, 0x1c27d007, 0x06241e7c, 0x2f000e24, 0xe000d1f6, + 0x602e6018, 0x23036468, 0x480203db, 0x60ca6003, 0xbdf0750a, + 0xffff0808 }; +#endif + + FN_ENTER; + + /* No combined image; tell common we need the radio firmware, too */ + adev->need_radio_fw = 1; + + fw_image = acx_read_fw(adev->bus_dev, filename, &file_size); + if (!fw_image) { + FN_EXIT1(NOT_OK); + return NOT_OK; + } + + for (try = 1; try <= 5; try++) { + + acxmem_lock(); + res = acxmem_write_fw(adev, fw_image, 0); + log(L_DEBUG|L_INIT, "acx_write_fw (main): %d\n", res); + if (OK == res) { + res = acxmem_validate_fw(adev, fw_image, 0); + log(L_DEBUG|L_INIT, "acx_validate_fw " + "(main): %d\n", res); + } + acxmem_unlock(); + + if (OK == res) { + SET_BIT(adev->dev_state_mask, ACX_STATE_FW_LOADED); + break; + } + pr_acx("firmware upload attempt #%d FAILED, " + "retrying...\n", try); + acx_mwait(1000); /* better wait for a while... */ + } + +#ifdef PATCH_AROUND_BAD_SPOTS + acxmem_lock(); + /* + * Only want to do this if the firmware is exactly what we expect for an + * iPaq 4700; otherwise, bad things would ensue. + */ + if ((HX4700_FIRMWARE_CHECKSUM == fw_image->chksum) + || (HX4700_ALTERNATE_FIRMWARE_CHECKSUM == fw_image->chksum)) { + /* + * Put the patch after the main firmware image. 0x950c contains + * the ACX's idea of the end of the firmware. Use that location to + * load ours (which depends on that location being 0xab58) then + * update that location to point to after ours. + */ + + offset = read_slavemem32(adev, 0x950c); + + log (L_DEBUG, "patching in at 0x%04x\n", offset); + + for (i = 0; i < sizeof(patch) / sizeof(patch[0]); i++) { + write_slavemem32(adev, offset, patch[i]); + offset += sizeof(u32); + } + + /* + * Patch the instruction at 0x0804 to branch to our ARM patch at 0xab58 + */ + write_slavemem32(adev, 0x0804, 0xea000000 + (0xab58 - 0x0804 - 8) / 4); + + /* + * Patch the instructions at 0x1f40 to branch to our Thumb patch at 0xab74 + * + * 4a00 ldr r2, [pc, #0] + * 4710 bx r2 + * .data 0xab74+1 + */ + write_slavemem32(adev, 0x1f40, 0x47104a00); + write_slavemem32(adev, 0x1f44, 0x0000ab74 + 1); + + /* + * Bump the end of the firmware up to beyond our patch. + */ + write_slavemem32(adev, 0x950c, offset); + + } + acxmem_unlock(); +#endif + vfree(fw_image); + + FN_EXIT1(res); + return res; +} +#endif // defer + +#if defined(NONESSENTIAL_FEATURES) +typedef struct device_id { + unsigned char id[6]; + char *descr; + char *type; +}device_id_t; + +static const device_id_t +device_ids[] = +{ + { + { 'G', 'l', 'o', 'b', 'a', 'l'}, + NULL, + NULL, + }, + { + { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, + "uninitialized", + "SpeedStream SS1021 or Gigafast WF721-AEX" + }, + { + { 0x80, 0x81, 0x82, 0x83, 0x84, 0x85}, + "non-standard", + "DrayTek Vigor 520" + }, + { + { '?', '?', '?', '?', '?', '?'}, + "non-standard", + "Level One WPC-0200" + }, + { + { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + "empty", + "DWL-650+ variant" + } +}; + +static void +acx_show_card_eeprom_id(acx_device_t *adev) +{ + unsigned char buffer[CARD_EEPROM_ID_SIZE]; + int i, rc; + + FN_ENTER; + + memset(&buffer, 0, CARD_EEPROM_ID_SIZE); + /* use direct EEPROM access */ + for (i = 0; i < CARD_EEPROM_ID_SIZE; i++) { + rc = (IS_MEM(adev)) + ? acxmem_read_eeprom_byte(adev, + ACX100_EEPROM_ID_OFFSET + i, + &buffer[i]) + : acxpci_read_eeprom_byte(adev, + ACX100_EEPROM_ID_OFFSET + i, + &buffer[i]); + if (rc != OK) { + pr_acx("reading EEPROM FAILED\n"); + break; + } + } + + for (i = 0; i < ARRAY_SIZE(device_ids); i++) { + if (!memcmp(&buffer, device_ids[i].id, CARD_EEPROM_ID_SIZE)) { + if (device_ids[i].descr) { + pr_acx("EEPROM card ID string check " + "found %s card ID: is this %s?\n", + device_ids[i].descr, device_ids[i].type); + } + break; + } + } + if (i == ARRAY_SIZE(device_ids)) { + pr_acx("EEPROM card ID string check found " + "unknown card: expected 'Global', got '%.*s\'. " + "Please report\n", CARD_EEPROM_ID_SIZE, buffer); + } + FN_EXIT0; +} +#endif /* NONESSENTIAL_FEATURES */ + +/* + * BOM CMDs (Control Path) + * ================================================== + */ + +/* + * acxmem_s_issue_cmd_timeo + * + * Sends command to fw, extract result + * + * OW, 20100630: + * + * The mem device is quite sensible to data access operations, therefore + * we may not sleep during the command handling. + * + * This has manifested as problem during sw-scan while if up. The acx got + * stuck - most probably due to concurrent data access collision. + * + * By not sleeping anymore and doing the entire operation completely under + * spinlock (thus with irqs disabled), the sw scan problem was solved. + * + * We can now run repeating sw scans, under load, without that the acx + * device gets stuck. + * + * Also ifup/down works more reliable on the mem device. + * + */ +int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, + void *buffer, unsigned buflen, + unsigned cmd_timeout, const char* cmdstr) +{ + + unsigned long start = jiffies; + const char *devname; + unsigned counter; + u16 irqtype; + u16 cmd_status=-1; + int i, j; + u8 *p; + unsigned long timeout; + + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + devname = wiphy_name(adev->ieee->wiphy); + if (!devname || !devname[0] || devname[4] == '%') + devname = "acx"; + + log(L_CTL, "%s: cmd:%s, cmd:0x%04X, buflen:%u, timeout:%ums, type:0x%04X)\n", + __func__, cmdstr, cmd, buflen, cmd_timeout, + buffer ? le16_to_cpu(((acx_ie_generic_t *)buffer)->type) : -1); + + if (!(adev->dev_state_mask & ACX_STATE_FW_LOADED)) { + pr_acxmem("%s: %s: firmware is not loaded yet, cannot execute commands!\n", + __func__, devname); + goto bad; + } + + if ((acx_debug & L_DEBUG) && (cmd != ACX1xx_CMD_INTERROGATE)) { + pr_acxmem("input buffer (len=%u):\n", buflen); + acx_dump_bytes(buffer, buflen); + } + + /* wait for firmware to become idle for our command submission */ + counter = 199; /* in ms */ + // from pci.c + timeout = HZ / 5; + counter = (timeout * 1000 / HZ) - 1; + timeout += jiffies; + + do { + cmd_status = (IS_MEM(adev)) + ? acxmem_read_cmd_type_status(adev) + : acxpci_read_cmd_type_status(adev); + /* Test for IDLE state */ + // pci.c had more complicated timeout code here. + if (!cmd_status) + break; + + udelay(1000); + } while (likely(--counter)); + + if (counter == 0) { + /* the card doesn't get idle, we're in trouble */ + pr_acxmem("%s: %s: cmd_status is not IDLE: 0x%04X!=0\n", + __func__, devname, cmd_status); + goto bad; + } else if (counter < 190) { /* if waited >10ms... */ + log(L_CTL|L_DEBUG, "%s: waited for IDLE %dms. Please report\n", + __func__, 199 - counter); + } + + /* now write the parameters of the command if needed */ + if (buffer && buflen) { + /* if it's an INTERROGATE command, just pass the length + * of parameters to read, as data */ +#if CMD_DISCOVERY + if (cmd == ACX1xx_CMD_INTERROGATE) + memset_io(adev->cmd_area + 4, 0xAA, buflen); +#endif + + if (IS_MEM(adev)) { + /* slave memory version */ + acxmem_copy_to_slavemem(adev, (u32) (adev->cmd_area + 4), buffer, + (cmd == ACX1xx_CMD_INTERROGATE) + ? 4 : buflen); + } else { + /* adev->cmd_area points to PCI device's memory, not to RAM! */ + memcpy_toio(adev->cmd_area + 4, buffer, + (cmd == ACX1xx_CMD_INTERROGATE) ? 4 : buflen); + } + } + /* now write the actual command type */ + if (IS_MEM(adev)) + acxmem_write_cmd_type_status(adev, cmd, 0); + else + acxpci_write_cmd_type_status(adev, cmd, 0); + + /* clear CMD_COMPLETE bit. can be set only by IRQ handler: */ + CLEAR_BIT(adev->irq_status, HOST_INT_CMD_COMPLETE); + + /* execute command */ + write_reg16(adev, IO_ACX_INT_TRIG, INT_TRIG_CMD); + write_flush(adev); + + /* wait for firmware to process command */ + + /* Ensure nonzero and not too large timeout. + ** Also converts e.g. 100->99, 200->199 + ** which is nice but not essential */ + cmd_timeout = (cmd_timeout - 1) | 1; + if (unlikely(cmd_timeout> 1199)) + cmd_timeout = 1199; + + /* we schedule away sometimes (timeout can be large) */ + counter = cmd_timeout; + do { + irqtype = read_reg16(adev, IO_ACX_IRQ_STATUS_NON_DES); + if (irqtype & HOST_INT_CMD_COMPLETE) { + write_reg16(adev, IO_ACX_IRQ_ACK, HOST_INT_CMD_COMPLETE); + break; + } + + if (adev->irq_status & HOST_INT_CMD_COMPLETE) + break; + + udelay(1000); + + } while (likely(--counter)); + + /* save state for debugging */ + cmd_status = (IS_MEM(adev)) + ? acxmem_read_cmd_type_status(adev) + : acxpci_read_cmd_type_status(adev); + + /* put the card in IDLE state */ + (IS_MEM(adev)) + ? acxmem_write_cmd_type_status(adev, ACX1xx_CMD_RESET, 0) + ? acxpci_write_cmd_type_status(adev, 0, 0) + + /* Timed out! */ + if (counter == 0) { + + log(L_ANY, "%s: %s: Timed out %s for CMD_COMPLETE. " + "irq bits:0x%04X irq_status:0x%04X timeout:%dms " + "cmd_status:%d (%s)\n", + __func__, devname, + (adev->irqs_active) ? "waiting" : "polling", + irqtype, adev->irq_status, cmd_timeout, + cmd_status, acx_cmd_status_str(cmd_status)); + log(L_ANY, "%s: " + "timeout: counter:%d cmd_timeout:%d cmd_timeout-counter:%d\n", + __func__, + counter, cmd_timeout, cmd_timeout - counter); + + if (read_reg16(adev, IO_ACX_IRQ_MASK) == 0xffff) { + log(L_ANY,"acxmem: firmware probably hosed - reloading: FIXME: Not implmemented\n"); + FIXME(); + } + + } else if (cmd_timeout - counter > 30) { /* if waited >30ms... */ + log(L_CTL|L_DEBUG, "%s: " + "%s for CMD_COMPLETE %dms. count:%d. Please report\n", + __func__, + (adev->irqs_active) ? "waited" : "polled", + cmd_timeout - counter, counter); + } + + logf1(L_CTL, "%s: cmd=%s, buflen=%u, timeout=%ums, type=0x%04X: %s\n", + devname, + cmdstr, buflen, cmd_timeout, + buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) : -1, + acx_cmd_status_str(cmd_status) + ); + + if (cmd_status != 1) { /* it is not a 'Success' */ + + /* zero out result buffer + * WARNING: this will trash stack in case of illegally large input + * length! */ + + if (buflen > 388) { + /* + * 388 is maximum command length + */ + log(L_ANY, "%s: invalid length 0x%08x\n", + __func__, buflen); + buflen = 388; + } + p = (u8 *) buffer; + for (i = 0; i < buflen; i += 16) { + printk("%04x:", i); + for (j = 0; (j < 16) && (i + j < buflen); j++) { + printk(" %02x", *p++); + } + printk("\n"); + } + + if (buffer && buflen) + memset(buffer, 0, buflen); + goto bad; + } + + /* read in result parameters if needed */ + if (buffer && buflen && (cmd == ACX1xx_CMD_INTERROGATE)) { + acxmem_copy_from_slavemem(adev, buffer, (u32) (adev->cmd_area + 4), buflen); + if (acx_debug & L_DEBUG) { + log(L_ANY, "%s: output buffer (len=%u): ", __func__, buflen); + acx_dump_bytes(buffer, buflen); + } + } + + /* ok: */ + log(L_DEBUG, "%s: %s: took %ld jiffies to complete\n", + __func__, cmdstr, jiffies - start); + + acxmem_unlock(); + FN_EXIT1(OK); + return OK; + + bad: + /* Give enough info so that callers can avoid + ** printing their own diagnostic messages */ + logf1(L_ANY, "%s: cmd=%s, buflen=%u, timeout=%ums, type=0x%04X, status=%s: FAILED\n", + devname, + cmdstr, buflen, cmd_timeout, + buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) : -1, + acx_cmd_status_str(cmd_status) + ); + + acxmem_unlock(); + FN_EXIT1(NOT_OK); + return NOT_OK; +} + +static inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, + u16 status) { + FN_ENTER; + write_slavemem32(adev, (u32) adev->cmd_area, type | (status << 16)); + write_flush(adev); + FN_EXIT0; +} + +static u32 acxmem_read_cmd_type_status(acx_device_t *adev) { + u32 cmd_type, cmd_status; + + FN_ENTER; + + cmd_type = read_slavemem32(adev, (u32) adev->cmd_area); + + cmd_status = (cmd_type >> 16); + cmd_type = (u16) cmd_type; + + log(L_DEBUG, "%s: " + "cmd_type:%04X cmd_status:%04X [%s]\n", + __func__, + cmd_type, cmd_status, + acx_cmd_status_str(cmd_status)); + + FN_EXIT1(cmd_status); + return cmd_status; +} + +static inline void acxmem_init_mboxes(acx_device_t *adev) { + u32 cmd_offs, info_offs; + + FN_ENTER; + + cmd_offs = read_reg32(adev, IO_ACX_CMD_MAILBOX_OFFS); + info_offs = read_reg32(adev, IO_ACX_INFO_MAILBOX_OFFS); + adev->cmd_area = (u8*) cmd_offs; + adev->info_area = (u8*) info_offs; + + // OW iobase2 not used in mem.c, in pci.c it is + /* + log(L_DEBUG, "iobase2=%p\n" + */ + log(L_DEBUG, "cmd_mbox_offset=%X cmd_area=%p\n" + "acx: info_mbox_offset=%X info_area=%p\n", + cmd_offs, adev->cmd_area, + info_offs, adev->info_area); + + FN_EXIT0; +} + + +/* + * BOM Init, Configure (Control Path) + * ================================================== + */ + +/* + * acxmem_s_reset_dev + * + * Arguments: + * netdevice that contains the adev variable + * Returns: + * NOT_OK on fail + * OK on success + * Side effects: + * device is hard reset + * Call context: + * acxmem_e_probe + * Comment: + * This resets the device using low level hardware calls + * as well as uploads and verifies the firmware to the card + */ +int acxmem_reset_dev(acx_device_t *adev) { + const char* msg = ""; + int result = NOT_OK; + u16 hardware_info; + u16 ecpu_ctrl; + int count; + u32 tmp; + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + /* + write_reg32 (adev, IO_ACX_SLV_MEM_CP, 0); + */ + /* reset the device to make sure the eCPU is stopped + * to upload the firmware correctly */ + + /* Windows driver does some funny things here */ + /* + * clear bit 0x200 in register 0x2A0 + */ + clear_regbits(adev, 0x2A0, 0x200); + + /* + * Set bit 0x200 in ACX_GPIO_OUT + */ + set_regbits(adev, IO_ACX_GPIO_OUT, 0x200); + + /* + * read register 0x900 until its value is 0x8400104C, sleeping + * in between reads if it's not immediate + */ + tmp = read_reg32(adev, REG_ACX_VENDOR_ID); + count = 500; + while (count-- && (tmp != ACX_VENDOR_ID)) { + mdelay (10); + tmp = read_reg32(adev, REG_ACX_VENDOR_ID); + } + + /* end what Windows driver does */ + + acxmem_reset_mac(adev); + + ecpu_ctrl = read_reg32(adev, IO_ACX_ECPU_CTRL) & 1; + if (!ecpu_ctrl) { + msg = "acx: eCPU is already running. "; + goto end_fail; + } + +#if 0 + if (read_reg16(adev, IO_ACX_SOR_CFG) & 2) { + /* eCPU most likely means "embedded CPU" */ + msg = "acx: eCPU did not start after boot from flash. "; + goto end_unlock; + } + + /* check sense on reset flags */ + if (read_reg16(adev, IO_ACX_SOR_CFG) & 0x10) { + pr_acx("%s: eCPU did not start after boot (SOR), " + "is this fatal?\n", adev->ndev->name); + } +#endif + + /* scan, if any, is stopped now, setting corresponding IRQ bit */ + adev->irq_status |= HOST_INT_SCAN_COMPLETE; + + /* need to know radio type before fw load */ + /* Need to wait for arrival of this information in a loop, + * most probably since eCPU runs some init code from EEPROM + * (started burst read in reset_mac()) which also + * sets the radio type ID */ + + count = 0xffff; + do { + hardware_info = read_reg16(adev, IO_ACX_EEPROM_INFORMATION); + if (!--count) { + msg = "acx: eCPU didn't indicate radio type"; + goto end_fail; + } + cpu_relax(); + } while (!(hardware_info & 0xff00)); /* radio type still zero? */ + + pr_acx("ACX radio type 0x%02x\n", (hardware_info >> 8) & 0xff); + /* printk("DEBUG: count %d\n", count); */ + adev->form_factor = hardware_info & 0xff; + adev->radio_type = hardware_info >> 8; + + acxmem_unlock(); + /* load the firmware */ + if (OK != acxmem_upload_fw(adev)) + goto end_fail; + acxmem_lock(); + + /* acx_s_mwait(10); this one really shouldn't be required */ + + /* now start eCPU by clearing bit */ + clear_regbits(adev, IO_ACX_ECPU_CTRL, 0x1); + log(L_DEBUG, "booted eCPU up and waiting for completion...\n"); + + /* Windows driver clears bit 0x200 in register 0x2A0 here */ + clear_regbits(adev, 0x2A0, 0x200); + + /* Windows driver sets bit 0x200 in ACX_GPIO_OUT here */ + set_regbits(adev, IO_ACX_GPIO_OUT, 0x200); + + acxmem_unlock(); + /* wait for eCPU bootup */ + if (OK != acxmem_verify_init(adev)) { + msg = "acx: timeout waiting for eCPU. "; + goto end_fail; + } + acxmem_lock(); + + log(L_DEBUG, "eCPU has woken up, card is ready to be configured\n"); + acxmem_init_mboxes(adev); + acxmem_write_cmd_type_status(adev, ACX1xx_CMD_RESET, 0); + + /* test that EEPROM is readable */ + acxmem_read_eeprom_area(adev); + + result = OK; + goto end; + + /* Finish error message. Indicate which function failed */ + end_fail: + + pr_acx("%sreset_dev() FAILED\n", msg); + + end: + + acxmem_unlock(); + FN_EXIT1(result); + return result; +} + +static int acxmem_verify_init(acx_device_t *adev) { + int result = NOT_OK; + unsigned long timeout; + u32 irqstat; + + acxmem_lock_flags; + + FN_ENTER; + + timeout = jiffies + 2 * HZ; + for (;;) { + acxmem_lock(); + irqstat = read_reg32(adev, IO_ACX_IRQ_STATUS_NON_DES); + if ((irqstat != 0xFFFFFFFF) && (irqstat & HOST_INT_FCS_THRESHOLD)) { + result = OK; + write_reg32(adev, IO_ACX_IRQ_ACK, HOST_INT_FCS_THRESHOLD); + acxmem_unlock(); + break; + } + acxmem_unlock(); + + if (time_after(jiffies, timeout)) + break; + /* Init may take up to ~0.5 sec total */ + acx_mwait(50); + } + + FN_EXIT1(result); + return result; +} + +/* + * Most of the acx specific pieces of hardware reset. + */ +static int acxmem_complete_hw_reset(acx_device_t *adev) { + acx111_ie_configoption_t co; + acxmem_lock_flags; + + /* NB: read_reg() reads may return bogus data before reset_dev(), + * since the firmware which directly controls large parts of the I/O + * registers isn't initialized yet. + * acx100 seems to be more affected than acx111 */ + if (OK != acxmem_reset_dev(adev)) + return -1; + + acxmem_lock(); + if (IS_ACX100(adev)) { + /* ACX100: configopt struct in cmd mailbox - directly after reset */ + acxmem_copy_from_slavemem(adev, (u8*) &co, (u32) adev->cmd_area, sizeof(co)); + } + acxmem_unlock(); + + if (OK != acx_init_mac(adev)) + return -3; + + if (IS_ACX111(adev)) { + /* ACX111: configopt struct needs to be queried after full init */ + acx_interrogate(adev, &co, ACX111_IE_CONFIG_OPTIONS); + } + + /* + * Set up transmit buffer administration + */ + acxmem_init_acx_txbuf(adev); + + acxmem_lock(); + /* + * Windows driver writes 0x01000000 to register 0x288, RADIO_CTL, if the form factor + * is 3. It also write protects the EEPROM by writing 1<<9 to GPIO_OUT + */ + if (adev->form_factor == 3) { + set_regbits(adev, 0x288, 0x01000000); + set_regbits(adev, 0x298, 1 << 9); + } + + /* TODO: merge them into one function, they are called just once and are the same for pci & usb */ + if (OK != acxmem_read_eeprom_byte(adev, 0x05, &adev->eeprom_version)) + return -2; + + acxmem_unlock(); + + acx_parse_configoption(adev, &co); + acx_get_firmware_version(adev); /* needs to be after acx_s_init_mac() */ + acx_display_hardware_details(adev); + + return 0; +} + +/* + * acxmem_l_reset_mac + * + * MAC will be reset + * Call context: reset_dev + */ +static void acxmem_reset_mac(acx_device_t *adev) { + int count; + FN_ENTER; + + // OW Bit setting done differently in pci.c + /* halt eCPU */ + set_regbits(adev, IO_ACX_ECPU_CTRL, 0x1); + + /* now do soft reset of eCPU, set bit */ + set_regbits(adev, IO_ACX_SOFT_RESET, 0x1); + log(L_DEBUG, "%s: enable soft reset...\n", __func__); + + /* Windows driver sleeps here for a while with this sequence */ + for (count = 0; count < 200; count++) { + udelay (50); + } + + /* now clear bit again: deassert eCPU reset */ + log(L_DEBUG, "%s: disable soft reset and go to init mode...\n", __func__); + clear_regbits(adev, IO_ACX_SOFT_RESET, 0x1); + + /* now start a burst read from initial EEPROM */ + set_regbits(adev, IO_ACX_EE_START, 0x1); + + /* + * Windows driver sleeps here for a while with this sequence + */ + for (count = 0; count < 200; count++) { + udelay (50); + } + + /* Windows driver writes 0x10000 to register 0x808 here */ + + write_reg32(adev, 0x808, 0x10000); + + FN_EXIT0; +} + +static void acxmem_up(struct ieee80211_hw *hw) { + acx_device_t *adev = ieee2adev(hw); + acxmem_lock_flags; + + FN_ENTER; + + acxmem_lock(); + acxmem_irq_enable(adev); + acxmem_unlock(); + + /* acx fw < 1.9.3.e has a hardware timer, and older drivers + ** used to use it. But we don't do that anymore, our OS + ** has reliable software timers */ + init_timer(&adev->mgmt_timer); + adev->mgmt_timer.function = acx_timer; + adev->mgmt_timer.data = (unsigned long) adev; + + /* Need to set ACX_STATE_IFACE_UP first, or else + ** timer won't be started by acx_set_status() */ + SET_BIT(adev->dev_state_mask, ACX_STATE_IFACE_UP); + + acx_start(adev); + + FN_EXIT0; +} + + +#if 0 +/*********************************************************************** + ** acxmem_i_set_multicast_list + ** FIXME: most likely needs refinement + */ +static void acxmem_i_set_multicast_list(struct net_device *ndev) { + acx_device_t *adev = ndev2adev(ndev); + unsigned long flags; + + FN_ENTER; + + acx_lock(adev, flags); + + /* firmwares don't have allmulti capability, + * so just use promiscuous mode instead in this case. */ + if (ndev->flags & (IFF_PROMISC|IFF_ALLMULTI)) { + SET_BIT(adev->rx_config_1, RX_CFG1_RCV_PROMISCUOUS); + CLEAR_BIT(adev->rx_config_1, RX_CFG1_FILTER_ALL_MULTI); + SET_BIT(adev->set_mask, SET_RXCONFIG); + /* let kernel know in case *we* needed to set promiscuous */ + ndev->flags |= (IFF_PROMISC|IFF_ALLMULTI); + } else { + CLEAR_BIT(adev->rx_config_1, RX_CFG1_RCV_PROMISCUOUS); + SET_BIT(adev->rx_config_1, RX_CFG1_FILTER_ALL_MULTI); + SET_BIT(adev->set_mask, SET_RXCONFIG); + ndev->flags &= ~(IFF_PROMISC|IFF_ALLMULTI); + } + + /* cannot update card settings directly here, atomic context */ + acx_schedule_task(adev, ACX_AFTER_IRQ_UPDATE_CARD_CFG); + + acx_unlock(adev, flags); + + FN_EXIT0; +} +#endif + + +/* + * BOM Other (Control Path) + * ================================================== + */ + +/* + * BOM Proc, Debug + * ================================================== + */ +int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { + const char *rtl, *thd, *ttl; + txdesc_t *txdesc; + u8 Ctl_8; + rxdesc_t *rxdesc; + int i; + u32 tmp, tmp2; + txdesc_t txd; + rxdesc_t rxd; + + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + +#if DUMP_MEM_DURING_DIAG > 0 + acxmem_dump_mem (adev, 0, 0x10000); + panic ("dump finished"); +#endif + + seq_printf(file, "** Rx buf **\n"); + rxdesc = adev->rxdesc_start; + if (rxdesc) + for (i = 0; i < RX_CNT; i++) { + rtl = (i == adev->rx_tail) ? " [tail]" : ""; + Ctl_8 = read_slavemem8(adev, (u32) &(rxdesc->Ctl_8)); + if (Ctl_8 & DESC_CTL_HOSTOWN) + seq_printf(file, "%02u (%02x) FULL %-10s", i, Ctl_8, rtl); + else + seq_printf(file, "%02u (%02x) empty%-10s", i, Ctl_8, rtl); + + //seq_printf(file, "\n"); + + acxmem_copy_from_slavemem(adev, (u8 *) &rxd, (u32) rxdesc, sizeof(rxd)); + seq_printf(file, + "%04x: %04x %04x %04x %04x %04x %04x %04x Ctl_8=%04x %04x %04x %04x %04x %04x %04x %04x\n", + (u32) rxdesc, + rxd.pNextDesc.v, + rxd.HostMemPtr.v, + rxd.ACXMemPtr.v, + rxd.rx_time, + rxd.total_length, + rxd.WEP_length, + rxd.WEP_ofs, + rxd.Ctl_8, + rxd.rate, + rxd.error, + rxd.SNR, + rxd.RxLevel, + rxd.queue_ctrl, + rxd.unknown, + rxd.unknown2); + rxdesc++; + } + + seq_printf(file, "** Tx buf (free %d, Ieee80211 queue: %s) **\n", + adev->acx_txbuf_free, acx_queue_stopped(adev->ieee) ? "STOPPED" + : "Running"); + + seq_printf(file, + "** Tx buf %d blocks total, %d available, free list head %04x\n", + adev->acx_txbuf_numblocks, adev->acx_txbuf_blocks_free, + adev->acx_txbuf_free); + + txdesc = adev->txdesc_start; + if (txdesc) { + for (i = 0; i < TX_CNT; i++) { + thd = (i == adev->tx_head) ? " [head]" : ""; + ttl = (i == adev->tx_tail) ? " [tail]" : ""; + acxmem_copy_from_slavemem(adev, (u8 *) &txd, (u32) txdesc, sizeof(txd)); + + Ctl_8 = read_slavemem8(adev, (u32) &(txdesc->Ctl_8)); + if (Ctl_8 & DESC_CTL_ACXDONE) + seq_printf(file, "%02u ready to free (%02X)%-7s%-7s", i, Ctl_8, thd, ttl); + else if (Ctl_8 & DESC_CTL_HOSTOWN) + seq_printf(file, "%02u available (%02X)%-7s%-7s", i, Ctl_8, thd, ttl); + else + seq_printf(file, "%02u busy (%02X)%-7s%-7s", i, Ctl_8, thd, ttl); + + seq_printf(file, + "%04x: %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %02x %02x %02x %02x " + "%02x %02x %02x %02x %04x: ", (u32) txdesc, + txd.pNextDesc.v, txd.HostMemPtr.v, txd.AcxMemPtr.v, + txd.tx_time, txd.total_length, txd.Reserved, + txd.dummy[0], txd.dummy[1], txd.dummy[2], + txd.dummy[3], txd.Ctl_8, txd.Ctl2_8, txd.error, + txd.ack_failures, txd.rts_failures, + txd.rts_ok, txd.u.r1.rate, + txd.u.r1.queue_ctrl, txd.queue_info); + + tmp = read_slavemem32(adev, (u32) & (txdesc->AcxMemPtr)); + seq_printf(file, " %04x: ", tmp); + + // Output allocated tx-buffer chain +#if 1 + if (tmp) { + while ((tmp2 = read_slavemem32(adev, (u32) tmp)) != 0x02000000) { + tmp2 = tmp2 << 5; + seq_printf(file, "%04x=%04x,", tmp, tmp2); + tmp = tmp2; + } + seq_printf(file, " %04x=%04x", tmp, tmp2); + } +#endif + seq_printf(file, "\n"); + +#if 0 + u8 buf[0x200]; + int j, k; + + if (txd.AcxMemPtr.v) { + acxmem_copy_from_slavemem(adev, buf, txd.AcxMemPtr.v, sizeof(buf)); + for (j = 0; (j < txd.total_length) && (j < (sizeof(buf) - 4)); j + += 16) { + seq_printf(file, " "); + for (k = 0; (k < 16) && (j + k < txd.total_length); k++) { + seq_printf(file, " %02x", buf[j + k + 4]); + } + seq_printf(file, "\n"); + } + } +#endif + + txdesc = acxmem_advance_txdesc(adev, txdesc, 1); + } + } + +#if 1 + // Tx-buffer list dump + seq_printf(file, "\n"); + seq_printf(file, "* Tx-buffer list dump\n"); + seq_printf(file, "acx_txbuf_numblocks=%d, acx_txbuf_blocks_free=%d, \n" + "acx_txbuf_start==%04x, acx_txbuf_free=%04x, memblocksize=%d\n", + adev->acx_txbuf_numblocks, adev->acx_txbuf_blocks_free, + adev->acx_txbuf_start, adev->acx_txbuf_free, adev->memblocksize); + + tmp = adev->acx_txbuf_start; + for (i = 0; i < adev->acx_txbuf_numblocks; i++) { + tmp2 = read_slavemem32(adev, (u32) tmp); + seq_printf(file, "%02d: %04x=%04x,%04x\n", i, tmp, tmp2, tmp2 << 5); + + tmp += adev->memblocksize; + } + seq_printf(file, "\n"); + // --- +#endif + + seq_printf(file, "\n" + "** Generic slave data **\n" + "irq_mask 0x%04x irq_status 0x%04x irq on acx 0x%04x\n" + + "txbuf_start 0x%p, txbuf_area_size %u\n" + // OW TODO Add also the acx tx_buf size available + "txdesc_size %u, txdesc_start 0x%p\n" + "txhostdesc_start 0x%p, txhostdesc_area_size %u\n" + "txbuf start 0x%04x, txbuf size %d\n" + + "rxdesc_start 0x%p\n" + "rxhostdesc_start 0x%p, rxhostdesc_area_size %u\n" + "rxbuf_start 0x%p, rxbuf_area_size %u\n", + + adev->irq_mask, adev->irq_status, read_reg32(adev, IO_ACX_IRQ_STATUS_NON_DES), + + adev->txbuf_start, adev->txbuf_area_size, adev->txdesc_size, + adev->txdesc_start, adev->txhostdesc_start, + adev->txhostdesc_area_size, adev->acx_txbuf_start, + adev->acx_txbuf_numblocks * adev->memblocksize, + + adev->rxdesc_start, + adev->rxhostdesc_start, adev->rxhostdesc_area_size, + adev->rxbuf_start, adev->rxbuf_area_size); + + acxmem_unlock(); + FN_EXIT0; + return 0; +} + +char *acxmem_proc_eeprom_output(int *length, acx_device_t *adev) { + char *p, *buf; + int i; + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + p = buf = kmalloc(0x400, GFP_KERNEL); + for (i = 0; i < 0x400; i++) { + acxmem_read_eeprom_byte(adev, i, p++); + } + *length = i; + + acxmem_unlock(); + FN_EXIT1(p - buf); + return buf; +} + +/* + * BOM Rx Path + * ================================================== + */ + +/* + * acxmem_l_process_rxdesc + * + * Called directly and only from the IRQ handler + */ +static void acxmem_process_rxdesc(acx_device_t *adev) { + register rxhostdesc_t *hostdesc; + register rxdesc_t *rxdesc; + unsigned count, tail; + u32 addr; + u8 Ctl_8; + + FN_ENTER; + + if (unlikely(acx_debug & L_BUFR)) + acx_log_rxbuffer(adev); + + /* First, have a loop to determine the first descriptor that's + * full, just in case there's a mismatch between our current + * rx_tail and the full descriptor we're supposed to handle. */ + tail = adev->rx_tail; + count = RX_CNT; + while (1) { + hostdesc = &adev->rxhostdesc_start[tail]; + rxdesc = &adev->rxdesc_start[tail]; + /* advance tail regardless of outcome of the below test */ + tail = (tail + 1) % RX_CNT; + + /* + * Unlike the PCI interface, where the ACX can write directly to + * the host descriptors, on the slave memory interface we have to + * pull these. All we really need to do is check the Ctl_8 field + * in the rx descriptor on the ACX, which should be 0x11000000 if + * we should process it. + */ + Ctl_8 = hostdesc->Ctl_16 = read_slavemem8(adev, (u32) &(rxdesc->Ctl_8)); + if ((Ctl_8 & DESC_CTL_HOSTOWN) && (Ctl_8 & DESC_CTL_ACXDONE)) + break; /* found it! */ + + if (unlikely(!--count)) /* hmm, no luck: all descs empty, bail out */ + goto end; + } + + /* now process descriptors, starting with the first we figured out */ + while (1) { + log(L_BUFR, "%s: rx: tail=%u Ctl_8=%02X\n", __func__, tail, Ctl_8); + /* + * If the ACX has CTL_RECLAIM set on this descriptor there + * is no buffer associated; it just wants us to tell it to + * reclaim the memory. + */ + if (!(Ctl_8 & DESC_CTL_RECLAIM)) { + + /* + * slave interface - pull data now + */ + hostdesc->length = read_slavemem16(adev, + (u32) &(rxdesc->total_length)); + + /* + * hostdesc->data is an rxbuffer_t, which includes header information, + * but the length in the data packet doesn't. The header information + * takes up an additional 12 bytes, so add that to the length we copy. + */ + addr = read_slavemem32(adev, (u32) &(rxdesc->ACXMemPtr)); + if (addr) { + /* + * How can &(rxdesc->ACXMemPtr) above ever be zero? Looks like we + * get that now and then - try to trap it for debug. + */ + if (addr & 0xffff0000) { + log(L_ANY, "%s: rxdesc 0x%08x\n", __func__, (u32) rxdesc); + acxmem_dump_mem(adev, 0, 0x10000); + panic("Bad access!"); + } + acxmem_chaincopy_from_slavemem(adev, (u8 *) hostdesc->data, addr, + hostdesc->length + (u32) &((rxbuffer_t *) 0)->hdr_a3); + + acx_process_rxbuf(adev, hostdesc->data); + } + } else { + log(L_ANY, "%s: rx reclaim only!\n", __func__); + } + + hostdesc->Status = 0; + + /* + * Let the ACX know we're done. + */ + CLEAR_BIT (Ctl_8, DESC_CTL_HOSTOWN); + SET_BIT (Ctl_8, DESC_CTL_HOSTDONE); + SET_BIT (Ctl_8, DESC_CTL_RECLAIM); + write_slavemem8(adev, (u32) &rxdesc->Ctl_8, Ctl_8); + + /* + * Now tell the ACX we've finished with the receive buffer so + * it can finish the reclaim. + */ + write_reg16(adev, IO_ACX_INT_TRIG, INT_TRIG_RXPRC); + + /* ok, descriptor is handled, now check the next descriptor */ + hostdesc = &adev->rxhostdesc_start[tail]; + rxdesc = &adev->rxdesc_start[tail]; + + Ctl_8 = hostdesc->Ctl_16 = read_slavemem8(adev, (u32) &(rxdesc->Ctl_8)); + + /* if next descriptor is empty, then bail out */ + if (!(Ctl_8 & DESC_CTL_HOSTOWN) || !(Ctl_8 & DESC_CTL_ACXDONE)) + break; + + tail = (tail + 1) % RX_CNT; + } + end: + adev->rx_tail = tail; + FN_EXIT0; +} + +/* + * BOM Tx Path + * ================================================== + */ + +/* + * acxmem_l_alloc_tx + * Actually returns a txdesc_t* ptr + * + * FIXME: in case of fragments, should allocate multiple descrs + * after figuring out how many we need and whether we still have + * sufficiently many. + */ + // OW TODO Align with pci.c +tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len) { + struct txdesc *txdesc; + unsigned head; + u8 ctl8; + static int txattempts = 0; + int blocks_needed; + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + if (unlikely(!adev->tx_free)) { + log(L_ANY, "%s: BUG: no free txdesc left\n", __func__); + /* + * Probably the ACX ignored a transmit attempt and now there's a packet + * sitting in the queue we think should be transmitting but the ACX doesn't + * know about. + * On the first pass, send the ACX a TxProc interrupt to try moving + * things along, and if that doesn't work (ie, we get called again) completely + * flush the transmit queue. + */ + if (txattempts < 10) { + txattempts++; + log(L_ANY, "%s: trying to wake up ACX\n", __func__); + write_reg16(adev, IO_ACX_INT_TRIG, INT_TRIG_TXPRC); + write_flush(adev); + } else { + txattempts = 0; + log(L_ANY, "%s: flushing transmit queue.\n", __func__); + acxmem_clean_txdesc_emergency(adev); + } + txdesc = NULL; + goto end; + } + + /* + * Make a quick check to see if there is transmit buffer space on + * the ACX. This can't guarantee there is enough space for the packet + * since we don't yet know how big it is, but it will prevent at least some + * annoyances. + */ + + /* OW 20090815 + * Make a detailed check of required tx_buf blocks, to avoid 'out of tx_buf' situation. + * + * The empty tx_buf and reuse trick in acxmem_l_tx_data doen't wotk well. + * I think it confused mac80211, that was supposing the packet was send, + * but actually it was dropped. According to mac80211 dropping should not happen, + * altough a bit of dropping seemed to be ok. + * + * What we do now is simpler and clean I think: + * - first check the number of required blocks + * - and if there are not enough: Stop the queue and report NOT_OK. + * + * Reporting NOT_OK here shouldn't be done neither according to mac80211, + * but it seems to work better here. + */ + + blocks_needed=acxmem_get_txbuf_space_needed(adev, len); + if (!(blocks_needed <= adev->acx_txbuf_blocks_free)) { + txdesc = NULL; + log(L_BUFT, "%s: !(blocks_needed <= adev->acx_txbuf_blocks_free), " + "len=%i, blocks_needed=%i, acx_txbuf_blocks_free=%i: " + "Stopping queue.\n", + __func__, + len, blocks_needed, adev->acx_txbuf_blocks_free); + acx_stop_queue(adev->ieee, NULL); + goto end; + } + + head = adev->tx_head; + /* + * txdesc points to ACX memory + */ + txdesc = acxmem_get_txdesc(adev, head); + ctl8 = read_slavemem8(adev, (u32) &(txdesc->Ctl_8)); + + /* + * If we don't own the buffer (HOSTOWN) it is certainly not free; however, + * we may have previously thought we had enough memory to send + * a packet, allocated the buffer then gave up when we found not enough + * transmit buffer space on the ACX. In that case, HOSTOWN and + * ACXDONE will both be set. + */ + + // TODO OW Check if this is correct + // TODO 20100115 Changed to DESC_CTL_ACXDONE_HOSTOWN like in pci.c + if (unlikely(DESC_CTL_HOSTOWN != (ctl8 & DESC_CTL_ACXDONE_HOSTOWN))) { + /* whoops, descr at current index is not free, so probably + * ring buffer already full */ + log(L_ANY, "%s: BUG: tx_head:%d Ctl8:0x%02X - failed to find free txdesc\n", + __func__, + head, ctl8); + txdesc = NULL; + goto end; + } + + /* Needed in case txdesc won't be eventually submitted for tx */ + write_slavemem8(adev, (u32) &(txdesc->Ctl_8), DESC_CTL_ACXDONE_HOSTOWN); + + adev->tx_free--; + log(L_BUFT, "%s: tx: got desc %u, %u remain\n", + __func__, head, adev->tx_free); + + /* returning current descriptor, so advance to next free one */ + adev->tx_head = (head + 1) % TX_CNT; + + end: + + acxmem_unlock(); + FN_EXIT0; + + return (tx_t*) txdesc; +} + +/* + * acxmem_l_dealloc_tx + * + * Clears out a previously allocatedvoid acxmem_l_dealloc_tx(tx_t *tx_opaque); + * transmit descriptor. + * The ACX can get confused if we skip transmit descriptors in the queue, + * so when we don't need a descriptor return it to its original + * state and move the queue head pointer back. + * + */ +void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque) { + /* + * txdesc is the address of the descriptor on the ACX. + */ + txdesc_t *txdesc = (txdesc_t*) tx_opaque; + txdesc_t tmptxdesc; + int index; + + acxmem_lock_flags; + acxmem_lock(); + + memset (&tmptxdesc, 0, sizeof(tmptxdesc)); + tmptxdesc.Ctl_8 = DESC_CTL_HOSTOWN | DESC_CTL_FIRSTFRAG; + tmptxdesc.u.r1.rate = 0x0a; + + /* + * Clear out all of the transmit descriptor except for the next pointer + */ + acxmem_copy_to_slavemem(adev, (u32) &(txdesc->HostMemPtr), + (u8 *) &(tmptxdesc.HostMemPtr), sizeof(tmptxdesc) + - sizeof(tmptxdesc.pNextDesc)); + + /* + * This is only called immediately after we've allocated, so we should + * be able to set the head back to this descriptor. + */ + index = ((u8*) txdesc - (u8*) adev->txdesc_start) / adev->txdesc_size; + pr_info("acx_dealloc: moving head from %d to %d\n", + adev->tx_head, index); + adev->tx_head = index; + + acxmem_unlock(); + +} + +void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque) { + return acxmem_get_txhostdesc(adev, (txdesc_t*) tx_opaque)->data; +} + +static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { + int blocks_needed; + + blocks_needed = len / (adev->memblocksize - 4); + if (len % (adev->memblocksize - 4)) + blocks_needed++; + + return (blocks_needed); +} + +/* + * Return an acx pointer to the next transmit data block. + */ +static u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count) { + u32 block, next, last_block; + int blocks_needed; + + /* + * Take 4 off the memory block size to account for the reserved word at the start of + * the block. + */ + blocks_needed=acxmem_get_txbuf_space_needed(adev, count); + + if (blocks_needed <= adev->acx_txbuf_blocks_free) { + /* + * Take blocks at the head of the free list. + */ + last_block = block = adev->acx_txbuf_free; + + /* + * Follow block pointers through the requested number of blocks both to + * find the new head of the free list and to set the flags for the blocks + * appropriately. + */ + while (blocks_needed--) { + /* + * Keep track of the last block of the allocation + */ + last_block = adev->acx_txbuf_free; + + /* + * Make sure the end control flag is not set. + */ + next = read_slavemem32(adev, adev->acx_txbuf_free) & 0x7ffff; + write_slavemem32(adev, adev->acx_txbuf_free, next); + + /* + * Update the new head of the free list + */ + adev->acx_txbuf_free = next << 5; + adev->acx_txbuf_blocks_free--; + + } + + /* + * Flag the last block both by clearing out the next pointer + * and marking the control field. + */ + write_slavemem32(adev, last_block, 0x02000000); + + /* + * If we're out of buffers make sure the free list pointer is NULL + */ + if (!adev->acx_txbuf_blocks_free) { + adev->acx_txbuf_free = 0; + } + } else { + block = 0; + } + + return block; +} + +/* + * Return buffer space back to the pool by following the next pointers until we find + * the block marked as the end. Point the last block to the head of the free list, + * then update the head of the free list to point to the newly freed memory. + * This routine gets called in interrupt context, so it shouldn't block to protect + * the integrity of the linked list. The ISR already holds the lock. + */ +static void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { + u32 cur, last, next; + + if ((blockptr >= adev->acx_txbuf_start) && + (blockptr <= adev->acx_txbuf_start + + (adev->acx_txbuf_numblocks - 1) * adev->memblocksize)) { + cur = blockptr; + do { + last = cur; + next = read_slavemem32(adev, cur); + + /* + * Advance to the next block in this allocation + */ + cur = (next & 0x7ffff) << 5; + + /* + * This block now counts as free. + */ + adev->acx_txbuf_blocks_free++; + } while (!(next & 0x02000000)); + + /* + * last now points to the last block of that allocation. Update the pointer + * in that block to point to the free list and reset the free list to the + * first block of the free call. If there were no free blocks, make sure + * the new end of the list marks itself as truly the end. + */ + if (adev->acx_txbuf_free) { + write_slavemem32(adev, last, adev->acx_txbuf_free >> 5); + } else { + write_slavemem32(adev, last, 0x02000000); + } + adev->acx_txbuf_free = blockptr; + } + +} + +/* + * Initialize the pieces managing the transmit buffer pool on the ACX. The transmit + * buffer is a circular queue with one 32 bit word reserved at the beginning of each + * block. The upper 13 bits are a control field, of which only 0x02000000 has any + * meaning. The lower 19 bits are the address of the next block divided by 32. + */ +static void acxmem_init_acx_txbuf(acx_device_t *adev) { + + /* + * acx100_s_init_memory_pools set up txbuf_start and txbuf_numblocks for us. + * All we need to do is reset the rest of the bookeeping. + */ + + adev->acx_txbuf_free = adev->acx_txbuf_start; + adev->acx_txbuf_blocks_free = adev->acx_txbuf_numblocks; + + /* + * Initialization leaves the last transmit pool block without a pointer back to + * the head of the list, but marked as the end of the list. That's how we want + * to see it, too, so leave it alone. This is only ever called after a firmware + * reset, so the ACX memory is in the state we want. + */ + +} + +/* Re-initialize tx-buffer list + */ +void acxmem_init_acx_txbuf2(acx_device_t *adev) { + + int i; + u32 adr, next_adr; + + adr = adev->acx_txbuf_start; + for (i = 0; i < adev->acx_txbuf_numblocks; i++) { + next_adr = adr + adev->memblocksize; + + // Last block is marked with 0x02000000 + if (i == adev->acx_txbuf_numblocks - 1) { + write_slavemem32(adev, adr, 0x02000000); + } + // Else write pointer to next block + else { + write_slavemem32(adev, adr, (next_adr >> 5)); + } + adr = next_adr; + } + + adev->acx_txbuf_free = adev->acx_txbuf_start; + adev->acx_txbuf_blocks_free = adev->acx_txbuf_numblocks; + +} + +static inline txdesc_t* +acxmem_get_txdesc(acx_device_t *adev, int index) { + return (txdesc_t*) (((u8*) adev->txdesc_start) + index * adev->txdesc_size); +} + +// static inline +txdesc_t* +acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc) { + return (txdesc_t*) (((u8*) txdesc) + inc * adev->txdesc_size); +} + +static txhostdesc_t* +acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { + int index = (u8*) txdesc - (u8*) adev->txdesc_start; + if (unlikely(ACX_DEBUG && (index % adev->txdesc_size))) { + pr_info("bad txdesc ptr %p\n", txdesc); + return NULL; + } + index /= adev->txdesc_size; + if (unlikely(ACX_DEBUG && (index >= TX_CNT))) { + pr_info("bad txdesc ptr %p\n", txdesc); + return NULL; + } + return &adev->txhostdesc_start[index * 2]; +} + +/* + * acxmem_l_tx_data + * + * Can be called from IRQ (rx -> (AP bridging or mgmt response) -> tx). + * Can be called from acx_i_start_xmit (data frames from net core). + * + * FIXME: in case of fragments, should loop over the number of + * pre-allocated tx descrs, properly setting up transfer data and + * CTL_xxx flags according to fragment number. + */ +void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, + struct ieee80211_tx_info *info, struct sk_buff *skb) { + /* + * txdesc is the address on the ACX + */ + txdesc_t *txdesc = (txdesc_t*) tx_opaque; + // FIXME Cleanup?: struct ieee80211_hdr *wireless_header; + txhostdesc_t *hostdesc1, *hostdesc2; + int rateset; + u8 Ctl_8, Ctl2_8; + int wlhdr_len; + u32 addr; + + acxmem_lock_flags; + + FN_ENTER; + acxmem_lock(); + + /* fw doesn't tx such packets anyhow */ + /* if (unlikely(len < WLAN_HDR_A3_LEN)) + goto end; + */ + + hostdesc1 = acxmem_get_txhostdesc(adev, txdesc); + // FIXME Cleanup?: wireless_header = (struct ieee80211_hdr *) hostdesc1->data; + + // wlhdr_len = ieee80211_hdrlen(le16_to_cpu(wireless_header->frame_control)); + wlhdr_len = WLAN_HDR_A3_LEN; + + /* modify flag status in separate variable to be able to write it back + * in one big swoop later (also in order to have less device memory + * accesses) */ + Ctl_8 = read_slavemem8(adev, (u32) &(txdesc->Ctl_8)); + Ctl2_8 = 0; /* really need to init it to 0, not txdesc->Ctl2_8, it seems */ + + hostdesc2 = hostdesc1 + 1; + + write_slavemem16(adev, (u32) &(txdesc->total_length), cpu_to_le16(len)); + hostdesc2->length = cpu_to_le16(len - wlhdr_len); + + /* DON'T simply set Ctl field to 0 here globally, + * it needs to maintain a consistent flag status (those are state flags!!), + * otherwise it may lead to severe disruption. Only set or reset particular + * flags at the exact moment this is needed... */ + + /* let chip do RTS/CTS handshaking before sending + * in case packet size exceeds threshold */ + + // if (len > adev->rts_threshold) + if (info->flags & IEEE80211_TX_RC_USE_RTS_CTS) + SET_BIT(Ctl2_8, DESC_CTL2_RTS); + else + CLEAR_BIT(Ctl2_8, DESC_CTL2_RTS); + + /* ACX111 */ + if (IS_ACX111(adev)) { + + // Build rateset for acx111 + rateset=acx111_tx_build_rateset(adev, txdesc, info); + + /* note that if !txdesc->do_auto, txrate->cur + ** has only one nonzero bit */ + txdesc->u.r2.rate111 = cpu_to_le16(rateset); + + /* WARNING: I was never able to make it work with prism54 AP. + ** It was falling down to 1Mbit where shortpre is not applicable, + ** and not working at all at "5,11 basic rates only" setting. + ** I even didn't see tx packets in radio packet capture. + ** Disabled for now --vda */ + /*| ((clt->shortpre && clt->cur!=RATE111_1) ? RATE111_SHORTPRE : 0) */ + +#ifdef TODO_FIGURE_OUT_WHEN_TO_SET_THIS + /* should add this to rate111 above as necessary */ + | (clt->pbcc511 ? RATE111_PBCC511 : 0) +#endif + hostdesc1->length = cpu_to_le16(len); + } + /* ACX100 */ + else { + + // Get rate for acx100, single rate only for acx100 + rateset = ieee80211_get_tx_rate(adev->ieee, info)->hw_value; + logf1(L_BUFT, "rateset=%u\n", rateset) + + write_slavemem8(adev, (u32) &(txdesc->u.r1.rate), (u8) rateset); + +#ifdef TODO_FIGURE_OUT_WHEN_TO_SET_THIS + if (clt->pbcc511) { + if (n == RATE100_5 || n == RATE100_11) + n |= RATE100_PBCC511; + } + + if (clt->shortpre && (clt->cur != RATE111_1)) + SET_BIT(Ctl_8, DESC_CTL_SHORT_PREAMBLE); /* set Short Preamble */ +#endif + + /* set autodma and reclaim and 1st mpdu */ + SET_BIT(Ctl_8, DESC_CTL_FIRSTFRAG); + +#if ACX_FRAGMENTATION + /* SET_BIT(Ctl2_8, DESC_CTL2_MORE_FRAG); cannot set it unconditionally, needs to be set for all non-last fragments */ +#endif + + hostdesc1->length = cpu_to_le16(wlhdr_len); + + /* + * Since we're not using autodma copy the packet data to the acx now. + * Even host descriptors point to the packet header, and the odd indexed + * descriptor following points to the packet data. + * + * The first step is to find free memory in the ACX transmit buffers. + * They don't necessarily map one to one with the transmit queue entries, + * so search through them starting just after the last one used. + */ + addr = acxmem_allocate_acx_txbuf_space(adev, len); + if (addr) { + acxmem_chaincopy_to_slavemem(adev, addr, hostdesc1->data, len); + } else { + /* + * Bummer. We thought we might have enough room in the transmit + * buffers to send this packet, but it turns out we don't. alloc_tx + * has already marked this transmit descriptor as HOSTOWN and ACXDONE, + * which means the ACX will hang when it gets to this descriptor unless + * we do something about it. Having a bubble in the transmit queue just + * doesn't seem to work, so we have to reset this transmit queue entry's + * state to its original value and back up our head pointer to point + * back to this entry. + */ + // OW FIXME Logging + pr_info("acxmem_l_tx_data: Bummer. Not enough room in the txbuf_space.\n"); + hostdesc1->length = 0; + hostdesc2->length = 0; + write_slavemem16(adev, (u32) &(txdesc->total_length), 0); + write_slavemem8(adev, (u32) &(txdesc->Ctl_8), DESC_CTL_HOSTOWN + | DESC_CTL_FIRSTFRAG); + adev->tx_head = ((u8*) txdesc - (u8*) adev->txdesc_start) + / adev->txdesc_size; + adev->tx_free++; + goto end; + } + /* + * Tell the ACX where the packet is. + */ + write_slavemem32(adev, (u32) &(txdesc->AcxMemPtr), addr); + + } + /* don't need to clean ack/rts statistics here, already + * done on descr cleanup */ + + /* clears HOSTOWN and ACXDONE bits, thus telling that the descriptors + * are now owned by the acx100; do this as LAST operation */ + CLEAR_BIT(Ctl_8, DESC_CTL_ACXDONE_HOSTOWN); + /* flush writes before we release hostdesc to the adapter here */ + //wmb(); + + + /* write back modified flags */ + //At this point Ctl_8 should just be FIRSTFRAG + CLEAR_BIT(Ctl2_8, DESC_CTL2_WEP); + write_slavemem8(adev, (u32) &(txdesc->Ctl2_8), Ctl2_8); + write_slavemem8(adev, (u32) &(txdesc->Ctl_8), Ctl_8); + /* unused: txdesc->tx_time = cpu_to_le32(jiffies); ... [truncated message content] |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:19
|
merge.h: add op-start, op-stop protos merge.c: drop "static" from op-start, op-stop protos pci.c, mem.c: #if0 op-start, op-stop, prettify ieee80211_ops. change .op_start, .op_stop in the acx(pci|mem)_hw_ops structs to reference acx_op_(start|stop) in merge.c This worked, before I rebased it back in attempt to clean up the mega-patch. too many conflicts to finish that, so I punted. no-bisect: compile errs Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 32 ++++++++++++++++++-------------- merge.c | 7 +++++-- merge.h | 2 ++ pci.c | 32 +++++++++++++++++--------------- 4 files changed, 42 insertions(+), 31 deletions(-) diff --git a/mem.c b/mem.c index 126954b..2f98f7d 100644 --- a/mem.c +++ b/mem.c @@ -3917,23 +3917,26 @@ static irqreturn_t acxmem_interrupt(int irq, void *dev_id) */ static const struct ieee80211_ops acxmem_hw_ops = { - .tx = acx_op_tx, - .conf_tx = acx_conf_tx, - .add_interface = acx_op_add_interface, - .remove_interface = acx_op_remove_interface, - .start = acxmem_op_start, - .configure_filter = acx_op_configure_filter, - .stop = acxmem_op_stop, - .config = acx_op_config, - .bss_info_changed = acx_op_bss_info_changed, - .set_key = acx_op_set_key, - .get_stats = acx_op_get_stats, + .tx = acx_op_tx, + .conf_tx = acx_conf_tx, + .start = acx_op_start, + .stop = acx_op_stop, + .config = acx_op_config, + .set_key = acx_op_set_key, + .get_stats = acx_op_get_stats, + + .add_interface = acx_op_add_interface, + .remove_interface = acx_op_remove_interface, + .configure_filter = acx_op_configure_filter, + .bss_info_changed = acx_op_bss_info_changed, + #if CONFIG_ACX_MAC80211_VERSION < KERNEL_VERSION(2, 6, 34) - .get_tx_stats = acx_e_op_get_tx_stats, + .get_tx_stats = acx_e_op_get_tx_stats, #endif - }; +}; -static int acxmem_op_start(struct ieee80211_hw *hw) { +#if 0 +STATick int acxmem_op_start(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); int result = OK; @@ -4002,6 +4005,7 @@ static void acxmem_op_stop(struct ieee80211_hw *hw) acx_sem_unlock(adev); FN_EXIT0; } +#endif /* * BOM Helpers diff --git a/merge.c b/merge.c index dc2d397..d3e1a52 100644 --- a/merge.c +++ b/merge.c @@ -3201,7 +3201,9 @@ static const struct ieee80211_ops acxmem_hw_ops = { #endif }; -static int acx_op_start(struct ieee80211_hw *hw) { +// static +int acx_op_start(struct ieee80211_hw *hw) +{ acx_device_t *adev = ieee2adev(hw); int result = OK; @@ -3234,7 +3236,8 @@ static int acx_op_start(struct ieee80211_hw *hw) { } // trivial diffs mem/pci -static void acx_op_stop(struct ieee80211_hw *hw) +// static +void acx_op_stop(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); acxmem_lock_flags; diff --git a/merge.h b/merge.h index efd462f..e1d1618 100644 --- a/merge.h +++ b/merge.h @@ -10,3 +10,5 @@ int acx_create_hostdesc_queues(acx_device_t *adev); void acx_log_rxbuffer(acx_device_t *adev); void acx_log_txbuffer(acx_device_t *adev); +void acx_op_stop(struct ieee80211_hw *hw); +int acx_op_start(struct ieee80211_hw *hw); diff --git a/pci.c b/pci.c index 47713a5..7fb8deb 100644 --- a/pci.c +++ b/pci.c @@ -155,8 +155,8 @@ static void acxpci_handle_info_irq(acx_device_t * adev); void acxpci_set_interrupt_mask(acx_device_t * adev); // Mac80211 Ops -static int acxpci_op_start(struct ieee80211_hw *hw); -static void acxpci_op_stop(struct ieee80211_hw *hw); +// static int acxpci_op_start(struct ieee80211_hw *hw); +// static void acxpci_op_stop(struct ieee80211_hw *hw); // Helpers void acxpci_power_led(acx_device_t * adev, int enable); @@ -2685,24 +2685,26 @@ void acxpci_set_interrupt_mask(acx_device_t * adev) */ static const struct ieee80211_ops acxpci_hw_ops = { - .tx = acx_op_tx, - .conf_tx = acx_conf_tx, - .add_interface = acx_op_add_interface, - .remove_interface = acx_op_remove_interface, - .start = acxpci_op_start, - .configure_filter = acx_op_configure_filter, - .stop = acxpci_op_stop, - .config = acx_op_config, - .bss_info_changed = acx_op_bss_info_changed, - .set_key = acx_op_set_key, - .get_stats = acx_op_get_stats, + .tx = acx_op_tx, + .conf_tx = acx_conf_tx, + .start = acx_op_start, + .stop = acx_op_stop, + .config = acx_op_config, + .set_key = acx_op_set_key, + .get_stats = acx_op_get_stats, + + .add_interface = acx_op_add_interface, + .remove_interface = acx_op_remove_interface, + .configure_filter = acx_op_configure_filter, + .bss_info_changed = acx_op_bss_info_changed, + #if CONFIG_ACX_MAC80211_VERSION < KERNEL_VERSION(2, 6, 34) .get_tx_stats = acx_e_op_get_tx_stats, #endif .set_tim = acx_op_set_tim, }; - +#if 0 static int acxpci_op_start(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); @@ -2767,7 +2769,7 @@ static void acxpci_op_stop(struct ieee80211_hw *hw) acx_sem_unlock(adev); FN_EXIT0; } - +#endif /* * BOM Helpers -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:20
|
lots of header tweaking; STATick suppression, //= of problem prototypes, rename of acxmem_*_eeprom(), whitespace, comment wraps. Lots of junk here, plowing ahead was debatable strategy. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 32 +++- mem.h | 47 +++-- merge.c | 656 ++++++++++++++++++++++++++++++++++----------------------------- merge.h | 2 +- pci.h | 3 +- 5 files changed, 408 insertions(+), 332 deletions(-) diff --git a/mem.c b/mem.c index 2f98f7d..47f9f85 100644 --- a/mem.c +++ b/mem.c @@ -152,7 +152,7 @@ static void acxmem_delete_dma_regions(acx_device_t *adev); static void *acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); // Firmware, EEPROM, Phy -int acxmem_upload_radio(acx_device_t *adev); +//= int acxmem_upload_radio(acx_device_t *adev); int acxmem_read_eeprom_byte(acx_device_t *adev, u32 addr, u8 *charbuf); #ifdef UNUSED int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, const u8 *charbuf); @@ -1222,7 +1222,7 @@ static inline void acxmem_read_eeprom_area(acx_device_t *adev) { #endif } -#if 1 // port soon to merge.c +#if 0 // port soon to merge.c /* * acxmem_s_read_phy_reg * @@ -1321,6 +1321,8 @@ int acxmem_write_phy_reg(acx_device_t *adev, u32 reg, u8 value) { * 1 firmware image corrupted * 0 success */ + +#if 0 // static int acxmem_write_fw(acx_device_t *adev, const firmware_image_t *fw_image, u32 offset) { @@ -1466,6 +1468,8 @@ int acxmem_validate_fw(acx_device_t *adev, return result; } +#endif + static int acxmem_upload_fw(acx_device_t *adev) { firmware_image_t *fw_image = NULL; int res = NOT_OK; @@ -1678,6 +1682,7 @@ acx_show_card_eeprom_id(acx_device_t *adev) * Also ifup/down works more reliable on the mem device. * */ +#if 0 int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *buffer, unsigned buflen, unsigned cmd_timeout, const char* cmdstr) { @@ -1883,6 +1888,7 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, FN_EXIT1(NOT_OK); return NOT_OK; } +#endif static inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, u16 status) { @@ -1956,6 +1962,7 @@ static inline void acxmem_init_mboxes(acx_device_t *adev) { * This resets the device using low level hardware calls * as well as uploads and verifies the firmware to the card */ +#if 0 int acxmem_reset_dev(acx_device_t *adev) { const char* msg = ""; int result = NOT_OK; @@ -2091,6 +2098,7 @@ int acxmem_reset_dev(acx_device_t *adev) { FN_EXIT1(result); return result; } +#endif static int acxmem_verify_init(acx_device_t *adev) { int result = NOT_OK; @@ -2298,6 +2306,7 @@ static void acxmem_i_set_multicast_list(struct net_device *ndev) { * BOM Proc, Debug * ================================================== */ +#if 0 int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { const char *rtl, *thd, *ttl; txdesc_t *txdesc; @@ -2494,6 +2503,8 @@ char *acxmem_proc_eeprom_output(int *length, acx_device_t *adev) { return buf; } +#endif + /* * BOM Rx Path * ================================================== @@ -2630,6 +2641,7 @@ static void acxmem_process_rxdesc(acx_device_t *adev) { * sufficiently many. */ // OW TODO Align with pci.c +#if 0 tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len) { struct txdesc *txdesc; unsigned head; @@ -2744,6 +2756,7 @@ tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len) { return (tx_t*) txdesc; } +#endif /* * acxmem_l_dealloc_tx @@ -2755,6 +2768,7 @@ tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len) { * state and move the queue head pointer back. * */ +#if 0 void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque) { /* * txdesc is the address of the descriptor on the ACX. @@ -2793,6 +2807,7 @@ void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque) { void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque) { return acxmem_get_txhostdesc(adev, (txdesc_t*) tx_opaque)->data; } +#endif static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { int blocks_needed; @@ -2939,6 +2954,8 @@ static void acxmem_init_acx_txbuf(acx_device_t *adev) { /* Re-initialize tx-buffer list */ +#if 0 + void acxmem_init_acx_txbuf2(acx_device_t *adev) { int i; @@ -2963,17 +2980,20 @@ void acxmem_init_acx_txbuf2(acx_device_t *adev) { adev->acx_txbuf_blocks_free = adev->acx_txbuf_numblocks; } +#endif static inline txdesc_t* acxmem_get_txdesc(acx_device_t *adev, int index) { return (txdesc_t*) (((u8*) adev->txdesc_start) + index * adev->txdesc_size); } +#if 0 // static inline txdesc_t* acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc) { return (txdesc_t*) (((u8*) txdesc) + inc * adev->txdesc_size); } +#endif static txhostdesc_t* acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { @@ -3000,6 +3020,7 @@ acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { * pre-allocated tx descrs, properly setting up transfer data and * CTL_xxx flags according to fragment number. */ +#if 0 void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, struct ieee80211_tx_info *info, struct sk_buff *skb) { /* @@ -3206,7 +3227,9 @@ void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, FN_EXIT0; } +#endif +#if 0 /* * acxmem_l_clean_txdesc @@ -3438,6 +3461,7 @@ void acxmem_update_queue_indicator(acx_device_t *adev, int txqueue) { local_irq_restore (flags); #endif } +#endif // OW TODO See if this is usable with mac80211 #if 0 @@ -3514,6 +3538,7 @@ static void acxmem_irq_disable(acx_device_t *adev) { /* Interrupt handler bottom-half */ // OW TODO Copy of pci: possible merging. +#if 0 void acxmem_irq_work(struct work_struct *work) { acx_device_t *adev = container_of(work, struct acx_device, irq_work); @@ -3606,6 +3631,7 @@ void acxmem_irq_work(struct work_struct *work) return; } +#endif /* * acxmem_handle_info_irq @@ -3684,6 +3710,7 @@ static void acxmem_handle_info_irq(acx_device_t *adev) { ); } +#if 0 void acxmem_set_interrupt_mask(acx_device_t *adev) { FN_ENTER; @@ -3732,6 +3759,7 @@ void acxmem_set_interrupt_mask(acx_device_t *adev) { FN_EXIT0; } +#endif // OW FIXME Old interrupt handler // --- diff --git a/mem.h b/mem.h index b8eb3e9..8120463 100644 --- a/mem.h +++ b/mem.h @@ -54,16 +54,19 @@ STATick void acx_show_card_eeprom_id(acx_device_t *adev); // CMDs (Control Path) int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *buffer, unsigned buflen, unsigned cmd_timeout, const char* cmdstr); -STATick inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, u16 status); -STATick u32 acxmem_read_cmd_type_status(acx_device_t *adev); -STATick inline void acxmem_init_mboxes(acx_device_t *adev); + +// STATick inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, u16 status); + +//= copied to merge.c +//= STATick u32 acxmem_read_cmd_type_status(acx_device_t *adev); +//= STATick inline void acxmem_init_mboxes(acx_device_t *adev); // Init, Configure (Control Path) -int acxmem_reset_dev(acx_device_t *adev); -STATick int acxmem_verify_init(acx_device_t *adev); -STATick int acxmem_complete_hw_reset(acx_device_t *adev); -STATick void acxmem_reset_mac(acx_device_t *adev); -STATick void acxmem_up(struct ieee80211_hw *hw); +//= int acxmem_reset_dev(acx_device_t *adev); +//= STATick int acxmem_verify_init(acx_device_t *adev); +// STATick int acxmem_complete_hw_reset(acx_device_t *adev); +// STATick void acxmem_reset_mac(acx_device_t *adev); +// STATick void acxmem_up(struct ieee80211_hw *hw); //STATick void acxmem_i_set_multicast_list(struct net_device *ndev); // Other (Control Path) @@ -73,21 +76,21 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev); char *acxmem_proc_eeprom_output(int *len, acx_device_t *adev); // Rx Path -STATick void acxmem_process_rxdesc(acx_device_t *adev); +//= STATick void acxmem_process_rxdesc(acx_device_t *adev); // Tx Path tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len); void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque); void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque); -STATick int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len); -STATick u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count); -STATick void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr); -STATick void acxmem_init_acx_txbuf(acx_device_t *adev); +//= STATick int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len); +//= STATick u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count); +//= STATick void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr); +//= STATick void acxmem_init_acx_txbuf(acx_device_t *adev); void acxmem_init_acx_txbuf2(acx_device_t *adev); -STATick inline txdesc_t *acxmem_get_txdesc(acx_device_t *adev, int index); +//= STATick inline txdesc_t *acxmem_get_txdesc(acx_device_t *adev, int index); STATick inline txdesc_t *acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc); -STATick txhostdesc_t *acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc); +//= STATick txhostdesc_t *acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc); void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, struct ieee80211_tx_info *info, struct sk_buff *skb); unsigned int acxmem_tx_clean_txdesc(acx_device_t *adev); @@ -98,8 +101,8 @@ int acx100mem_set_tx_level(acx_device_t *adev, u8 level_dbm); //STATick void acxmem_i_tx_timeout(struct net_device *ndev); // Irq Handling, Timer -STATick void acxmem_irq_enable(acx_device_t *adev); -STATick void acxmem_irq_disable(acx_device_t *adev); +//= STATick void acxmem_irq_enable(acx_device_t *adev); +//= STATick void acxmem_irq_disable(acx_device_t *adev); void acxmem_irq_work(struct work_struct *work); // STATick irqreturn_t acxmem_interrupt(int irq, void *dev_id); irqreturn_t acx_interrupt(int irq, void *dev_id); @@ -113,7 +116,7 @@ STATick void acxmem_op_stop(struct ieee80211_hw *hw); // Helpers void acxmem_power_led(acx_device_t *adev, int enable); // INLINE_IO int acxmem_adev_present(acx_device_t *adev); -STATick char acxmem_printable(char c); +//= STATick char acxmem_printable(char c); //STATick void update_link_quality_led(acx_device_t *adev); // Ioctls @@ -121,11 +124,11 @@ STATick char acxmem_printable(char c); //int acx100mem_ioctl_set_phy_amp_bias(struct ieee80211_hw *hw, struct iw_request_info *info, struct iw_param *vwrq, char *extra); // Driver, Module -STATick int __devinit acxmem_probe(struct platform_device *pdev); -STATick int __devexit acxmem_remove(struct platform_device *pdev); +//= STATick int __devinit acxmem_probe(struct platform_device *pdev); +//= STATick int __devexit acxmem_remove(struct platform_device *pdev); #ifdef CONFIG_PM -STATick int acxmem_e_suspend(struct platform_device *pdev, pm_message_t state); -STATick int acxmem_e_resume(struct platform_device *pdev); +//= STATick int acxmem_e_suspend(struct platform_device *pdev, pm_message_t state); +//= STATick int acxmem_e_resume(struct platform_device *pdev); #endif int __init acxmem_init_module(void); void __exit acxmem_cleanup_module(void); diff --git a/merge.c b/merge.c index d3e1a52..0b52de7 100644 --- a/merge.c +++ b/merge.c @@ -42,6 +42,7 @@ // merge adaptation help #include "pci.h" #include "mem.h" +#include "io-acx.h" // from mem.c:98 #define FW_NO_AUTO_INCREMENT 1 @@ -191,7 +192,8 @@ int acxmem_upload_radio(acx_device_t *adev) { char filename[sizeof("RADIONN.BIN")]; - snprintf(filename, sizeof(filename), "RADIO%02x.BIN", adev->radio_type); + snprintf(filename, sizeof(filename), "RADIO%02x.BIN", + adev->radio_type); return acx_upload_radio(adev, filename); } @@ -276,7 +278,7 @@ void acx_log_txbuffer(acx_device_t *adev) /* - * acxmem_read_eeprom_byte + * acx_read_eeprom_byte * * Function called to read an octet in the EEPROM. * @@ -289,7 +291,7 @@ void acx_log_txbuffer(acx_device_t *adev) * charbuf ptr to a char. This is where the read octet * will be stored */ -int acxmem_read_eeprom_byte(acx_device_t *adev, u32 addr, u8 *charbuf) +int acx_read_eeprom_byte(acx_device_t *adev, u32 addr, u8 *charbuf) { int result; int count; @@ -330,34 +332,28 @@ fail: * Note: this function sleeps only because of GFP_KERNEL alloc */ // unused in mem, used in pci -int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, +int acx_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, const u8 *charbuf) { u8 *data_verify = NULL; - unsigned long flags; + // unsigned long flags; // block warn unused int count, i; int result = NOT_OK; u16 gpio_orig; pr_acx("WARNING! I would write to EEPROM now. " - "Since I really DON'T want to unless you know " - "what you're doing (THIS CODE WILL PROBABLY " - "NOT WORK YET!), I will abort that now. And " - "definitely make sure to make a " - "/proc/driver/acx_wlan0_eeprom backup copy first!!! " - "(the EEPROM content includes the PCI config header!! " - "If you kill important stuff, then you WILL " - "get in trouble and people DID get in trouble already)\n"); + "Since I really DON'T want to unless you know " + "what you're doing (THIS CODE WILL PROBABLY " + "NOT WORK YET!), I will abort that now. And " + "definitely make sure to make a " + "/proc/driver/acx_wlan0_eeprom backup copy first!!! " + "(the EEPROM content includes the PCI config header!! " + "If you kill important stuff, then you WILL " + "get in trouble and people DID get in trouble already)\n"); return OK; FN_ENTER; - // TODO - move malloc down - data_verify = kmalloc(len, GFP_KERNEL); - if (!data_verify) { - goto end; - } - /* first we need to enable the OE (EEPROM Output Enable) GPIO line * to be able to write to the EEPROM. * NOTE: an EEPROM writing success has been reported, @@ -380,7 +376,7 @@ int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, while (read_reg16(adev, IO_ACX_EEPROM_CTL)) { if (unlikely(!--count)) { pr_acx("WARNING, DANGER!!! " - "Timeout waiting for EEPROM write\n"); + "Timeout waiting for EEPROM write\n"); goto end; } cpu_relax(); @@ -392,7 +388,9 @@ int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, write_flush(adev); /* now start a verification run */ - // kmalloc here. + data_verify = kmalloc(len, GFP_KERNEL); + if (!data_verify) + goto end; for (i = 0; i < len; i++) { write_reg32(adev, IO_ACX_EEPROM_CFG, 0); @@ -412,16 +410,16 @@ int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, data_verify[i] = read_reg16(adev, IO_ACX_EEPROM_DATA); } - if (0 == memcmp(charbuf, data_verify, len)) - result = OK; /* read data matches, success */ + if (!memcmp(charbuf, data_verify, len)) + result = OK; /* read data matches, success */ - end: kfree(data_verify); +end: FN_EXIT1(result); return result; } -static inline void acxmem_read_eeprom_area(acx_device_t *adev) +static inline void acx_read_eeprom_area(acx_device_t *adev) { #if ACX_DEBUG > 1 int offs; @@ -896,6 +894,68 @@ acx_show_card_eeprom_id(acx_device_t *adev) * ================================================== */ +static inline void +acxpci_write_cmd_type_status(acx_device_t * adev, u16 type, u16 status) +{ + FN_ENTER; + acx_writel(type | (status << 16), adev->cmd_area); + write_flush(adev); + FN_EXIT0; +} +static inline +void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, + u16 status) { + FN_ENTER; + write_slavemem32(adev, (u32) adev->cmd_area, type | (status << 16)); + write_flush(adev); + FN_EXIT0; +} + +static u32 acxmem_read_cmd_type_status(acx_device_t *adev) +{ + u32 cmd_type, cmd_status; + + FN_ENTER; + + cmd_type = read_slavemem32(adev, (u32) adev->cmd_area); + + cmd_status = (cmd_type >> 16); + cmd_type = (u16) cmd_type; + + log(L_DEBUG, "%s: " + "cmd_type:%04X cmd_status:%04X [%s]\n", + __func__, + cmd_type, cmd_status, + acx_cmd_status_str(cmd_status)); + + FN_EXIT1(cmd_status); + return cmd_status; +} + +static inline void acxmem_init_mboxes(acx_device_t *adev) +{ + u32 cmd_offs, info_offs; + + FN_ENTER; + + cmd_offs = read_reg32(adev, IO_ACX_CMD_MAILBOX_OFFS); + info_offs = read_reg32(adev, IO_ACX_INFO_MAILBOX_OFFS); + adev->cmd_area = (u8*) cmd_offs; + adev->info_area = (u8*) info_offs; + + // OW iobase2 not used in mem.c, in pci.c it is + /* + log(L_DEBUG, "iobase2=%p\n" + */ + log(L_DEBUG, "cmd_mbox_offset=%X cmd_area=%p\n" + "acx: info_mbox_offset=%X info_area=%p\n", + cmd_offs, adev->cmd_area, + info_offs, adev->info_area); + + FN_EXIT0; +} + + /* * acxmem_s_issue_cmd_timeo * @@ -946,13 +1006,13 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, buffer ? le16_to_cpu(((acx_ie_generic_t *)buffer)->type) : -1); if (!(adev->dev_state_mask & ACX_STATE_FW_LOADED)) { - pr_acxmem("%s: %s: firmware is not loaded yet, cannot execute commands!\n", + pr_acx("%s: %s: firmware is not loaded yet, cannot execute commands!\n", __func__, devname); goto bad; } if ((acx_debug & L_DEBUG) && (cmd != ACX1xx_CMD_INTERROGATE)) { - pr_acxmem("input buffer (len=%u):\n", buflen); + pr_acx("input buffer (len=%u):\n", buflen); acx_dump_bytes(buffer, buflen); } @@ -977,7 +1037,7 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, if (counter == 0) { /* the card doesn't get idle, we're in trouble */ - pr_acxmem("%s: %s: cmd_status is not IDLE: 0x%04X!=0\n", + pr_acx("%s: %s: cmd_status is not IDLE: 0x%04X!=0\n", __func__, devname, cmd_status); goto bad; } else if (counter < 190) { /* if waited >10ms... */ @@ -1032,7 +1092,8 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, do { irqtype = read_reg16(adev, IO_ACX_IRQ_STATUS_NON_DES); if (irqtype & HOST_INT_CMD_COMPLETE) { - write_reg16(adev, IO_ACX_IRQ_ACK, HOST_INT_CMD_COMPLETE); + write_reg16(adev, IO_ACX_IRQ_ACK, + HOST_INT_CMD_COMPLETE); break; } @@ -1051,55 +1112,56 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, /* put the card in IDLE state */ (IS_MEM(adev)) ? acxmem_write_cmd_type_status(adev, ACX1xx_CMD_RESET, 0) - ? acxpci_write_cmd_type_status(adev, 0, 0) + : acxpci_write_cmd_type_status(adev, 0, 0); /* Timed out! */ if (counter == 0) { log(L_ANY, "%s: %s: Timed out %s for CMD_COMPLETE. " - "irq bits:0x%04X irq_status:0x%04X timeout:%dms " - "cmd_status:%d (%s)\n", - __func__, devname, - (adev->irqs_active) ? "waiting" : "polling", - irqtype, adev->irq_status, cmd_timeout, - cmd_status, acx_cmd_status_str(cmd_status)); + "irq bits:0x%04X irq_status:0x%04X timeout:%dms " + "cmd_status:%d (%s)\n", + __func__, devname, + (adev->irqs_active) ? "waiting" : "polling", + irqtype, adev->irq_status, cmd_timeout, + cmd_status, acx_cmd_status_str(cmd_status)); log(L_ANY, "%s: " - "timeout: counter:%d cmd_timeout:%d cmd_timeout-counter:%d\n", - __func__, - counter, cmd_timeout, cmd_timeout - counter); + "timeout: counter:%d cmd_timeout:%d " + "cmd_timeout-counter:%d\n", + __func__, + counter, cmd_timeout, cmd_timeout - counter); if (read_reg16(adev, IO_ACX_IRQ_MASK) == 0xffff) { - log(L_ANY,"acxmem: firmware probably hosed - reloading: FIXME: Not implmemented\n"); + log(L_ANY, "acxmem: firmware probably hosed -" + " reloading: FIXME: Not implmemented\n"); FIXME(); } } else if (cmd_timeout - counter > 30) { /* if waited >30ms... */ log(L_CTL|L_DEBUG, "%s: " - "%s for CMD_COMPLETE %dms. count:%d. Please report\n", - __func__, - (adev->irqs_active) ? "waited" : "polled", - cmd_timeout - counter, counter); + "%s for CMD_COMPLETE %dms. count:%d. Please report\n", + __func__, + (adev->irqs_active) ? "waited" : "polled", + cmd_timeout - counter, counter); } logf1(L_CTL, "%s: cmd=%s, buflen=%u, timeout=%ums, type=0x%04X: %s\n", - devname, - cmdstr, buflen, cmd_timeout, - buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) : -1, - acx_cmd_status_str(cmd_status) + devname, cmdstr, buflen, cmd_timeout, + (buffer + ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) + : -1), + acx_cmd_status_str(cmd_status) ); if (cmd_status != 1) { /* it is not a 'Success' */ /* zero out result buffer - * WARNING: this will trash stack in case of illegally large input - * length! */ + * WARNING: this will trash stack in case of illegally + * large input length! */ if (buflen > 388) { - /* - * 388 is maximum command length - */ + /* 388 is maximum command length */ log(L_ANY, "%s: invalid length 0x%08x\n", - __func__, buflen); + __func__, buflen); buflen = 388; } p = (u8 *) buffer; @@ -1118,16 +1180,18 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, /* read in result parameters if needed */ if (buffer && buflen && (cmd == ACX1xx_CMD_INTERROGATE)) { - acxmem_copy_from_slavemem(adev, buffer, (u32) (adev->cmd_area + 4), buflen); + acxmem_copy_from_slavemem(adev, buffer, + (u32) (adev->cmd_area + 4), buflen); if (acx_debug & L_DEBUG) { - log(L_ANY, "%s: output buffer (len=%u): ", __func__, buflen); + log(L_ANY, "%s: output buffer (len=%u): ", + __func__, buflen); acx_dump_bytes(buffer, buflen); } } /* ok: */ log(L_DEBUG, "%s: %s: took %ld jiffies to complete\n", - __func__, cmdstr, jiffies - start); + __func__, cmdstr, jiffies - start); acxmem_unlock(); FN_EXIT1(OK); @@ -1137,10 +1201,10 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, /* Give enough info so that callers can avoid ** printing their own diagnostic messages */ logf1(L_ANY, "%s: cmd=%s, buflen=%u, timeout=%ums, type=0x%04X, status=%s: FAILED\n", - devname, - cmdstr, buflen, cmd_timeout, - buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) : -1, - acx_cmd_status_str(cmd_status) + devname, cmdstr, buflen, cmd_timeout, + (buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) + : -1), + acx_cmd_status_str(cmd_status) ); acxmem_unlock(); @@ -1148,62 +1212,91 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, return NOT_OK; } -static inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, - u16 status) { +#define REG_ACX_VENDOR_ID 0x900 +#define ACX_VENDOR_ID 0x8400104c + +static int acxmem_verify_init(acx_device_t *adev) { + int result = NOT_OK; + unsigned long timeout; + u32 irqstat; + + acxmem_lock_flags; + FN_ENTER; - write_slavemem32(adev, (u32) adev->cmd_area, type | (status << 16)); - write_flush(adev); - FN_EXIT0; + + timeout = jiffies + 2 * HZ; + for (;;) { + acxmem_lock(); + irqstat = read_reg32(adev, IO_ACX_IRQ_STATUS_NON_DES); + if ((irqstat != 0xFFFFFFFF) + && (irqstat & HOST_INT_FCS_THRESHOLD)) { + result = OK; + write_reg32(adev, IO_ACX_IRQ_ACK, + HOST_INT_FCS_THRESHOLD); + acxmem_unlock(); + break; + } + acxmem_unlock(); + + if (time_after(jiffies, timeout)) + break; + /* Init may take up to ~0.5 sec total */ + acx_mwait(50); + } + + FN_EXIT1(result); + return result; } -static u32 acxmem_read_cmd_type_status(acx_device_t *adev) { - u32 cmd_type, cmd_status; +/* + * BOM Init, Configure (Control Path) + * ================================================== + */ +/* + * acxmem_l_reset_mac + * + * MAC will be reset + * Call context: reset_dev + */ +static void acxmem_reset_mac(acx_device_t *adev) +{ + int count; FN_ENTER; - cmd_type = read_slavemem32(adev, (u32) adev->cmd_area); + // OW Bit setting done differently in pci.c + /* halt eCPU */ + set_regbits(adev, IO_ACX_ECPU_CTRL, 0x1); - cmd_status = (cmd_type >> 16); - cmd_type = (u16) cmd_type; + /* now do soft reset of eCPU, set bit */ + set_regbits(adev, IO_ACX_SOFT_RESET, 0x1); + log(L_DEBUG, "%s: enable soft reset...\n", __func__); - log(L_DEBUG, "%s: " - "cmd_type:%04X cmd_status:%04X [%s]\n", - __func__, - cmd_type, cmd_status, - acx_cmd_status_str(cmd_status)); + /* Windows driver sleeps here for a while with this sequence */ + for (count = 0; count < 200; count++) { + udelay (50); + } - FN_EXIT1(cmd_status); - return cmd_status; -} + /* now clear bit again: deassert eCPU reset */ + log(L_DEBUG, "%s: disable soft reset and go to init mode...\n", + __func__); + clear_regbits(adev, IO_ACX_SOFT_RESET, 0x1); -static inline void acxmem_init_mboxes(acx_device_t *adev) { - u32 cmd_offs, info_offs; + /* now start a burst read from initial EEPROM */ + set_regbits(adev, IO_ACX_EE_START, 0x1); - FN_ENTER; + /* Windows driver sleeps here for a while with this sequence */ + for (count = 0; count < 200; count++) { + udelay (50); + } - cmd_offs = read_reg32(adev, IO_ACX_CMD_MAILBOX_OFFS); - info_offs = read_reg32(adev, IO_ACX_INFO_MAILBOX_OFFS); - adev->cmd_area = (u8*) cmd_offs; - adev->info_area = (u8*) info_offs; + /* Windows driver writes 0x10000 to register 0x808 here */ - // OW iobase2 not used in mem.c, in pci.c it is - /* - log(L_DEBUG, "iobase2=%p\n" - */ - log(L_DEBUG, "cmd_mbox_offset=%X cmd_area=%p\n" - "acx: info_mbox_offset=%X info_area=%p\n", - cmd_offs, adev->cmd_area, - info_offs, adev->info_area); + write_reg32(adev, 0x808, 0x10000); FN_EXIT0; } - -/* - * BOM Init, Configure (Control Path) - * ================================================== - */ - /* * acxmem_s_reset_dev * @@ -1220,7 +1313,8 @@ static inline void acxmem_init_mboxes(acx_device_t *adev) { * This resets the device using low level hardware calls * as well as uploads and verifies the firmware to the card */ -int acxmem_reset_dev(acx_device_t *adev) { +int acxmem_reset_dev(acx_device_t *adev) +{ const char* msg = ""; int result = NOT_OK; u16 hardware_info; @@ -1280,7 +1374,7 @@ int acxmem_reset_dev(acx_device_t *adev) { /* check sense on reset flags */ if (read_reg16(adev, IO_ACX_SOR_CFG) & 0x10) { pr_acx("%s: eCPU did not start after boot (SOR), " - "is this fatal?\n", adev->ndev->name); + "is this fatal?\n", adev->ndev->name); } #endif @@ -1339,58 +1433,55 @@ int acxmem_reset_dev(acx_device_t *adev) { acxmem_write_cmd_type_status(adev, ACX1xx_CMD_RESET, 0); /* test that EEPROM is readable */ - acxmem_read_eeprom_area(adev); + //= acxmem_read_eeprom_area(adev); + acx_read_eeprom_area(adev); result = OK; goto end; /* Finish error message. Indicate which function failed */ - end_fail: - +end_fail: pr_acx("%sreset_dev() FAILED\n", msg); - end: - +end: acxmem_unlock(); FN_EXIT1(result); return result; } -static int acxmem_verify_init(acx_device_t *adev) { - int result = NOT_OK; - unsigned long timeout; - u32 irqstat; - - acxmem_lock_flags; +/* + * Initialize the pieces managing the transmit buffer pool on the ACX. + * The transmit buffer is a circular queue with one 32 bit word + * reserved at the beginning of each block. The upper 13 bits are a + * control field, of which only 0x02000000 has any meaning. The lower + * 19 bits are the address of the next block divided by 32. + */ - FN_ENTER; +static void acxmem_init_acx_txbuf(acx_device_t *adev) { - timeout = jiffies + 2 * HZ; - for (;;) { - acxmem_lock(); - irqstat = read_reg32(adev, IO_ACX_IRQ_STATUS_NON_DES); - if ((irqstat != 0xFFFFFFFF) && (irqstat & HOST_INT_FCS_THRESHOLD)) { - result = OK; - write_reg32(adev, IO_ACX_IRQ_ACK, HOST_INT_FCS_THRESHOLD); - acxmem_unlock(); - break; - } - acxmem_unlock(); + /* + * acx100_s_init_memory_pools set up txbuf_start and + * txbuf_numblocks for us. All we need to do is reset the + * rest of the bookeeping. + */ - if (time_after(jiffies, timeout)) - break; - /* Init may take up to ~0.5 sec total */ - acx_mwait(50); - } + adev->acx_txbuf_free = adev->acx_txbuf_start; + adev->acx_txbuf_blocks_free = adev->acx_txbuf_numblocks; - FN_EXIT1(result); - return result; + /* + * Initialization leaves the last transmit pool block without + * a pointer back to the head of the list, but marked as the + * end of the list. That's how we want to see it, too, so + * leave it alone. This is only ever called after a firmware + * reset, so the ACX memory is in the state we want. + */ } /* * Most of the acx specific pieces of hardware reset. */ -static int acxmem_complete_hw_reset(acx_device_t *adev) { +static int acxmem_complete_hw_reset(acx_device_t *adev) +{ acx111_ie_configoption_t co; acxmem_lock_flags; @@ -1404,7 +1495,8 @@ static int acxmem_complete_hw_reset(acx_device_t *adev) { acxmem_lock(); if (IS_ACX100(adev)) { /* ACX100: configopt struct in cmd mailbox - directly after reset */ - acxmem_copy_from_slavemem(adev, (u8*) &co, (u32) adev->cmd_area, sizeof(co)); + acxmem_copy_from_slavemem(adev, (u8*) &co, + (u32) adev->cmd_area, sizeof(co)); } acxmem_unlock(); @@ -1416,79 +1508,54 @@ static int acxmem_complete_hw_reset(acx_device_t *adev) { acx_interrogate(adev, &co, ACX111_IE_CONFIG_OPTIONS); } - /* - * Set up transmit buffer administration - */ + /* Set up transmit buffer administration */ acxmem_init_acx_txbuf(adev); acxmem_lock(); - /* - * Windows driver writes 0x01000000 to register 0x288, RADIO_CTL, if the form factor - * is 3. It also write protects the EEPROM by writing 1<<9 to GPIO_OUT + + /* Windows driver writes 0x01000000 to register 0x288, + * RADIO_CTL, if the form factor is 3. It also write protects + * the EEPROM by writing 1<<9 to GPIO_OUT */ if (adev->form_factor == 3) { set_regbits(adev, 0x288, 0x01000000); set_regbits(adev, 0x298, 1 << 9); } - /* TODO: merge them into one function, they are called just once and are the same for pci & usb */ + /* TODO: merge them into one function, they are called just + * once and are the same for pci & usb */ if (OK != acxmem_read_eeprom_byte(adev, 0x05, &adev->eeprom_version)) return -2; acxmem_unlock(); acx_parse_configoption(adev, &co); - acx_get_firmware_version(adev); /* needs to be after acx_s_init_mac() */ + acx_get_firmware_version(adev); + /* needs to be after acx_s_init_mac() */ acx_display_hardware_details(adev); return 0; } -/* - * acxmem_l_reset_mac - * - * MAC will be reset - * Call context: reset_dev - */ -static void acxmem_reset_mac(acx_device_t *adev) { - int count; +static void acxmem_irq_enable(acx_device_t *adev) { FN_ENTER; + write_reg16(adev, IO_ACX_IRQ_MASK, adev->irq_mask); + write_reg16(adev, IO_ACX_FEMR, 0x8000); + adev->irqs_active = 1; + FN_EXIT0; +} - // OW Bit setting done differently in pci.c - /* halt eCPU */ - set_regbits(adev, IO_ACX_ECPU_CTRL, 0x1); - - /* now do soft reset of eCPU, set bit */ - set_regbits(adev, IO_ACX_SOFT_RESET, 0x1); - log(L_DEBUG, "%s: enable soft reset...\n", __func__); - - /* Windows driver sleeps here for a while with this sequence */ - for (count = 0; count < 200; count++) { - udelay (50); - } - - /* now clear bit again: deassert eCPU reset */ - log(L_DEBUG, "%s: disable soft reset and go to init mode...\n", __func__); - clear_regbits(adev, IO_ACX_SOFT_RESET, 0x1); - - /* now start a burst read from initial EEPROM */ - set_regbits(adev, IO_ACX_EE_START, 0x1); - - /* - * Windows driver sleeps here for a while with this sequence - */ - for (count = 0; count < 200; count++) { - udelay (50); - } - - /* Windows driver writes 0x10000 to register 0x808 here */ - - write_reg32(adev, 0x808, 0x10000); +static void acxmem_irq_disable(acx_device_t *adev) { + FN_ENTER; + write_reg16(adev, IO_ACX_IRQ_MASK, HOST_INT_MASK_ALL); + write_reg16(adev, IO_ACX_FEMR, 0x0); + adev->irqs_active = 0; FN_EXIT0; } -static void acxmem_up(struct ieee80211_hw *hw) { +static void acxmem_up(struct ieee80211_hw *hw) +{ acx_device_t *adev = ieee2adev(hw); acxmem_lock_flags; @@ -1520,7 +1587,8 @@ static void acxmem_up(struct ieee80211_hw *hw) { ** acxmem_i_set_multicast_list ** FIXME: most likely needs refinement */ -static void acxmem_i_set_multicast_list(struct net_device *ndev) { +static void acxmem_i_set_multicast_list(struct net_device *ndev) +{ acx_device_t *adev = ndev2adev(ndev); unsigned long flags; @@ -1558,11 +1626,14 @@ static void acxmem_i_set_multicast_list(struct net_device *ndev) { * ================================================== */ +#define DUMP_MEM_DURING_DIAG 0 + /* * BOM Proc, Debug * ================================================== */ -int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { +int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) +{ const char *rtl, *thd, *ttl; txdesc_t *txdesc; u8 Ctl_8; @@ -1595,25 +1666,26 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { //seq_printf(file, "\n"); - acxmem_copy_from_slavemem(adev, (u8 *) &rxd, (u32) rxdesc, sizeof(rxd)); + acxmem_copy_from_slavemem(adev, (u8 *) &rxd, + (u32) rxdesc, sizeof(rxd)); seq_printf(file, - "%04x: %04x %04x %04x %04x %04x %04x %04x Ctl_8=%04x %04x %04x %04x %04x %04x %04x %04x\n", - (u32) rxdesc, - rxd.pNextDesc.v, - rxd.HostMemPtr.v, - rxd.ACXMemPtr.v, - rxd.rx_time, - rxd.total_length, - rxd.WEP_length, - rxd.WEP_ofs, - rxd.Ctl_8, - rxd.rate, - rxd.error, - rxd.SNR, - rxd.RxLevel, - rxd.queue_ctrl, - rxd.unknown, - rxd.unknown2); + "%04x: %04x %04x %04x %04x %04x %04x %04x Ctl_8=%04x %04x %04x %04x %04x %04x %04x %04x\n", + (u32) rxdesc, + rxd.pNextDesc.v, + rxd.HostMemPtr.v, + rxd.ACXMemPtr.v, + rxd.rx_time, + rxd.total_length, + rxd.WEP_length, + rxd.WEP_ofs, + rxd.Ctl_8, + rxd.rate, + rxd.error, + rxd.SNR, + rxd.RxLevel, + rxd.queue_ctrl, + rxd.unknown, + rxd.unknown2); rxdesc++; } @@ -1622,16 +1694,17 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { : "Running"); seq_printf(file, - "** Tx buf %d blocks total, %d available, free list head %04x\n", - adev->acx_txbuf_numblocks, adev->acx_txbuf_blocks_free, - adev->acx_txbuf_free); + "** Tx buf %d blocks total, %d available, free list head %04x\n", + adev->acx_txbuf_numblocks, adev->acx_txbuf_blocks_free, + adev->acx_txbuf_free); txdesc = adev->txdesc_start; if (txdesc) { for (i = 0; i < TX_CNT; i++) { thd = (i == adev->tx_head) ? " [head]" : ""; ttl = (i == adev->tx_tail) ? " [tail]" : ""; - acxmem_copy_from_slavemem(adev, (u8 *) &txd, (u32) txdesc, sizeof(txd)); + acxmem_copy_from_slavemem(adev, (u8 *) &txd, + (u32) txdesc, sizeof(txd)); Ctl_8 = read_slavemem8(adev, (u32) &(txdesc->Ctl_8)); if (Ctl_8 & DESC_CTL_ACXDONE) @@ -1642,23 +1715,26 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { seq_printf(file, "%02u busy (%02X)%-7s%-7s", i, Ctl_8, thd, ttl); seq_printf(file, - "%04x: %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %02x %02x %02x %02x " - "%02x %02x %02x %02x %04x: ", (u32) txdesc, - txd.pNextDesc.v, txd.HostMemPtr.v, txd.AcxMemPtr.v, - txd.tx_time, txd.total_length, txd.Reserved, - txd.dummy[0], txd.dummy[1], txd.dummy[2], - txd.dummy[3], txd.Ctl_8, txd.Ctl2_8, txd.error, - txd.ack_failures, txd.rts_failures, - txd.rts_ok, txd.u.r1.rate, - txd.u.r1.queue_ctrl, txd.queue_info); - - tmp = read_slavemem32(adev, (u32) & (txdesc->AcxMemPtr)); + "%04x: %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x %02x %02x %02x %02x " + "%02x %02x %02x %02x %04x: ", (u32) txdesc, + txd.pNextDesc.v, txd.HostMemPtr.v, + txd.AcxMemPtr.v, + txd.tx_time, txd.total_length, txd.Reserved, + txd.dummy[0], txd.dummy[1], txd.dummy[2], + txd.dummy[3], txd.Ctl_8, txd.Ctl2_8, txd.error, + txd.ack_failures, txd.rts_failures, + txd.rts_ok, txd.u.r1.rate, + txd.u.r1.queue_ctrl, txd.queue_info); + + tmp = read_slavemem32(adev, + (u32) & (txdesc->AcxMemPtr)); seq_printf(file, " %04x: ", tmp); // Output allocated tx-buffer chain #if 1 if (tmp) { - while ((tmp2 = read_slavemem32(adev, (u32) tmp)) != 0x02000000) { + while ((tmp2 = read_slavemem32(adev, + (u32) tmp)) != 0x02000000) { tmp2 = tmp2 << 5; seq_printf(file, "%04x=%04x,", tmp, tmp2); tmp = tmp2; @@ -1673,7 +1749,8 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { int j, k; if (txd.AcxMemPtr.v) { - acxmem_copy_from_slavemem(adev, buf, txd.AcxMemPtr.v, sizeof(buf)); + acxmem_copy_from_slavemem(adev, buf, + txd.AcxMemPtr.v, sizeof(buf)); for (j = 0; (j < txd.total_length) && (j < (sizeof(buf) - 4)); j += 16) { seq_printf(file, " "); @@ -1695,13 +1772,15 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { seq_printf(file, "* Tx-buffer list dump\n"); seq_printf(file, "acx_txbuf_numblocks=%d, acx_txbuf_blocks_free=%d, \n" "acx_txbuf_start==%04x, acx_txbuf_free=%04x, memblocksize=%d\n", - adev->acx_txbuf_numblocks, adev->acx_txbuf_blocks_free, - adev->acx_txbuf_start, adev->acx_txbuf_free, adev->memblocksize); + adev->acx_txbuf_numblocks, adev->acx_txbuf_blocks_free, + adev->acx_txbuf_start, adev->acx_txbuf_free, + adev->memblocksize); tmp = adev->acx_txbuf_start; for (i = 0; i < adev->acx_txbuf_numblocks; i++) { tmp2 = read_slavemem32(adev, (u32) tmp); - seq_printf(file, "%02d: %04x=%04x,%04x\n", i, tmp, tmp2, tmp2 << 5); + seq_printf(file, "%02d: %04x=%04x,%04x\n", + i, tmp, tmp2, tmp2 << 5); tmp += adev->memblocksize; } @@ -1885,6 +1964,23 @@ static void acxmem_process_rxdesc(acx_device_t *adev) { * ================================================== */ +static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { + int blocks_needed; + + blocks_needed = len / (adev->memblocksize - 4); + if (len % (adev->memblocksize - 4)) + blocks_needed++; + + return (blocks_needed); +} + +static inline +txdesc_t* acxmem_get_txdesc(acx_device_t *adev, int index) +{ + return (txdesc_t*) (((u8*) adev->txdesc_start) + + index * adev->txdesc_size); +} + /* * acxmem_l_alloc_tx * Actually returns a txdesc_t* ptr @@ -2054,19 +2150,6 @@ void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque) { } -void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque) { - return acxmem_get_txhostdesc(adev, (txdesc_t*) tx_opaque)->data; -} - -static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { - int blocks_needed; - - blocks_needed = len / (adev->memblocksize - 4); - if (len % (adev->memblocksize - 4)) - blocks_needed++; - - return (blocks_needed); -} /* * Return an acx pointer to the next transmit data block. @@ -2176,30 +2259,6 @@ static void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { } -/* - * Initialize the pieces managing the transmit buffer pool on the ACX. The transmit - * buffer is a circular queue with one 32 bit word reserved at the beginning of each - * block. The upper 13 bits are a control field, of which only 0x02000000 has any - * meaning. The lower 19 bits are the address of the next block divided by 32. - */ -static void acxmem_init_acx_txbuf(acx_device_t *adev) { - - /* - * acx100_s_init_memory_pools set up txbuf_start and txbuf_numblocks for us. - * All we need to do is reset the rest of the bookeeping. - */ - - adev->acx_txbuf_free = adev->acx_txbuf_start; - adev->acx_txbuf_blocks_free = adev->acx_txbuf_numblocks; - - /* - * Initialization leaves the last transmit pool block without a pointer back to - * the head of the list, but marked as the end of the list. That's how we want - * to see it, too, so leave it alone. This is only ever called after a firmware - * reset, so the ACX memory is in the state we want. - */ - -} /* Re-initialize tx-buffer list */ @@ -2228,10 +2287,6 @@ void acxmem_init_acx_txbuf2(acx_device_t *adev) { } -static inline txdesc_t* -acxmem_get_txdesc(acx_device_t *adev, int index) { - return (txdesc_t*) (((u8*) adev->txdesc_start) + index * adev->txdesc_size); -} // static inline txdesc_t* @@ -2471,6 +2526,9 @@ void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, FN_EXIT0; } +void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque) { + return acxmem_get_txhostdesc(adev, (txdesc_t*) tx_opaque)->data; +} /* * acxmem_l_clean_txdesc @@ -2759,23 +2817,6 @@ static void acxmem_i_tx_timeout(struct net_device *ndev) { * ================================================== */ -static void acxmem_irq_enable(acx_device_t *adev) { - FN_ENTER; - write_reg16(adev, IO_ACX_IRQ_MASK, adev->irq_mask); - write_reg16(adev, IO_ACX_FEMR, 0x8000); - adev->irqs_active = 1; - FN_EXIT0; -} - -static void acxmem_irq_disable(acx_device_t *adev) { - FN_ENTER; - - write_reg16(adev, IO_ACX_IRQ_MASK, HOST_INT_MASK_ALL); - write_reg16(adev, IO_ACX_FEMR, 0x0); - adev->irqs_active = 0; - FN_EXIT0; -} - /* Interrupt handler bottom-half */ // OW TODO Copy of pci: possible merging. void acxmem_irq_work(struct work_struct *work) @@ -3235,6 +3276,8 @@ int acx_op_start(struct ieee80211_hw *hw) return result; } + + // trivial diffs mem/pci // static void acx_op_stop(struct ieee80211_hw *hw) @@ -4034,7 +4077,7 @@ static int __devexit acxmem_remove(struct platform_device *pdev) { * expecting to see a working dev...) */ ieee80211_free_hw(adev->ieee); - pr_acxmem("%s done\n", __func__); + pr_acx("%s done\n", __func__); end_no_lock: FN_EXIT0; @@ -4042,15 +4085,17 @@ static int __devexit acxmem_remove(struct platform_device *pdev) { return(0); } +#if 0 // til-end /* * TODO: PM code needs to be fixed / debugged / tested. */ #ifdef CONFIG_PM static int -acxmem_e_suspend(struct platform_device *pdev, pm_message_t state) { - - struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); +acxmem_e_suspend(struct platform_device *pdev, pm_message_t state) +{ acx_device_t *adev; + struct ieee80211_hw *hw = (struct ieee80211_hw *) + platform_get_drvdata(pdev); FN_ENTER; pr_acx("suspend handler is experimental!\n"); @@ -4084,9 +4129,10 @@ acxmem_e_suspend(struct platform_device *pdev, pm_message_t state) { return OK; } -static int acxmem_e_resume(struct platform_device *pdev) { - - struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); +static int acxmem_e_resume(struct platform_device *pdev) +{ + struct ieee80211_hw *hw = (struct ieee80211_hw *) + platform_get_drvdata(pdev); acx_device_t *adev; FN_ENTER; @@ -4103,17 +4149,14 @@ static int acxmem_e_resume(struct platform_device *pdev) { acx_sem_lock(adev); - /* - * Turn on the ACX. - */ - // This should be done by the corresponding platform module, e.g. hx4700_acx.c - // hwdata->start_hw(); + /* Turn on the ACX */ + + /* This should be done by the corresponding platform module, + e.g. hx4700_acx.c hwdata->start_hw(); */ acxmem_complete_hw_reset(adev); - /* - * done by acx_s_set_defaults for initial startup - */ + /* done by acx_s_set_defaults for initial startup */ acxmem_set_interrupt_mask(adev); pr_acx("rsm: bringing up interface\n"); @@ -4143,17 +4186,16 @@ static int acxmem_e_resume(struct platform_device *pdev) { static struct platform_driver acxmem_driver = { - .driver = { - .name = "acx-mem", - }, - .probe = acxmem_probe, - .remove = __devexit_p(acxmem_remove), - - #ifdef CONFIG_PM - .suspend = acxmem_e_suspend, - .resume = acxmem_e_resume - #endif /* CONFIG_PM */ - + .driver = { + .name = "acx-mem", + }, + .probe = acxmem_probe, + .remove = __devexit_p(acxmem_remove), + +#ifdef CONFIG_PM + .suspend = acxmem_e_suspend, + .resume = acxmem_e_resume +#endif /* CONFIG_PM */ }; /* @@ -4200,7 +4242,7 @@ int __init acxmem_init_module(void) { void __exit acxmem_cleanup_module(void) { FN_ENTER; - pr_acxmem("cleanup_module\n"); + pr_acx("cleanup_module\n"); platform_driver_unregister(&acxmem_driver); FN_EXIT0; @@ -4209,3 +4251,5 @@ void __exit acxmem_cleanup_module(void) { MODULE_AUTHOR( "Todd Blumer <to...@sd...>" ); MODULE_DESCRIPTION( "ACX Slave Memory Driver" ); MODULE_LICENSE( "GPL" ); + +#endif // til-end diff --git a/merge.h b/merge.h index e1d1618..02c123b 100644 --- a/merge.h +++ b/merge.h @@ -1,7 +1,7 @@ irqreturn_t acx_interrupt(int irq, void *dev_id); -int acx_upload_radio(acx_device_t *adev); +// static int acx_upload_radio(acx_device_t *adev); int acxmem_upload_radio(acx_device_t *adev); int acxpci_upload_radio(acx_device_t *adev); diff --git a/pci.h b/pci.h index 2f88292..b7b6a1f 100644 --- a/pci.h +++ b/pci.h @@ -42,7 +42,8 @@ STATick int acxpci_upload_fw(acx_device_t * adev); // CMDs (Control Path) int acxpci_issue_cmd_timeo_debug(acx_device_t * adev, unsigned cmd, void *buffer, unsigned buflen, unsigned cmd_timeout, const char *cmdstr); -STATick inline void acxpci_write_cmd_type_status(acx_device_t * adev, u16 type, u16 status); +// coplied to merge.c +// STATick inline void acxpci_write_cmd_type_status(acx_device_t * adev, u16 type, u16 status); STATick u32 acxpci_read_cmd_type_status(acx_device_t *adev); STATick inline void acxpci_init_mboxes(acx_device_t * adev); -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:20
|
2nd half of rebase, manual re-edit of big-addition, adding hw-ops, op-start, op-stop, and rest. no-bisect: compile errs Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 1028 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1028 insertions(+), 0 deletions(-) diff --git a/merge.c b/merge.c index 71a5a50..dc2d397 100644 --- a/merge.c +++ b/merge.c @@ -3178,3 +3178,1031 @@ static irqreturn_t acxmem_interrupt(int irq, void *dev_id) #endif // --- + +/* + * BOM Mac80211 Ops + * ================================================== + */ + +static const struct ieee80211_ops acxmem_hw_ops = { + .tx = acx_op_tx, + .conf_tx = acx_conf_tx, + .add_interface = acx_op_add_interface, + .remove_interface = acx_op_remove_interface, + .start = acxmem_op_start, + .configure_filter = acx_op_configure_filter, + .stop = acxmem_op_stop, + .config = acx_op_config, + .bss_info_changed = acx_op_bss_info_changed, + .set_key = acx_op_set_key, + .get_stats = acx_op_get_stats, +#if CONFIG_ACX_MAC80211_VERSION < KERNEL_VERSION(2, 6, 34) + .get_tx_stats = acx_e_op_get_tx_stats, +#endif + }; + +static int acx_op_start(struct ieee80211_hw *hw) { + acx_device_t *adev = ieee2adev(hw); + int result = OK; + + FN_ENTER; + acx_sem_lock(adev); + + adev->initialized = 0; + + /* TODO: pci_set_power_state(pdev, PCI_D0); ? */ + + /* ifup device */ + acxmem_up(hw); // vs pci ?? + + /* We don't currently have to do anything else. + * The setup of the MAC should be subsequently completed via + * the mlme commands. + * Higher layers know we're ready from dev->start==1 and + * dev->tbusy==0. Our rx path knows to pass up received/ + * frames because of dev->flags&IFF_UP is true. + */ + + ieee80211_wake_queues(adev->ieee); + + adev->initialized = 1; + + acx_sem_unlock(adev); + FN_EXIT1(result); + + return result; +} + +// trivial diffs mem/pci +static void acx_op_stop(struct ieee80211_hw *hw) +{ + acx_device_t *adev = ieee2adev(hw); + acxmem_lock_flags; + + FN_ENTER; + acx_sem_lock(adev); + + acx_stop_queue(adev->ieee, "on ifdown"); + + /* disable all IRQs, release shared IRQ handler */ + acxmem_lock(); // null in pci + acxmem_irq_disable(adev); // pci + acxmem_unlock(); // + synchronize_irq(adev->irq); + + acx_sem_unlock(adev); + cancel_work_sync(&adev->irq_work); + cancel_work_sync(&adev->tx_work); + acx_sem_lock(adev); + + acx_tx_queue_flush(adev); + + del_timer_sync(&adev->mgmt_timer); + + CLEAR_BIT(adev->dev_state_mask, ACX_STATE_IFACE_UP); + + /* TODO: pci_set_power_state(pdev, PCI_D3hot); ? */ + + adev->initialized = 0; + + log(L_INIT, "acxpci: closed device\n"); + + acx_sem_unlock(adev); + FN_EXIT0; +} + +/* + * BOM Helpers + * ================================================== + */ +# if 0 // defer +void acxmem_power_led(acx_device_t *adev, int enable) { + u16 gpio_pled = IS_ACX111(adev) ? 0x0040 : 0x0800; + + /* A hack. Not moving message rate limiting to adev->xxx + * (it's only a debug message after all) */ + static int rate_limit = 0; + + if (rate_limit++ < 3) + log(L_IOCTL, "Please report in case toggling the power " + "LED doesn't work for your card!\n"); + if (enable) + write_reg16(adev, IO_ACX_GPIO_OUT, read_reg16(adev, IO_ACX_GPIO_OUT) + & ~gpio_pled); + else + write_reg16(adev, IO_ACX_GPIO_OUT, read_reg16(adev, IO_ACX_GPIO_OUT) + | gpio_pled); +} +#endif + +// identical +INLINE_IO int acxmem_adev_present(acx_device_t *adev) +{ + /* fast version (accesses the first register, IO_ACX_SOFT_RESET, + * which should be safe): */ + return acx_readl(adev->iobase) != 0xffffffff; +} + +static char acxmem_printable(char c) { + return ((c >= 20) && (c < 127)) ? c : '.'; +} + +// OW TODO +#if 0 +static void update_link_quality_led(acx_device_t *adev) { + int qual; + + qual = acx_signal_determine_quality(adev->wstats.qual.level, + adev->wstats.qual.noise); + if (qual > adev->brange_max_quality) + qual = adev->brange_max_quality; + + if (time_after(jiffies, adev->brange_time_last_state_change + + (HZ/2 - HZ/2 * (unsigned long)qual / adev->brange_max_quality ) )) { + acxmem_power_led(adev, (adev->brange_last_state == 0)); + adev->brange_last_state ^= 1; /* toggle */ + adev->brange_time_last_state_change = jiffies; + } +} +#endif + + +/* + * BOM Ioctls + * ================================================== + */ + +// OW TODO Not used in pci either !? +#if 0 +int acx111pci_ioctl_info(struct ieee80211_hw *hw, struct iw_request_info *info, + struct iw_param *vwrq, char *extra) { +#if ACX_DEBUG > 1 + + acx_device_t *adev = ieee2adev(hw); + rxdesc_t *rxdesc; + txdesc_t *txdesc; + rxhostdesc_t *rxhostdesc; + txhostdesc_t *txhostdesc; + struct acx111_ie_memoryconfig memconf; + struct acx111_ie_queueconfig queueconf; + unsigned long flags; + int i; + char memmap[0x34]; + char rxconfig[0x8]; + char fcserror[0x8]; + char ratefallback[0x5]; + + if (!(acx_debug & (L_IOCTL | L_DEBUG))) + return OK; + /* using printk() since we checked debug flag already */ + + acx_sem_lock(adev); + + if (!IS_ACX111(adev)) { + pr_acx("acx111-specific function called " + "with non-acx111 chip, aborting\n"); + goto end_ok; + } + + /* get Acx111 Memory Configuration */ + memset(&memconf, 0, sizeof(memconf)); + /* BTW, fails with 12 (Write only) error code. + ** Retained for easy testing of issue_cmd error handling :) */ + pr_info("Interrogating queue config\n"); + acx_interrogate(adev, &memconf, ACX1xx_IE_QUEUE_CONFIG); + pr_info("done with queue config\n"); + + /* get Acx111 Queue Configuration */ + memset(&queueconf, 0, sizeof(queueconf)); + pr_info("Interrogating mem config options\n"); + acx_interrogate(adev, &queueconf, ACX1xx_IE_MEMORY_CONFIG_OPTIONS); + pr_info("done with mem config options\n"); + + /* get Acx111 Memory Map */ + memset(memmap, 0, sizeof(memmap)); + pr_info("Interrogating mem map\n"); + acx_interrogate(adev, &memmap, ACX1xx_IE_MEMORY_MAP); + pr_info("done with mem map\n"); + + /* get Acx111 Rx Config */ + memset(rxconfig, 0, sizeof(rxconfig)); + pr_info("Interrogating rxconfig\n"); + acx_interrogate(adev, &rxconfig, ACX1xx_IE_RXCONFIG); + pr_info("done with queue rxconfig\n"); + + /* get Acx111 fcs error count */ + memset(fcserror, 0, sizeof(fcserror)); + pr_info("Interrogating fcs err count\n"); + acx_interrogate(adev, &fcserror, ACX1xx_IE_FCS_ERROR_COUNT); + pr_info("done with err count\n"); + + /* get Acx111 rate fallback */ + memset(ratefallback, 0, sizeof(ratefallback)); + pr_info("Interrogating rate fallback\n"); + acx_interrogate(adev, &ratefallback, ACX1xx_IE_RATE_FALLBACK); + pr_info("done with rate fallback\n"); + + /* force occurrence of a beacon interrupt */ + /* TODO: comment why is this necessary */ + write_reg16(adev, IO_ACX_HINT_TRIG, HOST_INT_BEACON); + + /* dump Acx111 Mem Configuration */ + pr_acx("dump mem config:\n" + "data read: %d, struct size: %d\n" + "Number of stations: %1X\n" + "Memory block size: %1X\n" + "tx/rx memory block allocation: %1X\n" + "count rx: %X / tx: %X queues\n" + "options %1X\n" + "fragmentation %1X\n" + "Rx Queue 1 Count Descriptors: %X\n" + "Rx Queue 1 Host Memory Start: %X\n" + "Tx Queue 1 Count Descriptors: %X\n" + "Tx Queue 1 Attributes: %X\n", + memconf.len, (int) sizeof(memconf), + memconf.no_of_stations, + memconf.memory_block_size, + memconf.tx_rx_memory_block_allocation, + memconf.count_rx_queues, memconf.count_tx_queues, + memconf.options, + memconf.fragmentation, + memconf.rx_queue1_count_descs, + acx2cpu(memconf.rx_queue1_host_rx_start), + memconf.tx_queue1_count_descs, memconf.tx_queue1_attributes); + + /* dump Acx111 Queue Configuration */ + pr_acx("dump queue head:\n" + "data read: %d, struct size: %d\n" + "tx_memory_block_address (from card): %X\n" + "rx_memory_block_address (from card): %X\n" + "rx1_queue address (from card): %X\n" + "tx1_queue address (from card): %X\n" + "tx1_queue attributes (from card): %X\n", + queueconf.len, (int) sizeof(queueconf), + queueconf.tx_memory_block_address, + queueconf.rx_memory_block_address, + queueconf.rx1_queue_address, + queueconf.tx1_queue_address, queueconf.tx1_attributes); + + /* dump Acx111 Mem Map */ + pr_acx("dump mem map:\n" + "data read: %d, struct size: %d\n" + "Code start: %X\n" + "Code end: %X\n" + "WEP default key start: %X\n" + "WEP default key end: %X\n" + "STA table start: %X\n" + "STA table end: %X\n" + "Packet template start: %X\n" + "Packet template end: %X\n" + "Queue memory start: %X\n" + "Queue memory end: %X\n" + "Packet memory pool start: %X\n" + "Packet memory pool end: %X\n" + "iobase: %p\n" + "iobase2: %p\n", + *((u16 *) &memmap[0x02]), (int) sizeof(memmap), + *((u32 *) &memmap[0x04]), + *((u32 *) &memmap[0x08]), + *((u32 *) &memmap[0x0C]), + *((u32 *) &memmap[0x10]), + *((u32 *) &memmap[0x14]), + *((u32 *) &memmap[0x18]), + *((u32 *) &memmap[0x1C]), + *((u32 *) &memmap[0x20]), + *((u32 *) &memmap[0x24]), + *((u32 *) &memmap[0x28]), + *((u32 *) &memmap[0x2C]), + *((u32 *) &memmap[0x30]), adev->iobase, + adev->iobase2); + + /* dump Acx111 Rx Config */ + pr_acx("dump rx config:\n" + "data read: %d, struct size: %d\n" + "rx config: %X\n" + "rx filter config: %X\n", + *((u16 *) &rxconfig[0x02]), (int) sizeof(rxconfig), + *((u16 *) &rxconfig[0x04]), *((u16 *) &rxconfig[0x06])); + + /* dump Acx111 fcs error */ + pr_acx("dump fcserror:\n" + "data read: %d, struct size: %d\n" + "fcserrors: %X\n", + *((u16 *) &fcserror[0x02]), (int) sizeof(fcserror), + *((u32 *) &fcserror[0x04])); + + /* dump Acx111 rate fallback */ + pr_acx("dump rate fallback:\n" + "data read: %d, struct size: %d\n" + "ratefallback: %X\n", + *((u16 *) &ratefallback[0x02]), + (int) sizeof(ratefallback), + *((u8 *) &ratefallback[0x04])); + + /* protect against IRQ */ + acx_lock(adev, flags); + + /* dump acx111 internal rx descriptor ring buffer */ + rxdesc = adev->rxdesc_start; + + /* loop over complete receive pool */ + if (rxdesc) + for (i = 0; i < RX_CNT; i++) { + pr_acx("\ndump internal rxdesc %d:\n" + "mem pos %p\n" + "next 0x%X\n" + "acx mem pointer (dynamic) 0x%X\n" + "CTL (dynamic) 0x%X\n" + "Rate (dynamic) 0x%X\n" + "RxStatus (dynamic) 0x%X\n" + "Mod/Pre (dynamic) 0x%X\n", + i, + rxdesc, + acx2cpu(rxdesc->pNextDesc), + acx2cpu(rxdesc->ACXMemPtr), + rxdesc->Ctl_8, rxdesc->rate, rxdesc->error, rxdesc->SNR); + rxdesc++; + } + + /* dump host rx descriptor ring buffer */ + + rxhostdesc = adev->rxhostdesc_start; + + /* loop over complete receive pool */ + if (rxhostdesc) + for (i = 0; i < RX_CNT; i++) { + pr_acx("\ndump host rxdesc %d:\n" + "mem pos %p\n" + "buffer mem pos 0x%X\n" + "buffer mem offset 0x%X\n" + "CTL 0x%X\n" + "Length 0x%X\n" + "next 0x%X\n" + "Status 0x%X\n", + i, + rxhostdesc, + acx2cpu(rxhostdesc->data_phy), + rxhostdesc->data_offset, + le16_to_cpu(rxhostdesc->Ctl_16), + le16_to_cpu(rxhostdesc->length), + acx2cpu(rxhostdesc->desc_phy_next), + rxhostdesc->Status); + rxhostdesc++; + } + + /* dump acx111 internal tx descriptor ring buffer */ + txdesc = adev->txdesc_start; + + /* loop over complete transmit pool */ + if (txdesc) + for (i = 0; i < TX_CNT; i++) { + pr_acx("\ndump internal txdesc %d:\n" + "size 0x%X\n" + "mem pos %p\n" + "next 0x%X\n" + "acx mem pointer (dynamic) 0x%X\n" + "host mem pointer (dynamic) 0x%X\n" + "length (dynamic) 0x%X\n" + "CTL (dynamic) 0x%X\n" + "CTL2 (dynamic) 0x%X\n" + "Status (dynamic) 0x%X\n" + "Rate (dynamic) 0x%X\n", + i, + (int) sizeof(struct txdesc), + txdesc, + acx2cpu(txdesc->pNextDesc), + acx2cpu(txdesc->AcxMemPtr), + acx2cpu(txdesc->HostMemPtr), + le16_to_cpu(txdesc->total_length), + txdesc->Ctl_8, + txdesc->Ctl2_8, + txdesc->error, + txdesc->u.r1.rate); + txdesc = acxmem_advance_txdesc(adev, txdesc, 1); + } + + /* dump host tx descriptor ring buffer */ + + txhostdesc = adev->txhostdesc_start; + + /* loop over complete host send pool */ + if (txhostdesc) + for (i = 0; i < TX_CNT * 2; i++) { + pr_acx("\ndump host txdesc %d:\n" + "mem pos %p\n" + "buffer mem pos 0x%X\n" + "buffer mem offset 0x%X\n" + "CTL 0x%X\n" + "Length 0x%X\n" + "next 0x%X\n" + "Status 0x%X\n", + i, + txhostdesc, + acx2cpu(txhostdesc->data_phy), + txhostdesc->data_offset, + le16_to_cpu(txhostdesc->Ctl_16), + le16_to_cpu(txhostdesc->length), + acx2cpu(txhostdesc->desc_phy_next), + le32_to_cpu(txhostdesc->Status)); + txhostdesc++; + } + + /* write_reg16(adev, 0xb4, 0x4); */ + + acx_unlock(adev, flags); + end_ok: + + acx_sem_unlock(adev); +#endif /* ACX_DEBUG */ + return OK; +} + +/*********************************************************************** + */ +int acx100mem_ioctl_set_phy_amp_bias(struct ieee80211_hw *hw, + struct iw_request_info *info, + struct iw_param *vwrq, char *extra) { + // OW + acx_device_t *adev = ieee2adev(hw); + unsigned long flags; + u16 gpio_old; + + if (!IS_ACX100(adev)) { + /* WARNING!!! + * Removing this check *might* damage + * hardware, since we're tweaking GPIOs here after all!!! + * You've been warned... + * WARNING!!! */ + pr_acx("sorry, setting bias level for non-acx100 " + "is not supported yet\n"); + return OK; + } + + if (*extra > 7) { + pr_acx("invalid bias parameter, range is 0-7\n"); + return -EINVAL; + } + + acx_sem_lock(adev); + + /* Need to lock accesses to [IO_ACX_GPIO_OUT]: + * IRQ handler uses it to update LED */ + acx_lock(adev, flags); + gpio_old = read_reg16(adev, IO_ACX_GPIO_OUT); + write_reg16(adev, IO_ACX_GPIO_OUT, + (gpio_old & 0xf8ff) | ((u16) *extra << 8)); + acx_unlock(adev, flags); + + log(L_DEBUG, "gpio_old: 0x%04X\n", gpio_old); + pr_acx("%s: PHY power amplifier bias: old:%d, new:%d\n", + wiphy_name(adev->ieee->wiphy), (gpio_old & 0x0700) >> 8, (unsigned char) *extra); + + acx_sem_unlock(adev); + + return OK; +} +#endif + + +/* + * BOM Driver, Module + * ================================================== + */ + +/* + * acxmem_e_probe + * + * Probe routine called when a PCI device w/ matching ID is found. + * Here's the sequence: + * - Allocate the PCI resources. + * - Read the PCMCIA attribute memory to make sure we have a WLAN card + * - Reset the MAC + * - Initialize the dev and wlan data + * - Initialize the MAC + * + * pdev - ptr to pci device structure containing info about pci configuration + * id - ptr to the device id entry that matched this device + */ +static int __devinit acxmem_probe(struct platform_device *pdev) { + + acx_device_t *adev = NULL; + const char *chip_name; + int result = -EIO; + int err; + int i; + + struct resource *iomem; + unsigned long addr_size = 0; + u8 chip_type; + + acxmem_lock_flags; + + struct ieee80211_hw *ieee; + + FN_ENTER; + + ieee = ieee80211_alloc_hw(sizeof(struct acx_device), &acxmem_hw_ops); + if (!ieee) { + pr_acx("could not allocate ieee80211 structure %s\n", pdev->name); + goto fail_ieee80211_alloc_hw; + } + SET_IEEE80211_DEV(ieee, &pdev->dev); + ieee->flags &= ~IEEE80211_HW_RX_INCLUDES_FCS; + /* TODO: mainline doesn't support the following flags yet */ + /* + ~IEEE80211_HW_MONITOR_DURING_OPER & + ~IEEE80211_HW_WEP_INCLUDE_IV; + */ + ieee->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) + | BIT(NL80211_IFTYPE_ADHOC); + ieee->queues = 1; + // OW TODO Check if RTS/CTS threshold can be included here + + /* TODO: although in the original driver the maximum value was 100, + * the OpenBSD driver assigns maximum values depending on the type of + * radio transceiver (i.e. Radia, Maxim, etc.). This value is always a + * positive integer which most probably indicates the gain of the AGC + * in the rx path of the chip, in dB steps (0.625 dB, for example?). + * The mapping of this rssi value to dBm is still unknown, but it can + * nevertheless be used as a measure of relative signal strength. The + * other two values, i.e. max_signal and max_noise, do not seem to be + * supported on my acx111 card (they are always 0), although iwconfig + * reports them (in dBm) when using ndiswrapper with the Windows XP + * driver. The GPL-licensed part of the AVM FRITZ!WLAN USB Stick + * driver sources (for the TNETW1450, though) seems to also indicate + * that only the RSSI is supported. In conclusion, the max_signal and + * max_noise values will not be initialised by now, as they do not + * seem to be supported or how to acquire them is still unknown. */ + + // We base signal quality on winlevel approach of previous driver + // TODO OW 20100615 This should into a common init code + ieee->flags |= IEEE80211_HW_SIGNAL_UNSPEC; + ieee->max_signal = 100; + + adev = ieee2adev(ieee); + + memset(adev, 0, sizeof(*adev)); + /** Set up our private interface **/ + spin_lock_init(&adev->spinlock); /* initial state: unlocked */ + /* We do not start with downed sem: we want PARANOID_LOCKING to work */ + mutex_init(&adev->mutex); + /* since nobody can see new netdev yet, we can as well + ** just _presume_ that we're under sem (instead of actually taking it): */ + /* acx_sem_lock(adev); */ + adev->ieee = ieee; + adev->pdev = pdev; + adev->bus_dev = &pdev->dev; + adev->dev_type = DEVTYPE_MEM; + + /** Finished with private interface **/ + + + /** begin board specific inits **/ + platform_set_drvdata(pdev, ieee); + + /* chiptype is u8 but id->driver_data is ulong + ** Works for now (possible values are 1 and 2) */ + chip_type = CHIPTYPE_ACX100; + /* acx100 and acx111 have different PCI memory regions */ + if (chip_type == CHIPTYPE_ACX100) { + chip_name = "ACX100"; + } else if (chip_type == CHIPTYPE_ACX111) { + chip_name = "ACX111"; + } else { + pr_acx("unknown chip type 0x%04X\n", chip_type); + goto fail_unknown_chiptype; + } + + pr_acx("found %s-based wireless network card\n", chip_name); + log(L_ANY, "initial debug setting is 0x%04X\n", acx_debug); + + adev->dev_type = DEVTYPE_MEM; + adev->chip_type = chip_type; + adev->chip_name = chip_name; + adev->io = (CHIPTYPE_ACX100 == chip_type) ? IO_ACX100 : IO_ACX111; + + iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); + addr_size = iomem->end - iomem->start + 1; + adev->membase = (volatile u32 *) iomem->start; + adev->iobase = (volatile u32 *) ioremap_nocache(iomem->start, addr_size); + if (!adev->iobase) { + result = -ENOMEM; + dev_err(adev->bus_dev, "Couldn't ioremap\n"); + goto fail_ioremap; + } + + i = platform_get_irq(pdev, 0); + if (i < 0) + return i; + adev->irq = i; + + log(L_ANY, "found an %s-based wireless network card, " + "irq:%d, " + "membase:0x%p, mem_size:%ld, " + "iobase:0x%p", + chip_name, + adev->irq, + adev->membase, addr_size, + adev->iobase); + log(L_ANY, "the initial debug setting is 0x%04X\n", acx_debug); + + if (adev->irq == 0) { + pr_acx("can't use IRQ 0\n"); + goto fail_request_irq; + } + + log(L_IRQ | L_INIT, "using IRQ %d\n", adev->irq); + /* request shared IRQ handler */ + if (request_irq(adev->irq, acx_interrupt, + IRQF_SHARED, + KBUILD_MODNAME, + adev)) { + pr_acx("%s: request_irq FAILED\n", wiphy_name(adev->ieee->wiphy)); + result = -EAGAIN; + goto fail_request_irq; + } + #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39) + set_irq_type(adev->irq, IRQF_TRIGGER_FALLING); + #else + irq_set_irq_type(adev->irq, IRQF_TRIGGER_FALLING); + #endif + log(L_ANY, "request_irq %d successful\n", adev->irq); + // Acx irqs shall be off and are enabled later in acxpci_s_up + acxmem_lock(); + acxmem_irq_disable(adev); + acxmem_unlock(); + + /* to find crashes due to weird driver access + * to unconfigured interface (ifup) */ + adev->mgmt_timer.function = (void(*)(unsigned long)) 0x0000dead; + +#if defined(NONESSENTIAL_FEATURES) + acx_show_card_eeprom_id(adev); +#endif /* NONESSENTIAL_FEATURES */ + + /* Device setup is finished, now start initializing the card */ + // --- + + acx_init_task_scheduler(adev); + + // Mac80211 Tx_queue + INIT_WORK(&adev->tx_work, acx_tx_work); + skb_queue_head_init(&adev->tx_queue); + + // OK init parts from pci.c are done in acxmem_complete_hw_reset(adev) + if (OK != acxmem_complete_hw_reset(adev)) + goto fail_complete_hw_reset; + + /* + * Set up default things for most of the card settings. + */ + acx_set_defaults(adev); + + /* Register the card, AFTER everything else has been set up, + * since otherwise an ioctl could step on our feet due to + * firmware operations happening in parallel or uninitialized data */ + + if (acx_proc_register_entries(ieee) != OK) + goto fail_proc_register_entries; + + /* Now we have our device, so make sure the kernel doesn't try + * to send packets even though we're not associated to a network yet */ + +// OW FIXME Check if acx_stop_queue, acx_carrier_off should be included +// OW Rest can be cleaned up +#if 0 + acx_stop_queue(ndev, "on probe"); + acx_carrier_off(ndev, "on probe"); +#endif + + pr_acx("net device %s, driver compiled " + "against wireless extensions %d and Linux %s\n", + wiphy_name(adev->ieee->wiphy), WIRELESS_EXT, UTS_RELEASE); + + MAC_COPY(adev->ieee->wiphy->perm_addr, adev->dev_addr); + + /** done with board specific setup **/ + + /* need to be able to restore PCI state after a suspend */ +#ifdef CONFIG_PM + // pci_save_state(pdev); +#endif + + err = acx_setup_modes(adev); + if (err) { + pr_acx("can't setup hwmode\n"); + goto fail_acx_setup_modes; + } + + err = ieee80211_register_hw(ieee); + if (OK != err) { + pr_acx("ieee80211_register_hw() FAILED: %d\n", err); + goto fail_ieee80211_register_hw; + } + +#if CMD_DISCOVERY + great_inquisitor(adev); +#endif + + result = OK; + goto done; + + + /* error paths: undo everything in reverse order... */ + fail_ieee80211_register_hw: + + fail_acx_setup_modes: + + fail_proc_register_entries: + acx_proc_unregister_entries(ieee); + + fail_complete_hw_reset: + + fail_request_irq: + free_irq(adev->irq, adev); + + fail_ioremap: + if (adev->iobase) + iounmap((void *)adev->iobase); + + fail_unknown_chiptype: + + fail_ieee80211_alloc_hw: + acxmem_delete_dma_regions(adev); + platform_set_drvdata(pdev, NULL); + ieee80211_free_hw(ieee); + + done: + + FN_EXIT1(result); + return result; +} + +/* + * acxmem_e_remove + * + * Shut device down (if not hot unplugged) + * and deallocate PCI resources for the acx chip. + * + * pdev - ptr to PCI device structure containing info about pci configuration + */ +static int __devexit acxmem_remove(struct platform_device *pdev) { + + struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); + acx_device_t *adev = ieee2adev(hw); + acxmem_lock_flags; + + FN_ENTER; + + if (!hw) { + log(L_DEBUG, "%s: card is unused. Skipping any release code\n", + __func__); + goto end_no_lock; + } + + // Unregister ieee80211 device + log(L_INIT, "removing device %s\n", wiphy_name(adev->ieee->wiphy)); + ieee80211_unregister_hw(adev->ieee); + CLEAR_BIT(adev->dev_state_mask, ACX_STATE_IFACE_UP); + + /* If device wasn't hot unplugged... */ + if (acxmem_adev_present(adev)) { + + /* disable both Tx and Rx to shut radio down properly */ + if (adev->initialized) { + acx_issue_cmd(adev, ACX1xx_CMD_DISABLE_TX, NULL, 0); + acx_issue_cmd(adev, ACX1xx_CMD_DISABLE_RX, NULL, 0); + adev->initialized = 0; + } + +#ifdef REDUNDANT + /* put the eCPU to sleep to save power + * Halting is not possible currently, + * since not supported by all firmware versions */ + acx_issue_cmd(adev, ACX100_CMD_SLEEP, NULL, 0); +#endif + + acxmem_lock(); + + /* disable power LED to save power :-) */ + log(L_INIT, "switching off power LED to save power\n"); + acxmem_power_led(adev, 0); + + /* stop our eCPU */ + if (IS_ACX111(adev)) { + /* FIXME: does this actually keep halting the eCPU? + * I don't think so... + */ + acxmem_reset_mac(adev); + } else { + u16 temp; + + /* halt eCPU */ + temp = read_reg16(adev, IO_ACX_ECPU_CTRL) | 0x1; + write_reg16(adev, IO_ACX_ECPU_CTRL, temp); + write_flush(adev); + } + + acxmem_unlock(); + } + + // Proc + acx_proc_unregister_entries(adev->ieee); + + // IRQs + acxmem_lock(); + acxmem_irq_disable(adev); + acxmem_unlock(); + + synchronize_irq(adev->irq); + free_irq(adev->irq, adev); + + /* finally, clean up PCI bus state */ + acxmem_delete_dma_regions(adev); + if (adev->iobase) + iounmap(adev->iobase); + + /* remove dev registration */ + platform_set_drvdata(pdev, NULL); + + /* Free netdev (quite late, + * since otherwise we might get caught off-guard + * by a netdev timeout handler execution + * expecting to see a working dev...) */ + ieee80211_free_hw(adev->ieee); + + pr_acxmem("%s done\n", __func__); + + end_no_lock: + FN_EXIT0; + + return(0); +} + +/* + * TODO: PM code needs to be fixed / debugged / tested. + */ +#ifdef CONFIG_PM +static int +acxmem_e_suspend(struct platform_device *pdev, pm_message_t state) { + + struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); + acx_device_t *adev; + + FN_ENTER; + pr_acx("suspend handler is experimental!\n"); + pr_acx("sus: dev %p\n", hw); + + /* if (!netif_running(ndev)) + goto end; + */ + + adev = ieee2adev(hw); + pr_info("sus: adev %p\n", adev); + + acx_sem_lock(adev); + + ieee80211_unregister_hw(hw); /* this one cannot sleep */ + acxmem_s_down(hw); + /* down() does not set it to 0xffff, but here we really want that */ + write_reg16(adev, IO_ACX_IRQ_MASK, 0xffff); + write_reg16(adev, IO_ACX_FEMR, 0x0); + acxmem_delete_dma_regions(adev); + + /* + * Turn the ACX chip off. + */ + // This should be done by the corresponding platform module, e.g. hx4700_acx.c + // hwdata->stop_hw(); + + acx_sem_unlock(adev); + + FN_EXIT0; + return OK; +} + +static int acxmem_e_resume(struct platform_device *pdev) { + + struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); + acx_device_t *adev; + + FN_ENTER; + + pr_acx("resume handler is experimental!\n"); + pr_acx("rsm: got dev %p\n", hw); + + /* if (!netif_running(ndev)) + return; + */ + + adev = ieee2adev(hw); + pr_acx("rsm: got adev %p\n", adev); + + acx_sem_lock(adev); + + /* + * Turn on the ACX. + */ + // This should be done by the corresponding platform module, e.g. hx4700_acx.c + // hwdata->start_hw(); + + acxmem_complete_hw_reset(adev); + + /* + * done by acx_s_set_defaults for initial startup + */ + acxmem_set_interrupt_mask(adev); + + pr_acx("rsm: bringing up interface\n"); + SET_BIT (adev->set_mask, GETSET_ALL); + acxmem_up(hw); + pr_acx("rsm: acx up done\n"); + + /* now even reload all card parameters as they were before suspend, + * and possibly be back in the network again already :-) + */ + /* - most settings updated in acxmem_s_up() */ + if (ACX_STATE_IFACE_UP & adev->dev_state_mask) { + adev->set_mask = GETSET_ALL; + acx_update_card_settings(adev); + pr_acx("rsm: settings updated\n"); + } + + ieee80211_register_hw(hw); + pr_acx("rsm: device attached\n"); + + acx_sem_unlock(adev); + + FN_EXIT0; + return OK; +} +#endif /* CONFIG_PM */ + + +static struct platform_driver acxmem_driver = { + .driver = { + .name = "acx-mem", + }, + .probe = acxmem_probe, + .remove = __devexit_p(acxmem_remove), + + #ifdef CONFIG_PM + .suspend = acxmem_e_suspend, + .resume = acxmem_e_resume + #endif /* CONFIG_PM */ + +}; + +/* + * acxmem_e_init_module + * + * Module initialization routine, called once at module load time + */ +int __init acxmem_init_module(void) { + int res; + + FN_ENTER; + +#if (ACX_IO_WIDTH==32) + pr_acx("compiled to use 32bit I/O access. " + "I/O timing issues might occur, such as " + "non-working firmware upload. Report them\n"); +#else + pr_acx("compiled to use 16bit I/O access only " + "(compatibility mode)\n"); +#endif + +#ifdef __LITTLE_ENDIAN +#define ENDIANNESS_STRING "acx: running on a little-endian CPU\n" +#else +#define ENDIANNESS_STRING "acx: running on a BIG-ENDIAN CPU\n" +#endif + log(L_INIT, + ENDIANNESS_STRING + "acx: Slave-memory module initialized, " + "waiting for cards to probe...\n" + ); + + res = platform_driver_register(&acxmem_driver); + FN_EXIT1(res); + return res; +} + +/* + * acxmem_e_cleanup_module + * + * Called at module unload time. This is our last chance to + * clean up after ourselves. + */ +void __exit acxmem_cleanup_module(void) { + FN_ENTER; + + pr_acxmem("cleanup_module\n"); + platform_driver_unregister(&acxmem_driver); + + FN_EXIT0; +} + +MODULE_AUTHOR( "Todd Blumer <to...@sd...>" ); +MODULE_DESCRIPTION( "ACX Slave Memory Driver" ); +MODULE_LICENSE( "GPL" ); -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:21
|
sdiff shows that merge.c version (added in mega-patch) looks good, so use it. merge.h: add proto, for pci.c merge.c: drop static, add proto above 1st caller (reorder later) change acxmem_handle_info_irq calls pci.c, mem.c: #if 0 this copy, comment out proto, call generic in acx(pci|mem)_irq_work Tested-by: jimc - modprobes, ifups, iwconfigs Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 9 +++++---- merge.c | 10 ++++++---- merge.h | 2 ++ pci.c | 7 ++++--- 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/mem.c b/mem.c index 82ed1c1..e2e706c 100644 --- a/mem.c +++ b/mem.c @@ -226,7 +226,7 @@ STATick void acxmem_irq_disable(acx_device_t *adev); void acxmem_irq_work(struct work_struct *work); // STATick irqreturn_t acxmem_interrupt(int irq, void *dev_id); irqreturn_t acx_interrupt(int irq, void *dev_id); -STATick void acxmem_handle_info_irq(acx_device_t *adev); +//= STATick void acxmem_handle_info_irq(acx_device_t *adev); void acxmem_set_interrupt_mask(acx_device_t *adev); // Mac80211 Ops @@ -3605,7 +3605,7 @@ void acxmem_irq_work(struct work_struct *work) /* HOST_INT_INFO */ if (irqmasked & HOST_INT_INFO) { - acxmem_handle_info_irq(adev); + acx_handle_info_irq(adev); } /* HOST_INT_SCAN_COMPLETE */ @@ -3652,7 +3652,7 @@ void acxmem_irq_work(struct work_struct *work) /* * acxmem_handle_info_irq */ - +#if 0 /* scan is complete. all frames now on the receive queue are valid */ #define INFO_SCAN_COMPLETE 0x0001 #define INFO_WEP_KEY_NOT_FOUND 0x0002 @@ -3725,6 +3725,7 @@ STATick void acxmem_handle_info_irq(acx_device_t *adev) { 0 : info_type] ); } +#endif #if 0 void acxmem_set_interrupt_mask(acx_device_t *adev) { @@ -3872,7 +3873,7 @@ STATick irqreturn_t acxmem_interrupt(int irq, void *dev_id) SET_BIT(adev->irq_status, HOST_INT_CMD_COMPLETE); } if (irqtype & HOST_INT_INFO) { - acxmem_handle_info_irq(adev); + acx_handle_info_irq(adev); } if (irqtype & HOST_INT_SCAN_COMPLETE) { log(L_IRQ, "got Scan_Complete IRQ\n"); diff --git a/merge.c b/merge.c index 0b52de7..3fed49c 100644 --- a/merge.c +++ b/merge.c @@ -2817,6 +2817,7 @@ static void acxmem_i_tx_timeout(struct net_device *ndev) { * ================================================== */ +void acx_handle_info_irq(acx_device_t *adev); // reorder later /* Interrupt handler bottom-half */ // OW TODO Copy of pci: possible merging. void acxmem_irq_work(struct work_struct *work) @@ -2869,7 +2870,7 @@ void acxmem_irq_work(struct work_struct *work) /* HOST_INT_INFO */ if (irqmasked & HOST_INT_INFO) { - acxmem_handle_info_irq(adev); + acx_handle_info_irq(adev); } /* HOST_INT_SCAN_COMPLETE */ @@ -2913,7 +2914,7 @@ void acxmem_irq_work(struct work_struct *work) } /* - * acxmem_handle_info_irq + * acx_handle_info_irq */ /* scan is complete. all frames now on the receive queue are valid */ @@ -2948,7 +2949,8 @@ void acxmem_irq_work(struct work_struct *work) after we set it once. Let's hope this will be fixed in firmware someday */ -static void acx_handle_info_irq(acx_device_t *adev) { +void acx_handle_info_irq(acx_device_t *adev) +{ #if ACX_DEBUG static const char * const info_type_msg[] = { "(unknown)", @@ -3137,7 +3139,7 @@ static irqreturn_t acxmem_interrupt(int irq, void *dev_id) SET_BIT(adev->irq_status, HOST_INT_CMD_COMPLETE); } if (irqtype & HOST_INT_INFO) { - acxmem_handle_info_irq(adev); + acx_handle_info_irq(adev); } if (irqtype & HOST_INT_SCAN_COMPLETE) { log(L_IRQ, "got Scan_Complete IRQ\n"); diff --git a/merge.h b/merge.h index 02c123b..0760e0b 100644 --- a/merge.h +++ b/merge.h @@ -12,3 +12,5 @@ void acx_log_txbuffer(acx_device_t *adev); void acx_op_stop(struct ieee80211_hw *hw); int acx_op_start(struct ieee80211_hw *hw); + +void acx_handle_info_irq(acx_device_t * adev); diff --git a/pci.c b/pci.c index e80fa9f..1501627 100644 --- a/pci.c +++ b/pci.c @@ -152,7 +152,7 @@ static void acxpci_irq_disable(acx_device_t * adev); void acxpci_irq_work(struct work_struct *work); // static irqreturn_t acxpci_interrupt(int irq, void *dev_id); irqreturn_t acx_interrupt(int irq, void *dev_id); -static void acxpci_handle_info_irq(acx_device_t * adev); +//= static void acxpci_handle_info_irq(acx_device_t * adev); void acxpci_set_interrupt_mask(acx_device_t * adev); // Mac80211 Ops @@ -2512,7 +2512,7 @@ void acxpci_irq_work(struct work_struct *work) /* HOST_INT_INFO */ if (irqmasked & HOST_INT_INFO) { - acxpci_handle_info_irq(adev); + acx_handle_info_irq(adev); } /* HOST_INT_SCAN_COMPLETE */ @@ -2560,7 +2560,7 @@ void acxpci_irq_work(struct work_struct *work) /* * acxpci_handle_info_irq */ - +#if 0 /* scan is complete. all frames now on the receive queue are valid */ #define INFO_SCAN_COMPLETE 0x0001 #define INFO_WEP_KEY_NOT_FOUND 0x0002 @@ -2635,6 +2635,7 @@ static void acxpci_handle_info_irq(acx_device_t * adev) 0 : info_type] ); } +#endif // handle-info-irq void acxpci_set_interrupt_mask(acx_device_t * adev) { -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:24
|
Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 4 ---- 1 files changed, 0 insertions(+), 4 deletions(-) diff --git a/merge.c b/merge.c index 3140448..d0ff6df 100644 --- a/merge.c +++ b/merge.c @@ -3351,10 +3351,6 @@ INLINE_IO int acxmem_adev_present(acx_device_t *adev) return acx_readl(adev->iobase) != 0xffffffff; } -static char acxmem_printable(char c) { - return ((c >= 20) && (c < 127)) ? c : '.'; -} - // OW TODO #if 0 static void update_link_quality_led(acx_device_t *adev) { -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:26
|
Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 42 +++++++++++++++++++++--------------------- 1 files changed, 21 insertions(+), 21 deletions(-) diff --git a/merge.c b/merge.c index 17399d6..a81bbed 100644 --- a/merge.c +++ b/merge.c @@ -2953,24 +2953,24 @@ void acx_handle_info_irq(acx_device_t *adev) { #if ACX_DEBUG static const char * const info_type_msg[] = { - "(unknown)", - "scan complete", - "WEP key not found", - "internal watchdog reset was done", - "failed to send powersave (NULL frame) notification to AP", - "encrypt/decrypt on a packet has failed", - "TKIP tx keys disabled", - "TKIP rx keys disabled", - "TKIP rx: key ID not found", - "???", - "???", - "???", - "???", - "???", - "???", - "???", - "TKIP IV value exceeds thresh" - }; + "(unknown)", + "scan complete", + "WEP key not found", + "internal watchdog reset was done", + "failed to send powersave (NULL frame) notification to AP", + "encrypt/decrypt on a packet has failed", + "TKIP tx keys disabled", + "TKIP rx keys disabled", + "TKIP rx: key ID not found", + "???", + "???", + "???", + "???", + "???", + "???", + "???", + "TKIP IV value exceeds thresh" + }; #endif u32 info_type, info_status; @@ -2989,10 +2989,10 @@ void acx_handle_info_irq(acx_device_t *adev) write_flush(adev); log(L_IRQ|L_CTL, "got Info IRQ: status %04X type %04X: %s\n", - info_status, info_type, - info_type_msg[(info_type >= ARRAY_SIZE(info_type_msg)) ? + info_status, info_type, + info_type_msg[(info_type >= ARRAY_SIZE(info_type_msg)) ? 0 : info_type] - ); + ); } void acxmem_set_interrupt_mask(acx_device_t *adev) { -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:26
|
fixups mostly in mem.c: more proto tweaks, STATick, restore INLINE_IO, include mem.h. Drop some "static"s in pci.c tested-by: jimc - modprobes, ifups, iwconfigs. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 254 ++++++++++++++++++++++++++++++++++------------------------------ pci.c | 6 +- 2 files changed, 139 insertions(+), 121 deletions(-) diff --git a/mem.c b/mem.c index 47f9f85..82ed1c1 100644 --- a/mem.c +++ b/mem.c @@ -71,6 +71,9 @@ #include "acx.h" #include "merge.h" +#include "mem.h" // which has STATick defn + +#define INLINE_IO static inline /* * BOM Config @@ -94,10 +97,6 @@ #define HX4700_FIRMWARE_CHECKSUM 0x0036862e #define HX4700_ALTERNATE_FIRMWARE_CHECKSUM 0x00368a75 -/* Pick one */ -/* #define INLINE_IO static */ -#define INLINE_IO static inline - #define FW_NO_AUTO_INCREMENT 1 #define MAX_IRQLOOPS_PER_JIFFY (20000/HZ) @@ -112,7 +111,8 @@ // static void acxmem_log_rxbuffer(const acx_device_t *adev); // static void acxmem_log_txbuffer(acx_device_t *adev); #if DUMP_MEM_DEFINED > 0 -static void acxmem_dump_mem(acx_device_t *adev, u32 start, int length); +//= static +void acxmem_dump_mem(acx_device_t *adev, u32 start, int length); #endif // Data Access @@ -134,10 +134,14 @@ INLINE_IO u8 read_slavemem8(acx_device_t *adev, u32 slave_address); INLINE_IO void write_slavemem16(acx_device_t *adev, u32 slave_address, u16 val); INLINE_IO u16 read_slavemem16(acx_device_t *adev, u32 slave_address); #endif -static void acxmem_copy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, int count); -static void acxmem_copy_to_slavemem(acx_device_t *adev, u32 destination, u8 *source, int count); -static void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 *source, int count); -static void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, int count); +//= static +void acxmem_copy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, int count); +//= static +void acxmem_copy_to_slavemem(acx_device_t *adev, u32 destination, u8 *source, int count); +//=static +void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 *source, int count); +//=static +void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, int count); // int acxmem_create_hostdesc_queues(acx_device_t *adev); // static @@ -145,11 +149,11 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev); // static int acxmem_create_tx_host_desc_queue(acx_device_t *adev); void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, u32 rx_queue_start); -static void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start); -static void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start); +STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start); +STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start); void acxmem_free_desc_queues(acx_device_t *adev); -static void acxmem_delete_dma_regions(acx_device_t *adev); -static void *acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); +STATick void acxmem_delete_dma_regions(acx_device_t *adev); +STATick void *acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); // Firmware, EEPROM, Phy //= int acxmem_upload_radio(acx_device_t *adev); @@ -157,31 +161,31 @@ int acxmem_read_eeprom_byte(acx_device_t *adev, u32 addr, u8 *charbuf); #ifdef UNUSED int acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, const u8 *charbuf); #endif -static inline void acxmem_read_eeprom_area(acx_device_t *adev); +STATick inline void acxmem_read_eeprom_area(acx_device_t *adev); int acxmem_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf); int acxmem_write_phy_reg(acx_device_t *adev, u32 reg, u8 value); -//static +//STATick int acxmem_write_fw(acx_device_t *adev, const firmware_image_t *fw_image, u32 offset); //static int acxmem_validate_fw(acx_device_t *adev, const firmware_image_t *fw_image, u32 offset); -static int acxmem_upload_fw(acx_device_t *adev); +STATick int acxmem_upload_fw(acx_device_t *adev); #if defined(NONESSENTIAL_FEATURES) -static void acx_show_card_eeprom_id(acx_device_t *adev); +STATick void acx_show_card_eeprom_id(acx_device_t *adev); #endif // CMDs (Control Path) int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *buffer, unsigned buflen, unsigned cmd_timeout, const char* cmdstr); -static inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, u16 status); -static u32 acxmem_read_cmd_type_status(acx_device_t *adev); -static inline void acxmem_init_mboxes(acx_device_t *adev); +STATick inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, u16 status); +STATick u32 acxmem_read_cmd_type_status(acx_device_t *adev); +STATick inline void acxmem_init_mboxes(acx_device_t *adev); // Init, Configure (Control Path) int acxmem_reset_dev(acx_device_t *adev); -static int acxmem_verify_init(acx_device_t *adev); -static int acxmem_complete_hw_reset(acx_device_t *adev); -static void acxmem_reset_mac(acx_device_t *adev); -static void acxmem_up(struct ieee80211_hw *hw); +STATick int acxmem_verify_init(acx_device_t *adev); +STATick int acxmem_complete_hw_reset(acx_device_t *adev); +STATick void acxmem_reset_mac(acx_device_t *adev); +STATick void acxmem_up(struct ieee80211_hw *hw); //static void acxmem_i_set_multicast_list(struct net_device *ndev); // Other (Control Path) @@ -191,22 +195,22 @@ int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev); char *acxmem_proc_eeprom_output(int *len, acx_device_t *adev); // Rx Path -static void acxmem_process_rxdesc(acx_device_t *adev); +STATick void acxmem_process_rxdesc(acx_device_t *adev); // Tx Path tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len); void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque); void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque); -static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len); -static u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count); -static void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr); -static void acxmem_init_acx_txbuf(acx_device_t *adev); +STATick int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len); +STATick u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count); +STATick void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr); +STATick void acxmem_init_acx_txbuf(acx_device_t *adev); void acxmem_init_acx_txbuf2(acx_device_t *adev); -static inline txdesc_t *acxmem_get_txdesc(acx_device_t *adev, int index); +STATick inline txdesc_t *acxmem_get_txdesc(acx_device_t *adev, int index); // static inline txdesc_t *acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc); -static txhostdesc_t *acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc); +STATick txhostdesc_t *acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc); void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, struct ieee80211_tx_info *info, struct sk_buff *skb); unsigned int acxmem_tx_clean_txdesc(acx_device_t *adev); @@ -217,22 +221,22 @@ int acx100mem_set_tx_level(acx_device_t *adev, u8 level_dbm); //static void acxmem_i_tx_timeout(struct net_device *ndev); // Irq Handling, Timer -static void acxmem_irq_enable(acx_device_t *adev); -static void acxmem_irq_disable(acx_device_t *adev); +STATick void acxmem_irq_enable(acx_device_t *adev); +STATick void acxmem_irq_disable(acx_device_t *adev); void acxmem_irq_work(struct work_struct *work); -// static irqreturn_t acxmem_interrupt(int irq, void *dev_id); +// STATick irqreturn_t acxmem_interrupt(int irq, void *dev_id); irqreturn_t acx_interrupt(int irq, void *dev_id); -static void acxmem_handle_info_irq(acx_device_t *adev); +STATick void acxmem_handle_info_irq(acx_device_t *adev); void acxmem_set_interrupt_mask(acx_device_t *adev); // Mac80211 Ops -static int acxmem_op_start(struct ieee80211_hw *hw); -static void acxmem_op_stop(struct ieee80211_hw *hw); +STATick int acxmem_op_start(struct ieee80211_hw *hw); +STATick void acxmem_op_stop(struct ieee80211_hw *hw); // Helpers void acxmem_power_led(acx_device_t *adev, int enable); INLINE_IO int acxmem_adev_present(acx_device_t *adev); -static char acxmem_printable(char c); +STATick char acxmem_printable(char c); //static void update_link_quality_led(acx_device_t *adev); // Ioctls @@ -240,11 +244,11 @@ static char acxmem_printable(char c); //int acx100mem_ioctl_set_phy_amp_bias(struct ieee80211_hw *hw, struct iw_request_info *info, struct iw_param *vwrq, char *extra); // Driver, Module -static int __devinit acxmem_probe(struct platform_device *pdev); -static int __devexit acxmem_remove(struct platform_device *pdev); +STATick int __devinit acxmem_probe(struct platform_device *pdev); +STATick int __devexit acxmem_remove(struct platform_device *pdev); #ifdef CONFIG_PM -static int acxmem_e_suspend(struct platform_device *pdev, pm_message_t state); -static int acxmem_e_resume(struct platform_device *pdev); +STATick int acxmem_e_suspend(struct platform_device *pdev, pm_message_t state); +STATick int acxmem_e_resume(struct platform_device *pdev); #endif int __init acxmem_init_module(void); void __exit acxmem_cleanup_module(void); @@ -310,7 +314,8 @@ static void acxmem_log_txbuffer(acx_device_t *adev) { #endif #if DUMP_MEM_DEFINED > 0 -static void acxmem_dump_mem(acx_device_t *adev, u32 start, int length) { +//= static +void acxmem_dump_mem(acx_device_t *adev, u32 start, int length) { int i; u8 buf[16]; @@ -342,8 +347,10 @@ static void acxmem_dump_mem(acx_device_t *adev, u32 start, int length) { * * TODO - rewrite using address autoincrement, handle partial words */ -static void acxmem_copy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, - int count) { +//= static +void acxmem_copy_from_slavemem(acx_device_t *adev, u8 *destination, + u32 source, int count) +{ u32 tmp = 0; u8 *ptmp = (u8 *) &tmp; @@ -386,8 +393,10 @@ static void acxmem_copy_from_slavemem(acx_device_t *adev, u8 *destination, u32 s * * TODO - rewrite using autoincrement, handle partial words */ -static void acxmem_copy_to_slavemem(acx_device_t *adev, u32 destination, u8 *source, - int count) { +//= static +void acxmem_copy_to_slavemem(acx_device_t *adev, u32 destination, + u8 *source, int count) +{ u32 tmp = 0; u8* ptmp = (u8 *) &tmp; static u8 src[512]; /* make static to avoid huge stack objects */ @@ -395,8 +404,9 @@ static void acxmem_copy_to_slavemem(acx_device_t *adev, u32 destination, u8 *sou ACXMEM_WARN_NOT_SPIN_LOCKED; /* - * For now, make sure the source is word-aligned by copying it to a word-aligned - * buffer. Someday rewrite to avoid the extra copy. + * For now, make sure the source is word-aligned by copying it + * to a word-aligned buffer. Someday rewrite to avoid the + * extra copy. */ if (count > sizeof(src)) { pr_acx("copy_to_slavemem: Warning! buffer overflow!\n"); @@ -437,12 +447,14 @@ static void acxmem_copy_to_slavemem(acx_device_t *adev, u32 destination, u8 *sou } /* - * Block copy to slave buffers using memory block chain mode. Copies to the ACX - * transmit buffer structure with minimal intervention on our part. - * Interrupts should be disabled when calling this. + * Block copy to slave buffers using memory block chain mode. Copies + * to the ACX transmit buffer structure with minimal intervention on + * our part. Interrupts should be disabled when calling this. */ -static void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 *source, - int count) { +//=static +void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, + u8 *source, int count) +{ u32 val; u32 *data = (u32 *) source; static u8 aligned_source[WLAN_A4FR_MAXLEN_WEP_FCS]; @@ -450,10 +462,10 @@ static void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 ACXMEM_WARN_NOT_SPIN_LOCKED; /* - * Warn if the pointers don't look right. Destination must fit in [23:5] with - * zero elsewhere and source should be 32 bit aligned. - * This should never happen since we're in control of both, but I want to know about - * it if it does. + * Warn if the pointers don't look right. Destination must + * fit in [23:5] with zero elsewhere and source should be 32 + * bit aligned. This should never happen since we're in + * control of both, but I want to know about it if it does. */ if ((destination & 0x00ffffe0) != destination) { pr_acx("chaincopy: destination block 0x%04x not aligned!\n", @@ -469,8 +481,9 @@ static void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 } /* - * SLV_MEM_CTL[17:16] = memory block chain mode with auto-increment - * SLV_MEM_CTL[5:2] = offset to data portion = 1 word + * SLV_MEM_CTL[17:16] = memory block chain mode with + * auto-increment SLV_MEM_CTL[5:2] = offset to data portion = + * 1 word */ val = 2 << 16 | 1 << 2; acx_writel (val, &adev->iobase[ACX_SLV_MEM_CTL]); @@ -489,8 +502,9 @@ static void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 acx_writel (val, &adev->iobase[ACX_SLV_MEM_ADDR]); /* - * Write the data to the slave data register, rounding up to the end - * of the word containing the last byte (hence the > 0) + * Write the data to the slave data register, rounding up to + * the end of the word containing the last byte (hence the > + * 0) */ while (count > 0) { acx_writel (*data++, &adev->iobase[ACX_SLV_MEM_DATA]); @@ -500,12 +514,15 @@ static void acxmem_chaincopy_to_slavemem(acx_device_t *adev, u32 destination, u8 } /* - * Block copy from slave buffers using memory block chain mode. Copies from the ACX - * receive buffer structures with minimal intervention on our part. - * Interrupts should be disabled when calling this. + * Block copy from slave buffers using memory block chain mode. + * Copies from the ACX receive buffer structures with minimal + * intervention on our part. Interrupts should be disabled when + * calling this. */ -static void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, - int count) { +//= static +void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, + u32 source, int count) +{ u32 val; u32 *data = (u32 *) destination; static u8 aligned_destination[WLAN_A4FR_MAXLEN_WEP_FCS]; @@ -514,10 +531,10 @@ static void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, ACXMEM_WARN_NOT_SPIN_LOCKED; /* - * Warn if the pointers don't look right. Destination must fit in [23:5] with - * zero elsewhere and source should be 32 bit aligned. - * Turns out the network stack sends unaligned things, so fix them before - * copying to the ACX. + * Warn if the pointers don't look right. Destination must + * fit in [23:5] with zero elsewhere and source should be 32 + * bit aligned. Turns out the network stack sends unaligned + * things, so fix them before copying to the ACX. */ if ((source & 0x00ffffe0) != source) { pr_acx("chaincopy: source block 0x%04x not aligned!\n", source); @@ -568,7 +585,6 @@ static void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, if ((u32) destination & 3) { memcpy(destination, aligned_destination, saved_count); } - } #if 0 @@ -778,7 +794,7 @@ void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, } -static void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) { +STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) { rxdesc_t *rxdesc; u32 mem_offs; int i; @@ -833,7 +849,7 @@ static void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) FN_EXIT0; } -static void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) { +STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) { txdesc_t *txdesc; u32 clr; int i; @@ -940,7 +956,7 @@ void acxmem_free_desc_queues(acx_device_t *adev) { FN_EXIT0; } -static void acxmem_delete_dma_regions(acx_device_t *adev) { +STATick void acxmem_delete_dma_regions(acx_device_t *adev) { //unsigned long flags; @@ -962,7 +978,7 @@ static void acxmem_delete_dma_regions(acx_device_t *adev) { FN_EXIT0; } -static void* +STATick void* acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg) { void *ptr; ptr = kmalloc(size, GFP_KERNEL); @@ -1207,7 +1223,7 @@ acxmem_s_write_eeprom(acx_device_t *adev, u32 addr, u32 len, } #endif /* UNUSED */ -static inline void acxmem_read_eeprom_area(acx_device_t *adev) { +STATick inline void acxmem_read_eeprom_area(acx_device_t *adev) { #if ACX_DEBUG > 1 int offs; u8 tmp; @@ -1470,7 +1486,7 @@ int acxmem_validate_fw(acx_device_t *adev, #endif -static int acxmem_upload_fw(acx_device_t *adev) { +STATick int acxmem_upload_fw(acx_device_t *adev) { firmware_image_t *fw_image = NULL; int res = NOT_OK; int try; @@ -1587,7 +1603,7 @@ typedef struct device_id { char *type; }device_id_t; -static const device_id_t +STATick const device_id_t device_ids[] = { { @@ -1617,7 +1633,7 @@ device_ids[] = } }; -static void +STATick void acx_show_card_eeprom_id(acx_device_t *adev) { unsigned char buffer[CARD_EEPROM_ID_SIZE]; @@ -1890,7 +1906,7 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, } #endif -static inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, +STATick inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, u16 status) { FN_ENTER; write_slavemem32(adev, (u32) adev->cmd_area, type | (status << 16)); @@ -1898,7 +1914,7 @@ static inline void acxmem_write_cmd_type_status(acx_device_t *adev, u16 type, FN_EXIT0; } -static u32 acxmem_read_cmd_type_status(acx_device_t *adev) { +STATick u32 acxmem_read_cmd_type_status(acx_device_t *adev) { u32 cmd_type, cmd_status; FN_ENTER; @@ -1918,7 +1934,7 @@ static u32 acxmem_read_cmd_type_status(acx_device_t *adev) { return cmd_status; } -static inline void acxmem_init_mboxes(acx_device_t *adev) { +STATick inline void acxmem_init_mboxes(acx_device_t *adev) { u32 cmd_offs, info_offs; FN_ENTER; @@ -2100,7 +2116,7 @@ int acxmem_reset_dev(acx_device_t *adev) { } #endif -static int acxmem_verify_init(acx_device_t *adev) { +STATick int acxmem_verify_init(acx_device_t *adev) { int result = NOT_OK; unsigned long timeout; u32 irqstat; @@ -2134,7 +2150,7 @@ static int acxmem_verify_init(acx_device_t *adev) { /* * Most of the acx specific pieces of hardware reset. */ -static int acxmem_complete_hw_reset(acx_device_t *adev) { +STATick int acxmem_complete_hw_reset(acx_device_t *adev) { acx111_ie_configoption_t co; acxmem_lock_flags; @@ -2194,7 +2210,7 @@ static int acxmem_complete_hw_reset(acx_device_t *adev) { * MAC will be reset * Call context: reset_dev */ -static void acxmem_reset_mac(acx_device_t *adev) { +STATick void acxmem_reset_mac(acx_device_t *adev) { int count; FN_ENTER; @@ -2232,7 +2248,7 @@ static void acxmem_reset_mac(acx_device_t *adev) { FN_EXIT0; } -static void acxmem_up(struct ieee80211_hw *hw) { +STATick void acxmem_up(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); acxmem_lock_flags; @@ -2264,7 +2280,7 @@ static void acxmem_up(struct ieee80211_hw *hw) { ** acxmem_i_set_multicast_list ** FIXME: most likely needs refinement */ -static void acxmem_i_set_multicast_list(struct net_device *ndev) { +STATick void acxmem_i_set_multicast_list(struct net_device *ndev) { acx_device_t *adev = ndev2adev(ndev); unsigned long flags; @@ -2515,7 +2531,7 @@ char *acxmem_proc_eeprom_output(int *length, acx_device_t *adev) { * * Called directly and only from the IRQ handler */ -static void acxmem_process_rxdesc(acx_device_t *adev) { +STATick void acxmem_process_rxdesc(acx_device_t *adev) { register rxhostdesc_t *hostdesc; register rxdesc_t *rxdesc; unsigned count, tail; @@ -2809,7 +2825,7 @@ void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque) { } #endif -static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { +STATick int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { int blocks_needed; blocks_needed = len / (adev->memblocksize - 4); @@ -2822,7 +2838,7 @@ static int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len) { /* * Return an acx pointer to the next transmit data block. */ -static u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count) { +STATick u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count) { u32 block, next, last_block; int blocks_needed; @@ -2889,7 +2905,7 @@ static u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count) { * This routine gets called in interrupt context, so it shouldn't block to protect * the integrity of the linked list. The ISR already holds the lock. */ -static void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { +STATick void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { u32 cur, last, next; if ((blockptr >= adev->acx_txbuf_start) && @@ -2933,7 +2949,7 @@ static void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { * block. The upper 13 bits are a control field, of which only 0x02000000 has any * meaning. The lower 19 bits are the address of the next block divided by 32. */ -static void acxmem_init_acx_txbuf(acx_device_t *adev) { +STATick void acxmem_init_acx_txbuf(acx_device_t *adev) { /* * acx100_s_init_memory_pools set up txbuf_start and txbuf_numblocks for us. @@ -2982,20 +2998,20 @@ void acxmem_init_acx_txbuf2(acx_device_t *adev) { } #endif -static inline txdesc_t* +STATick inline txdesc_t* acxmem_get_txdesc(acx_device_t *adev, int index) { return (txdesc_t*) (((u8*) adev->txdesc_start) + index * adev->txdesc_size); } #if 0 -// static inline +// STATick inline txdesc_t* acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc) { return (txdesc_t*) (((u8*) txdesc) + inc * adev->txdesc_size); } #endif -static txhostdesc_t* +STATick txhostdesc_t* acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { int index = (u8*) txdesc - (u8*) adev->txdesc_start; if (unlikely(ACX_DEBUG && (index % adev->txdesc_size))) { @@ -3470,7 +3486,7 @@ void acxmem_update_queue_indicator(acx_device_t *adev, int txqueue) { ** ** Called from network core. Must not sleep! */ -static void acxmem_i_tx_timeout(struct net_device *ndev) { +STATick void acxmem_i_tx_timeout(struct net_device *ndev) { acx_device_t *adev = ndev2adev(ndev); unsigned long flags; unsigned int tx_num_cleaned; @@ -3519,7 +3535,7 @@ static void acxmem_i_tx_timeout(struct net_device *ndev) { * ================================================== */ -static void acxmem_irq_enable(acx_device_t *adev) { +STATick void acxmem_irq_enable(acx_device_t *adev) { FN_ENTER; write_reg16(adev, IO_ACX_IRQ_MASK, adev->irq_mask); write_reg16(adev, IO_ACX_FEMR, 0x8000); @@ -3527,7 +3543,7 @@ static void acxmem_irq_enable(acx_device_t *adev) { FN_EXIT0; } -static void acxmem_irq_disable(acx_device_t *adev) { +STATick void acxmem_irq_disable(acx_device_t *adev) { FN_ENTER; write_reg16(adev, IO_ACX_IRQ_MASK, HOST_INT_MASK_ALL); @@ -3669,7 +3685,7 @@ void acxmem_irq_work(struct work_struct *work) after we set it once. Let's hope this will be fixed in firmware someday */ -static void acxmem_handle_info_irq(acx_device_t *adev) { +STATick void acxmem_handle_info_irq(acx_device_t *adev) { #if ACX_DEBUG static const char * const info_type_msg[] = { "(unknown)", @@ -3764,7 +3780,7 @@ void acxmem_set_interrupt_mask(acx_device_t *adev) { // OW FIXME Old interrupt handler // --- #if 0 -static irqreturn_t acxmem_interrupt(int irq, void *dev_id) +STATick irqreturn_t acxmem_interrupt(int irq, void *dev_id) { acx_device_t *adev = dev_id; unsigned long flags; @@ -3997,7 +4013,7 @@ STATick int acxmem_op_start(struct ieee80211_hw *hw) { } -static void acxmem_op_stop(struct ieee80211_hw *hw) +STATick void acxmem_op_stop(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); acxmem_lock_flags; @@ -4064,13 +4080,13 @@ INLINE_IO int acxmem_adev_present(acx_device_t *adev) { return acx_readl(adev->iobase) != 0xffffffff; } -static char acxmem_printable(char c) { +STATick char acxmem_printable(char c) { return ((c >= 20) && (c < 127)) ? c : '.'; } // OW TODO #if 0 -static void update_link_quality_led(acx_device_t *adev) { +STATick void update_link_quality_led(acx_device_t *adev) { int qual; qual = acx_signal_determine_quality(adev->wstats.qual.level, @@ -4444,7 +4460,7 @@ int acx100mem_ioctl_set_phy_amp_bias(struct ieee80211_hw *hw, * pdev - ptr to pci device structure containing info about pci configuration * id - ptr to the device id entry that matched this device */ -static int __devinit acxmem_probe(struct platform_device *pdev) { +STATick int __devinit acxmem_probe(struct platform_device *pdev) { acx_device_t *adev = NULL; const char *chip_name; @@ -4707,7 +4723,7 @@ static int __devinit acxmem_probe(struct platform_device *pdev) { * * pdev - ptr to PCI device structure containing info about pci configuration */ -static int __devexit acxmem_remove(struct platform_device *pdev) { +STATick int __devexit acxmem_remove(struct platform_device *pdev) { struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); acx_device_t *adev = ieee2adev(hw); @@ -4804,7 +4820,7 @@ static int __devexit acxmem_remove(struct platform_device *pdev) { * TODO: PM code needs to be fixed / debugged / tested. */ #ifdef CONFIG_PM -static int +STATick int acxmem_e_suspend(struct platform_device *pdev, pm_message_t state) { struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); @@ -4842,7 +4858,7 @@ acxmem_e_suspend(struct platform_device *pdev, pm_message_t state) { return OK; } -static int acxmem_e_resume(struct platform_device *pdev) { +STATick int acxmem_e_resume(struct platform_device *pdev) { struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); acx_device_t *adev; @@ -4900,17 +4916,17 @@ static int acxmem_e_resume(struct platform_device *pdev) { #endif /* CONFIG_PM */ -static struct platform_driver acxmem_driver = { - .driver = { - .name = "acx-mem", - }, - .probe = acxmem_probe, - .remove = __devexit_p(acxmem_remove), - - #ifdef CONFIG_PM - .suspend = acxmem_e_suspend, - .resume = acxmem_e_resume - #endif /* CONFIG_PM */ +STATick struct platform_driver acxmem_driver = { + .driver = { + .name = "acx-mem", + }, + .probe = acxmem_probe, + .remove = __devexit_p(acxmem_remove), + +#ifdef CONFIG_PM + .suspend = acxmem_e_suspend, + .resume = acxmem_e_resume +#endif /* CONFIG_PM */ }; diff --git a/pci.c b/pci.c index 7fb8deb..e80fa9f 100644 --- a/pci.c +++ b/pci.c @@ -116,7 +116,8 @@ static int acxpci_upload_fw(acx_device_t * adev); // CMDs (Control Path) int acxpci_issue_cmd_timeo_debug(acx_device_t * adev, unsigned cmd, void *buffer, unsigned buflen, unsigned cmd_timeout, const char *cmdstr); static inline void acxpci_write_cmd_type_status(acx_device_t * adev, u16 type, u16 status); -static u32 acxpci_read_cmd_type_status(acx_device_t *adev); +//= static +u32 acxpci_read_cmd_type_status(acx_device_t *adev); static inline void acxpci_init_mboxes(acx_device_t * adev); // Init, Configuration (Control Path) @@ -1541,7 +1542,8 @@ acxpci_write_cmd_type_status(acx_device_t * adev, u16 type, u16 status) } -static u32 acxpci_read_cmd_type_status(acx_device_t *adev) +//static +u32 acxpci_read_cmd_type_status(acx_device_t *adev) { u32 cmd_type, cmd_status; -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:26
|
It never belonged in merge.c Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 22 ---------------------- 1 files changed, 0 insertions(+), 22 deletions(-) diff --git a/merge.c b/merge.c index d0ff6df..17399d6 100644 --- a/merge.c +++ b/merge.c @@ -3227,24 +3227,6 @@ static irqreturn_t acxmem_interrupt(int irq, void *dev_id) * ================================================== */ -static const struct ieee80211_ops acxmem_hw_ops = { - .tx = acx_op_tx, - .conf_tx = acx_conf_tx, - .add_interface = acx_op_add_interface, - .remove_interface = acx_op_remove_interface, - .start = acxmem_op_start, - .configure_filter = acx_op_configure_filter, - .stop = acxmem_op_stop, - .config = acx_op_config, - .bss_info_changed = acx_op_bss_info_changed, - .set_key = acx_op_set_key, - .get_stats = acx_op_get_stats, -#if CONFIG_ACX_MAC80211_VERSION < KERNEL_VERSION(2, 6, 34) - .get_tx_stats = acx_e_op_get_tx_stats, -#endif - }; - -// static int acx_op_start(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); @@ -3278,10 +3260,6 @@ int acx_op_start(struct ieee80211_hw *hw) return result; } - - -// trivial diffs mem/pci -// static void acx_op_stop(struct ieee80211_hw *hw) { acx_device_t *adev = ieee2adev(hw); -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:27
|
Copy function from pci.c, #if0 it in pci.c, //= in pci.h Call it from merge.c:acx_create_hostdesc_queues(), and make it static. Also some formatting cleanups in mem.c, pci.c which eased the comparison by reducing the sdiff. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 14 ++++++++---- merge.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ pci.c | 13 +++++++---- pci.h | 2 +- 4 files changed, 82 insertions(+), 11 deletions(-) diff --git a/mem.c b/mem.c index e2e706c..439ac26 100644 --- a/mem.c +++ b/mem.c @@ -606,7 +606,8 @@ int acxmem_create_hostdesc_queues(acx_device_t *adev) * plus 32 bytes safety offset at the end */ //static -int acxmem_create_rx_host_desc_queue(acx_device_t *adev) { +int acxmem_create_rx_host_desc_queue(acx_device_t *adev) +{ rxhostdesc_t *hostdesc; rxbuffer_t *rxbuf; int i; @@ -616,8 +617,9 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) { /* allocate the RX host descriptor queue pool */ adev->rxhostdesc_area_size = RX_CNT * sizeof(*hostdesc); - adev->rxhostdesc_start = acxmem_allocate(adev, adev->rxhostdesc_area_size, - &adev->rxhostdesc_startphy, "rxhostdesc_start"); + adev->rxhostdesc_start = acxmem_allocate(adev, + adev->rxhostdesc_area_size, + &adev->rxhostdesc_startphy, "rxhostdesc_start"); if (!adev->rxhostdesc_start) goto fail; @@ -631,8 +633,10 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) { * to store the whole content of the received frames in it */ adev->rxbuf_area_size = RX_CNT * RX_BUFFER_SIZE; - adev->rxbuf_start = acxmem_allocate(adev, adev->rxbuf_area_size, - &adev->rxbuf_startphy, "rxbuf_start"); + adev->rxbuf_start + = acxmem_allocate(adev, adev->rxbuf_area_size, + &adev->rxbuf_startphy, + "rxbuf_start"); if (!adev->rxbuf_start) goto fail; diff --git a/merge.c b/merge.c index a81bbed..cab8abf 100644 --- a/merge.c +++ b/merge.c @@ -206,6 +206,70 @@ int acxpci_upload_radio(acx_device_t *adev) return acx_upload_radio(adev, filename); } +#define RX_BUFFER_SIZE (sizeof(rxbuffer_t) + 32) +static +int acxpci_create_rx_host_desc_queue(acx_device_t * adev) +{ + rxhostdesc_t *hostdesc; + rxbuffer_t *rxbuf; + dma_addr_t hostdesc_phy; + dma_addr_t rxbuf_phy; + int i; + + FN_ENTER; + + /* allocate the RX host descriptor queue pool */ + adev->rxhostdesc_area_size = RX_CNT * sizeof(*hostdesc); + adev->rxhostdesc_start = acxpci_allocate(adev, + adev->rxhostdesc_area_size, + &adev->rxhostdesc_startphy, "rxhostdesc_start"); + if (!adev->rxhostdesc_start) + goto fail; + /* check for proper alignment of RX host descriptor pool */ + if ((long)adev->rxhostdesc_start & 3) { + pr_acx("driver bug: dma alloc returns unaligned address\n"); + goto fail; + } + + /* allocate Rx buffer pool which will be used by the acx + * to store the whole content of the received frames in it */ + adev->rxbuf_area_size = RX_CNT * RX_BUFFER_SIZE; + adev->rxbuf_start + = acxpci_allocate(adev, adev->rxbuf_area_size, + &adev->rxbuf_startphy, "rxbuf_start"); + if (!adev->rxbuf_start) + goto fail; + + rxbuf = adev->rxbuf_start; + rxbuf_phy = adev->rxbuf_startphy; + hostdesc = adev->rxhostdesc_start; + hostdesc_phy = adev->rxhostdesc_startphy; + + /* don't make any popular C programming pointer arithmetic mistakes + * here, otherwise I'll kill you... + * (and don't dare asking me why I'm warning you about that...) */ + for (i = 0; i < RX_CNT; i++) { + hostdesc->data = rxbuf; + hostdesc->data_phy = cpu2acx(rxbuf_phy); + hostdesc->length = cpu_to_le16(RX_BUFFER_SIZE); + CLEAR_BIT(hostdesc->Ctl_16, cpu_to_le16(DESC_CTL_HOSTOWN)); + rxbuf++; + rxbuf_phy += sizeof(*rxbuf); + hostdesc_phy += sizeof(*hostdesc); + hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); + hostdesc++; + } + hostdesc--; + hostdesc->desc_phy_next = cpu2acx(adev->rxhostdesc_startphy); + FN_EXIT1(OK); + return OK; + fail: + pr_acx("create_rx_host_desc_queue FAILED\n"); + /* dealloc will be done by free function on error case */ + FN_EXIT1(NOT_OK); + return NOT_OK; +} + int acx_create_hostdesc_queues(acx_device_t *adev) { int result; diff --git a/pci.c b/pci.c index 1501627..22c5b42 100644 --- a/pci.c +++ b/pci.c @@ -299,6 +299,7 @@ int acxpci_create_hostdesc_queues(acx_device_t * adev) * plus 32 bytes safety offset at the end */ //static +#if 0 int acxpci_create_rx_host_desc_queue(acx_device_t * adev) { rxhostdesc_t *hostdesc; @@ -311,9 +312,9 @@ int acxpci_create_rx_host_desc_queue(acx_device_t * adev) /* allocate the RX host descriptor queue pool */ adev->rxhostdesc_area_size = RX_CNT * sizeof(*hostdesc); - adev->rxhostdesc_start = acxpci_allocate(adev, adev->rxhostdesc_area_size, - &adev->rxhostdesc_startphy, - "rxhostdesc_start"); + adev->rxhostdesc_start = acxpci_allocate(adev, + adev->rxhostdesc_area_size, + &adev->rxhostdesc_startphy, "rxhostdesc_start"); if (!adev->rxhostdesc_start) goto fail; /* check for proper alignment of RX host descriptor pool */ @@ -325,8 +326,9 @@ int acxpci_create_rx_host_desc_queue(acx_device_t * adev) /* allocate Rx buffer pool which will be used by the acx * to store the whole content of the received frames in it */ adev->rxbuf_area_size = RX_CNT * RX_BUFFER_SIZE; - adev->rxbuf_start = acxpci_allocate(adev, adev->rxbuf_area_size, - &adev->rxbuf_startphy, "rxbuf_start"); + adev->rxbuf_start + = acxpci_allocate(adev, adev->rxbuf_area_size, + &adev->rxbuf_startphy, "rxbuf_start"); if (!adev->rxbuf_start) goto fail; @@ -359,6 +361,7 @@ int acxpci_create_rx_host_desc_queue(acx_device_t * adev) FN_EXIT1(NOT_OK); return NOT_OK; } +#endif // static int acxpci_create_tx_host_desc_queue(acx_device_t * adev) diff --git a/pci.h b/pci.h index b7b6a1f..8528b7c 100644 --- a/pci.h +++ b/pci.h @@ -16,7 +16,7 @@ STATick void acxpci_log_rxbuffer(const acx_device_t * adev); STATick void acxpci_log_txbuffer(acx_device_t * adev); int acxpci_create_hostdesc_queues(acx_device_t * adev); -STATick int acxpci_create_rx_host_desc_queue(acx_device_t * adev); +//= STATick int acxpci_create_rx_host_desc_queue(acx_device_t * adev); STATick int acxpci_create_tx_host_desc_queue(acx_device_t * adev); void acxpci_create_desc_queues(acx_device_t * adev, u32 tx_queue_start, u32 rx_queue_start); -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:28
|
This fixes defined-but-not-used warnings. Revisit later. 2 more defined-but-not-used warnings are left. Tested-by: jimc - modprobes, ifups, iwconfigs. Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 11 ++++++++--- 1 files changed, 8 insertions(+), 3 deletions(-) diff --git a/merge.c b/merge.c index 3fed49c..3140448 100644 --- a/merge.c +++ b/merge.c @@ -3731,6 +3731,7 @@ int acx100mem_ioctl_set_phy_amp_bias(struct ieee80211_hw *hw, * pdev - ptr to pci device structure containing info about pci configuration * id - ptr to the device id entry that matched this device */ +#if 0 // non-trivial diffs vs pci static int __devinit acxmem_probe(struct platform_device *pdev) { acx_device_t *adev = NULL; @@ -3985,6 +3986,7 @@ static int __devinit acxmem_probe(struct platform_device *pdev) { FN_EXIT1(result); return result; } +#endif /* * acxmem_e_remove @@ -3994,9 +3996,11 @@ static int __devinit acxmem_probe(struct platform_device *pdev) { * * pdev - ptr to PCI device structure containing info about pci configuration */ -static int __devexit acxmem_remove(struct platform_device *pdev) { - - struct ieee80211_hw *hw = (struct ieee80211_hw *) platform_get_drvdata(pdev); +#if 0 // close, but defer merge +static int __devexit acxmem_remove(struct platform_device *pdev) +{ + struct ieee80211_hw *hw = (struct ieee80211_hw *) + platform_get_drvdata(pdev); acx_device_t *adev = ieee2adev(hw); acxmem_lock_flags; @@ -4086,6 +4090,7 @@ static int __devexit acxmem_remove(struct platform_device *pdev) { return(0); } +#endif #if 0 // til-end /* -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:29
|
merge.c: copied func, added "static" adjust acx_create_hostdesc_queues() to call it pci.c, mem.c: minor reformats to reduce sdiff, #if0d originals Tested-by: jimc - modprobes, ifups, iwconfigs. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 21 ++++++---- merge.c | 139 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- pci.c | 20 +++++---- 3 files changed, 162 insertions(+), 18 deletions(-) diff --git a/mem.c b/mem.c index e8ac59e..d3db2cf 100644 --- a/mem.c +++ b/mem.c @@ -660,6 +660,7 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) return NOT_OK; } +#if 0 /* * In the generic slave memory access mode, most of the stuff in * the txhostdesc_t is unused. It's only here because the rest of @@ -669,7 +670,8 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) * on the way out. */ //static -int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { +int acxmem_create_tx_host_desc_queue(acx_device_t *adev) +{ txhostdesc_t *hostdesc; u8 *txbuf; int i; @@ -680,7 +682,8 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { /* WLAN_A4FR_MAXLEN_WEP_FCS */ adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; - adev->txbuf_start = acx_allocate(adev, adev->txbuf_area_size, + adev->txbuf_start + = acx_allocate(adev, adev->txbuf_area_size, &adev->txbuf_startphy, "txbuf_start"); if (!adev->txbuf_start) goto fail; @@ -688,7 +691,8 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { /* allocate the TX host descriptor queue pool */ adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); - adev->txhostdesc_start = acx_allocate(adev, adev->txhostdesc_area_size, + adev->txhostdesc_start + = acx_allocate(adev, adev->txhostdesc_area_size, &adev->txhostdesc_startphy, "txhostdesc_start"); if (!adev->txhostdesc_start) goto fail; @@ -752,7 +756,7 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { #endif /* We initialize two hostdescs so that they point to adjacent - ** memory areas. Thus txbuf is really just a contiguous memory area */ + * memory areas. Thus txbuf is really just a contiguous memory area */ for (i = 0; i < TX_CNT * 2; i++) { /* ->data is a non-hardware field: */ hostdesc->data = txbuf; @@ -769,14 +773,15 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { FN_EXIT1(OK); return OK; - fail: - // OW FIXME Logging - pr_acx("create_tx_host_desc_queue FAILED\n"); - /* dealloc will be done by free function on error case */ +fail: + // OW FIXME Logging + pr_acx("create_tx_host_desc_queue FAILED\n"); + /* dealloc will be done by free function on error case */ FN_EXIT1(NOT_OK); return NOT_OK; } +#endif void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, u32 rx_queue_start) { diff --git a/merge.c b/merge.c index da18167..a74ba41 100644 --- a/merge.c +++ b/merge.c @@ -301,6 +301,141 @@ int acx_create_rx_host_desc_queue(acx_device_t * adev) return NOT_OK; } +static +int acx_create_tx_host_desc_queue(acx_device_t * adev) +{ + txhostdesc_t *hostdesc; + u8 *txbuf; + dma_addr_t hostdesc_phy; + dma_addr_t txbuf_phy; + int i; + + FN_ENTER; + + /* allocate TX buffer */ + /* OW 20100513 adev->txbuf_area_size = TX_CNT + * *WLAN_A4FR_MAXLEN_WEP_FCS (30 + 2312 + 4); */ + adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; + adev->txbuf_start + = acx_allocate(adev, adev->txbuf_area_size, + &adev->txbuf_startphy, "txbuf_start"); + if (!adev->txbuf_start) + goto fail; + + /* allocate the TX host descriptor queue pool */ + adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); + adev->txhostdesc_start + = acx_allocate(adev, adev->txhostdesc_area_size, + &adev->txhostdesc_startphy, + "txhostdesc_start"); + if (!adev->txhostdesc_start) + goto fail; + /* check for proper alignment of TX host descriptor pool */ + if ((long)adev->txhostdesc_start & 3) { + pr_acx("driver bug: dma alloc returns unaligned address\n"); + goto fail; + } + + hostdesc = adev->txhostdesc_start; + hostdesc_phy = adev->txhostdesc_startphy; + txbuf = adev->txbuf_start; + txbuf_phy = adev->txbuf_startphy; + +#if 0 +/* Each tx buffer is accessed by hardware via +** txdesc -> txhostdesc(s) -> txbuffer(s). +** We use only one txhostdesc per txdesc, but it looks like +** acx111 is buggy: it accesses second txhostdesc +** (via hostdesc.desc_phy_next field) even if +** txdesc->length == hostdesc->length and thus +** entire packet was placed into first txhostdesc. +** Due to this bug acx111 hangs unless second txhostdesc +** has le16_to_cpu(hostdesc.length) = 3 (or larger) +** Storing NULL into hostdesc.desc_phy_next +** doesn't seem to help. +** +** Update: although it worked on Xterasys XN-2522g +** with len=3 trick, WG311v2 is even more bogus, doesn't work. +** Keeping this code (#ifdef'ed out) for documentational purposes. +*/ + for (i = 0; i < TX_CNT * 2; i++) { + hostdesc_phy += sizeof(*hostdesc); + if (!(i & 1)) { + hostdesc->data_phy = cpu2acx(txbuf_phy); + /* hostdesc->data_offset = ... */ + /* hostdesc->reserved = ... */ + hostdesc->Ctl_16 = cpu_to_le16(DESC_CTL_HOSTOWN); + /* hostdesc->length = ... */ + hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); + hostdesc->pNext = ptr2acx(NULL); + /* hostdesc->Status = ... */ + /* below: non-hardware fields */ + hostdesc->data = txbuf; + + txbuf += WLAN_A4FR_MAXLEN_WEP_FCS; + txbuf_phy += WLAN_A4FR_MAXLEN_WEP_FCS; + } else { + /* hostdesc->data_phy = ... */ + /* hostdesc->data_offset = ... */ + /* hostdesc->reserved = ... */ + /* hostdesc->Ctl_16 = ... */ + hostdesc->length = cpu_to_le16(3); /* bug workaround */ + /* hostdesc->desc_phy_next = ... */ + /* hostdesc->pNext = ... */ + /* hostdesc->Status = ... */ + /* below: non-hardware fields */ + /* hostdesc->data = ... */ + } + hostdesc++; + } +#endif + /* We initialize two hostdescs so that they point to adjacent + * memory areas. Thus txbuf is really just a contiguous memory + * area */ + for (i = 0; i < TX_CNT * 2; i++) { + hostdesc_phy += sizeof(*hostdesc); + + hostdesc->data_phy = cpu2acx(txbuf_phy); + /* done by memset(0): hostdesc->data_offset = 0; */ + /* hostdesc->reserved = ... */ + hostdesc->Ctl_16 = cpu_to_le16(DESC_CTL_HOSTOWN); + /* hostdesc->length = ... */ + hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); + /* done by memset(0): hostdesc->pNext = ptr2acx(NULL); */ + /* hostdesc->Status = ... */ + /* ->data is a non-hardware field: */ + hostdesc->data = txbuf; + + if (!(i & 1)) { + /* OW 20100513 txbuf += 24 // WLAN_HDR_A3_LEN */ + /* OW 20100513 txbuf_phy += 24 // WLAN_HDR_A3_LEN */ + txbuf += WLAN_HDR_A3_LEN; + txbuf_phy += WLAN_HDR_A3_LEN; + } else { + /* OW 20100513 txbuf += 30 + 2132 + 4 - 24 // + * WLAN_A4FR_MAXLEN_WEP_FCS - + * WLAN_HDR_A3_LEN */; + /* OW 20100513 txbuf_phy += 30 + 2132 + 4 - + * 24 // WLAN_A4FR_MAXLEN_WEP_FCS - + * WLAN_HDR_A3_LEN */; + txbuf += WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN; + txbuf_phy += WLAN_A4FR_MAXLEN_WEP_FCS + - WLAN_HDR_A3_LEN; + } + hostdesc++; + } + hostdesc--; + hostdesc->desc_phy_next = cpu2acx(adev->txhostdesc_startphy); + + FN_EXIT1(OK); + return OK; +fail: + pr_acx("create_tx_host_desc_queue FAILED\n"); + /* dealloc will be done by free function on error case */ + FN_EXIT1(NOT_OK); + return NOT_OK; +} + int acx_create_hostdesc_queues(acx_device_t *adev) { int result; @@ -308,8 +443,8 @@ int acx_create_hostdesc_queues(acx_device_t *adev) pr_notice("notice IS_PCI(%p): %d\n", adev, IS_PCI(adev)); result = (IS_MEM(adev)) - ? acxmem_create_tx_host_desc_queue(adev) - : acxpci_create_tx_host_desc_queue(adev); + ? acx_create_tx_host_desc_queue(adev) + : acx_create_tx_host_desc_queue(adev); if (OK != result) return result; result = (IS_MEM(adev)) diff --git a/pci.c b/pci.c index 04e00c4..e55e328 100644 --- a/pci.c +++ b/pci.c @@ -363,6 +363,7 @@ int acxpci_create_rx_host_desc_queue(acx_device_t * adev) } #endif +#if 0 // static int acxpci_create_tx_host_desc_queue(acx_device_t * adev) { @@ -375,18 +376,21 @@ int acxpci_create_tx_host_desc_queue(acx_device_t * adev) FN_ENTER; /* allocate TX buffer */ - // OW 20100513 adev->txbuf_area_size = TX_CNT * /*WLAN_A4FR_MAXLEN_WEP_FCS*/ (30 + 2312 + 4); + /* OW 20100513 adev->txbuf_area_size = TX_CNT + * *WLAN_A4FR_MAXLEN_WEP_FCS (30 + 2312 + 4); */ adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; - adev->txbuf_start = acx_allocate(adev, adev->txbuf_area_size, - &adev->txbuf_startphy, "txbuf_start"); + adev->txbuf_start + = acx_allocate(adev, adev->txbuf_area_size, + &adev->txbuf_startphy, "txbuf_start"); if (!adev->txbuf_start) goto fail; /* allocate the TX host descriptor queue pool */ adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); - adev->txhostdesc_start = acx_allocate(adev, adev->txhostdesc_area_size, - &adev->txhostdesc_startphy, - "txhostdesc_start"); + adev->txhostdesc_start + = acx_allocate(adev, adev->txhostdesc_area_size, + &adev->txhostdesc_startphy, + "txhostdesc_start"); if (!adev->txhostdesc_start) goto fail; /* check for proper alignment of TX host descriptor pool */ @@ -482,13 +486,13 @@ int acxpci_create_tx_host_desc_queue(acx_device_t * adev) FN_EXIT1(OK); return OK; - fail: +fail: pr_acx("create_tx_host_desc_queue FAILED\n"); /* dealloc will be done by free function on error case */ FN_EXIT1(NOT_OK); return NOT_OK; } - +#endif void -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:30
|
previous patch used merge.c functions (w/o the (pci|mem), but left the IS_PCI().. ?: code. Drop it now. Signed-off-by: Jim Cromie <jim...@gm...> --- merge.c | 9 +++------ 1 files changed, 3 insertions(+), 6 deletions(-) diff --git a/merge.c b/merge.c index a74ba41..e2a96f5 100644 --- a/merge.c +++ b/merge.c @@ -442,14 +442,11 @@ int acx_create_hostdesc_queues(acx_device_t *adev) pr_notice("notice IS_PCI(%p): %d\n", adev, IS_PCI(adev)); - result = (IS_MEM(adev)) - ? acx_create_tx_host_desc_queue(adev) - : acx_create_tx_host_desc_queue(adev); + result = acx_create_tx_host_desc_queue(adev); if (OK != result) return result; - result = (IS_MEM(adev)) - ? acx_create_rx_host_desc_queue(adev) - : acx_create_rx_host_desc_queue(adev); + + result = acx_create_rx_host_desc_queue(adev); return result; } -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:32
|
merge.h: add proto temp ? remove once all callers moved to merge.c merge.c: acx_allocate() - drop "static" rename acxpci_create_rx_host_desc_queue(), drop "pci" change it to call acx_allocate() - 2 places change acx_create_hostdesc_queues() to call renamed acx_create_rx_host_desc_queue() mem.c: #if 0 acxmem_allocate(), //= proto change callers, drop "mem" pci.c: #if 0 acxpci_allocate, change calls in acxpci_create_tx_host_desc_queue() //= proto Tested-by: jimc - ifups, iwconfigs. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 13 +++++++------ merge.c | 21 +++++++++++---------- merge.h | 7 ++++++- pci.c | 8 +++++--- 4 files changed, 29 insertions(+), 20 deletions(-) diff --git a/mem.c b/mem.c index 01794a0..e8ac59e 100644 --- a/mem.c +++ b/mem.c @@ -153,7 +153,7 @@ STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start); void acxmem_free_desc_queues(acx_device_t *adev); STATick void acxmem_delete_dma_regions(acx_device_t *adev); -STATick void *acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); +//= STATick void *acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); // Firmware, EEPROM, Phy //= int acxmem_upload_radio(acx_device_t *adev); @@ -617,7 +617,7 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) /* allocate the RX host descriptor queue pool */ adev->rxhostdesc_area_size = RX_CNT * sizeof(*hostdesc); - adev->rxhostdesc_start = acxmem_allocate(adev, + adev->rxhostdesc_start = acx_allocate(adev, adev->rxhostdesc_area_size, &adev->rxhostdesc_startphy, "rxhostdesc_start"); if (!adev->rxhostdesc_start) @@ -634,7 +634,7 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) adev->rxbuf_area_size = RX_CNT * RX_BUFFER_SIZE; adev->rxbuf_start - = acxmem_allocate(adev, adev->rxbuf_area_size, + = acx_allocate(adev, adev->rxbuf_area_size, &adev->rxbuf_startphy, "rxbuf_start"); if (!adev->rxbuf_start) goto fail; @@ -680,7 +680,7 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { /* WLAN_A4FR_MAXLEN_WEP_FCS */ adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; - adev->txbuf_start = acxmem_allocate(adev, adev->txbuf_area_size, + adev->txbuf_start = acx_allocate(adev, adev->txbuf_area_size, &adev->txbuf_startphy, "txbuf_start"); if (!adev->txbuf_start) goto fail; @@ -688,7 +688,7 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { /* allocate the TX host descriptor queue pool */ adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); - adev->txhostdesc_start = acxmem_allocate(adev, adev->txhostdesc_area_size, + adev->txhostdesc_start = acx_allocate(adev, adev->txhostdesc_area_size, &adev->txhostdesc_startphy, "txhostdesc_start"); if (!adev->txhostdesc_start) goto fail; @@ -981,6 +981,7 @@ STATick void acxmem_delete_dma_regions(acx_device_t *adev) { FN_EXIT0; } +#if 0 STATick void* acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg) @@ -1003,7 +1004,7 @@ void* acxmem_allocate(acx_device_t *adev, size_t size, msg, (int) size); return NULL; } - +#endif /* * BOM Firmware, EEPROM, Phy diff --git a/merge.c b/merge.c index 3290033..da18167 100644 --- a/merge.c +++ b/merge.c @@ -206,8 +206,7 @@ int acxpci_upload_radio(acx_device_t *adev) return acx_upload_radio(adev, filename); } -static -void *acxpci_allocate(acx_device_t * adev, size_t size, +void *acx_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg) { void *ptr; @@ -238,7 +237,7 @@ void *acxpci_allocate(acx_device_t * adev, size_t size, #define RX_BUFFER_SIZE (sizeof(rxbuffer_t) + 32) static -int acxpci_create_rx_host_desc_queue(acx_device_t * adev) +int acx_create_rx_host_desc_queue(acx_device_t * adev) { rxhostdesc_t *hostdesc; rxbuffer_t *rxbuf; @@ -250,9 +249,11 @@ int acxpci_create_rx_host_desc_queue(acx_device_t * adev) /* allocate the RX host descriptor queue pool */ adev->rxhostdesc_area_size = RX_CNT * sizeof(*hostdesc); - adev->rxhostdesc_start = acxpci_allocate(adev, - adev->rxhostdesc_area_size, - &adev->rxhostdesc_startphy, "rxhostdesc_start"); + adev->rxhostdesc_start + = acx_allocate(adev, + adev->rxhostdesc_area_size, + &adev->rxhostdesc_startphy, + "rxhostdesc_start"); if (!adev->rxhostdesc_start) goto fail; /* check for proper alignment of RX host descriptor pool */ @@ -265,8 +266,8 @@ int acxpci_create_rx_host_desc_queue(acx_device_t * adev) * to store the whole content of the received frames in it */ adev->rxbuf_area_size = RX_CNT * RX_BUFFER_SIZE; adev->rxbuf_start - = acxpci_allocate(adev, adev->rxbuf_area_size, - &adev->rxbuf_startphy, "rxbuf_start"); + = acx_allocate(adev, adev->rxbuf_area_size, + &adev->rxbuf_startphy, "rxbuf_start"); if (!adev->rxbuf_start) goto fail; @@ -312,8 +313,8 @@ int acx_create_hostdesc_queues(acx_device_t *adev) if (OK != result) return result; result = (IS_MEM(adev)) - ? acxmem_create_rx_host_desc_queue(adev) - : acxpci_create_rx_host_desc_queue(adev); + ? acx_create_rx_host_desc_queue(adev) + : acx_create_rx_host_desc_queue(adev); return result; } diff --git a/merge.h b/merge.h index 0760e0b..f1e9b66 100644 --- a/merge.h +++ b/merge.h @@ -13,4 +13,9 @@ void acx_log_txbuffer(acx_device_t *adev); void acx_op_stop(struct ieee80211_hw *hw); int acx_op_start(struct ieee80211_hw *hw); -void acx_handle_info_irq(acx_device_t * adev); +void acx_handle_info_irq(acx_device_t *adev); + +// temporary ?? may go static after all users are in merge.c +void *acx_allocate(acx_device_t *adev, size_t size, + dma_addr_t *phy, const char *msg); + diff --git a/pci.c b/pci.c index 681ad83..04e00c4 100644 --- a/pci.c +++ b/pci.c @@ -97,7 +97,7 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start) void acxpci_free_desc_queues(acx_device_t * adev); static void acxpci_delete_dma_regions(acx_device_t * adev); static inline void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle); -static void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg); +//= static void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg); // Firmware, EEPROM, Phy int acxpci_upload_radio(acx_device_t * adev); @@ -377,14 +377,14 @@ int acxpci_create_tx_host_desc_queue(acx_device_t * adev) /* allocate TX buffer */ // OW 20100513 adev->txbuf_area_size = TX_CNT * /*WLAN_A4FR_MAXLEN_WEP_FCS*/ (30 + 2312 + 4); adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; - adev->txbuf_start = acxpci_allocate(adev, adev->txbuf_area_size, + adev->txbuf_start = acx_allocate(adev, adev->txbuf_area_size, &adev->txbuf_startphy, "txbuf_start"); if (!adev->txbuf_start) goto fail; /* allocate the TX host descriptor queue pool */ adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); - adev->txhostdesc_start = acxpci_allocate(adev, adev->txhostdesc_area_size, + adev->txhostdesc_start = acx_allocate(adev, adev->txhostdesc_area_size, &adev->txhostdesc_startphy, "txhostdesc_start"); if (!adev->txhostdesc_start) @@ -698,6 +698,7 @@ void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, size, vaddr, dma_handle); } +#if 0 // to merge.c static void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg) @@ -716,6 +717,7 @@ void *acxpci_allocate(acx_device_t * adev, size_t size, msg, (int)size); return NULL; } +#endif /* * BOM Firmware, EEPROM, Phy -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:34
|
move #if0s below comments, so theyre more evident in sdiffs. Also a couple func sig rewraps, again for sdiff reduction. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 37 +++++++++++++++++++++---------------- pci.c | 9 ++++----- 2 files changed, 25 insertions(+), 21 deletions(-) diff --git a/mem.c b/mem.c index f56efe9..09c9c97 100644 --- a/mem.c +++ b/mem.c @@ -660,7 +660,6 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) return NOT_OK; } -#if 0 /* * In the generic slave memory access mode, most of the stuff in * the txhostdesc_t is unused. It's only here because the rest of @@ -669,6 +668,7 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) * only use we have for the host descriptors is to store the packets * on the way out. */ +#if 0 //static int acxmem_create_tx_host_desc_queue(acx_device_t *adev) { @@ -952,7 +952,6 @@ void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) FN_EXIT0; } -#if 0 /* * acxmem_free_desc_queues * @@ -960,6 +959,7 @@ void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) * others have been initialised to NULL so this * function can be used if only part of the queues were allocated. */ +#if 0 void acxmem_free_desc_queues(acx_device_t *adev) { @@ -1040,12 +1040,12 @@ void* acxmem_allocate(acx_device_t *adev, size_t size, * ================================================== */ -#if 0 // now in merge.c /* * acxmem_s_upload_radio * * Uploads the appropriate radio module firmware into the card. */ +#if 0 // now in merge.c int acxmem_upload_radio(acx_device_t *adev) { acx_ie_memmap_t mm; firmware_image_t *radio_image; @@ -1274,13 +1274,13 @@ STATick inline void acxmem_read_eeprom_area(acx_device_t *adev) { #endif } -#if 0 // port soon to merge.c /* * acxmem_s_read_phy_reg * * Messing with rx/tx disabling and enabling here * (write_reg32(adev, IO_ACX_ENABLE, 0b000000xx)) kills traffic */ +#if 0 // port soon to merge.c int acxmem_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf) { int result = NOT_OK; int count; @@ -2311,11 +2311,11 @@ STATick void acxmem_up(struct ieee80211_hw *hw) { } -#if 0 /*********************************************************************** ** acxmem_i_set_multicast_list ** FIXME: most likely needs refinement */ +#if 0 STATick void acxmem_i_set_multicast_list(struct net_device *ndev) { acx_device_t *adev = ndev2adev(ndev); unsigned long flags; @@ -3007,7 +3007,6 @@ STATick void acxmem_init_acx_txbuf(acx_device_t *adev) { /* Re-initialize tx-buffer list */ #if 0 - void acxmem_init_acx_txbuf2(acx_device_t *adev) { int i; @@ -3281,8 +3280,6 @@ void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, } #endif -#if 0 - /* * acxmem_l_clean_txdesc * @@ -3294,6 +3291,7 @@ void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, * Everytime we get called we know where the next packet to be cleaned is. */ // OW TODO Very similar with pci: possible merging. +#if 0 unsigned int acxmem_tx_clean_txdesc(acx_device_t *adev) { txdesc_t *txdesc; txhostdesc_t *hostdesc; @@ -3516,12 +3514,12 @@ void acxmem_update_queue_indicator(acx_device_t *adev, int txqueue) { #endif // OW TODO See if this is usable with mac80211 -#if 0 /*********************************************************************** ** acxmem_i_tx_timeout ** ** Called from network core. Must not sleep! */ +#if 0 STATick void acxmem_i_tx_timeout(struct net_device *ndev) { acx_device_t *adev = ndev2adev(ndev); unsigned long flags; @@ -3699,6 +3697,7 @@ void acxmem_irq_work(struct work_struct *work) #define INFO_PS_FAIL 0x0004 /* encryption/decryption process on a packet failed */ #define INFO_IV_ICV_FAILURE 0x0005 +#endif /* Info mailbox format: 2 bytes: type @@ -3721,7 +3720,9 @@ void acxmem_irq_work(struct work_struct *work) after we set it once. Let's hope this will be fixed in firmware someday */ -STATick void acxmem_handle_info_irq(acx_device_t *adev) { +#if 0 +STATick void acxmem_handle_info_irq(acx_device_t *adev) +{ #if ACX_DEBUG static const char * const info_type_msg[] = { "(unknown)", @@ -3764,8 +3765,8 @@ STATick void acxmem_handle_info_irq(acx_device_t *adev) { #endif #if 0 -void acxmem_set_interrupt_mask(acx_device_t *adev) { - +void acxmem_set_interrupt_mask(acx_device_t *adev) +{ FN_ENTER; if (IS_ACX111(adev)) { @@ -4017,7 +4018,8 @@ static const struct ieee80211_ops acxmem_hw_ops = { }; #if 0 -STATick int acxmem_op_start(struct ieee80211_hw *hw) { +STATick int acxmem_op_start(struct ieee80211_hw *hw) +{ acx_device_t *adev = ieee2adev(hw); int result = OK; @@ -4123,7 +4125,8 @@ STATick char acxmem_printable(char c) { // OW TODO #if 0 -STATick void update_link_quality_led(acx_device_t *adev) { +STATick void update_link_quality_led(acx_device_t *adev) +{ int qual; qual = acx_signal_determine_quality(adev->wstats.qual.level, @@ -4148,8 +4151,10 @@ STATick void update_link_quality_led(acx_device_t *adev) { // OW TODO Not used in pci either !? #if 0 -int acx111pci_ioctl_info(struct ieee80211_hw *hw, struct iw_request_info *info, - struct iw_param *vwrq, char *extra) { +int acx111pci_ioctl_info(struct ieee80211_hw *hw, + struct iw_request_info *info, + struct iw_param *vwrq, char *extra) +{ #if ACX_DEBUG > 1 acx_device_t *adev = ieee2adev(hw); diff --git a/pci.c b/pci.c index 721f2d6..0487d93 100644 --- a/pci.c +++ b/pci.c @@ -644,7 +644,6 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, FN_EXIT0; } -#if 0 /* * acxpci_free_desc_queues * @@ -652,6 +651,7 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, * others have been initialised to NULL so this * function can be used if only part of the queues were allocated. */ +#if 0 void acxpci_free_desc_queues(acx_device_t * adev) { @@ -735,8 +735,6 @@ void *acxpci_allocate(acx_device_t * adev, size_t size, * ================================================== */ -#if 0 - /* * acxpci_s_upload_radio * @@ -744,6 +742,7 @@ void *acxpci_allocate(acx_device_t * adev, size_t size, * * Origin: Standard Read/Write to IO */ +#if 0 int acxpci_upload_radio(acx_device_t * adev) { acx_ie_memmap_t mm; @@ -2588,7 +2587,7 @@ void acxpci_irq_work(struct work_struct *work) #define INFO_PS_FAIL 0x0004 /* encryption/decryption process on a packet failed */ #define INFO_IV_ICV_FAILURE 0x0005 - +#endif /* Info mailbox format: 2 bytes: type 2 bytes: status @@ -2609,7 +2608,7 @@ more bytes may follow it does NOT clear bit 0x0001, and this bit will probably stay forever set after we set it once. Let's hope this will be fixed in firmware someday */ - +#if 0 static void acxpci_handle_info_irq(acx_device_t * adev) { #if ACX_DEBUG -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:34
|
copy function, #if0 in pci.c, comment out proto in pci.h Add in the diffs for mem.c version Also some formatting of the funciont in pci.c, mem.c to reduce sdiffs (use -W hereafter) Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 14 ++++++++------ merge.c | 30 ++++++++++++++++++++++++++++++ pci.c | 19 ++++++++++--------- pci.h | 2 +- 4 files changed, 49 insertions(+), 16 deletions(-) diff --git a/mem.c b/mem.c index 439ac26..01794a0 100644 --- a/mem.c +++ b/mem.c @@ -635,8 +635,7 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) adev->rxbuf_start = acxmem_allocate(adev, adev->rxbuf_area_size, - &adev->rxbuf_startphy, - "rxbuf_start"); + &adev->rxbuf_startphy, "rxbuf_start"); if (!adev->rxbuf_start) goto fail; @@ -982,8 +981,10 @@ STATick void acxmem_delete_dma_regions(acx_device_t *adev) { FN_EXIT0; } -STATick void* -acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg) { +STATick +void* acxmem_allocate(acx_device_t *adev, size_t size, + dma_addr_t *phy, const char *msg) +{ void *ptr; ptr = kmalloc(size, GFP_KERNEL); /* @@ -994,11 +995,12 @@ acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *ms if (ptr) { log(L_DEBUG, "%s sz=%d adr=0x%p phy=0x%08llx\n", - msg, (int)size, ptr, (unsigned long long)*phy); + msg, (int)size, ptr, (unsigned long long)*phy); memset(ptr, 0, size); return ptr; } - pr_err("acx: %s allocation FAILED (%d bytes)\n", msg, (int) size); + pr_err("acx: %s allocation FAILED (%d bytes)\n", + msg, (int) size); return NULL; } diff --git a/merge.c b/merge.c index cab8abf..3290033 100644 --- a/merge.c +++ b/merge.c @@ -206,6 +206,36 @@ int acxpci_upload_radio(acx_device_t *adev) return acx_upload_radio(adev, filename); } +static +void *acxpci_allocate(acx_device_t * adev, size_t size, + dma_addr_t * phy, const char *msg) +{ + void *ptr; + + if (IS_PCI(adev)) + ptr = dma_alloc_coherent(adev->bus_dev, + size, phy, GFP_KERNEL); + else { + ptr = kmalloc(size, GFP_KERNEL); + /* + * The ACX can't use the physical address, so we'll + * have to fa later and it might be handy to have the + * virtual address. + */ + *phy = (dma_addr_t) NULL; + } + + if (ptr) { + log(L_DEBUG, "%s sz=%d adr=0x%p phy=0x%08llx\n", + msg, (int)size, ptr, (unsigned long long)*phy); + memset(ptr, 0, size); + return ptr; + } + pr_err("%s allocation FAILED (%d bytes)\n", + msg, (int)size); + return NULL; +} + #define RX_BUFFER_SIZE (sizeof(rxbuffer_t) + 32) static int acxpci_create_rx_host_desc_queue(acx_device_t * adev) diff --git a/pci.c b/pci.c index 22c5b42..681ad83 100644 --- a/pci.c +++ b/pci.c @@ -690,16 +690,17 @@ static void acxpci_delete_dma_regions(acx_device_t * adev) FN_EXIT0; } -static inline void -acxpci_free_coherent(struct pci_dev *hwdev, size_t size, - void *vaddr, dma_addr_t dma_handle) +static inline +void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, + void *vaddr, dma_addr_t dma_handle) { - dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, - size, vaddr, dma_handle); + dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, + size, vaddr, dma_handle); } -static void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, - const char *msg) +static +void *acxpci_allocate(acx_device_t * adev, size_t size, + dma_addr_t * phy, const char *msg) { void *ptr; @@ -707,12 +708,12 @@ static void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, if (ptr) { log(L_DEBUG, "%s sz=%d adr=0x%p phy=0x%08llx\n", - msg, (int)size, ptr, (unsigned long long)*phy); + msg, (int)size, ptr, (unsigned long long)*phy); memset(ptr, 0, size); return ptr; } pr_err("%s allocation FAILED (%d bytes)\n", - msg, (int)size); + msg, (int)size); return NULL; } diff --git a/pci.h b/pci.h index 8528b7c..a271f3f 100644 --- a/pci.h +++ b/pci.h @@ -26,7 +26,7 @@ STATick void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start void acxpci_free_desc_queues(acx_device_t * adev); STATick void acxpci_delete_dma_regions(acx_device_t * adev); STATick inline void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle); -STATick void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg); +//= STATick void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg); // Firmware, EEPROM, Phy int acxpci_upload_radio(acx_device_t * adev); -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:36
|
Drop most of the code #if0d in this patchset, particularly the code known to have been moved to merge.c, I hope this will simplify further comparisons, if not, use another branch or git show HEAD~1:$file. Ive left some #if0d code in mem.c cuz I need to review its status in merge.c (damn mega-patch), and it will probly be easier this way. Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 437 --------------------------------------------------------- pci.c | 495 ----------------------------------------------------------------- 2 files changed, 0 insertions(+), 932 deletions(-) diff --git a/mem.c b/mem.c index 09c9c97..ac6c204 100644 --- a/mem.c +++ b/mem.c @@ -116,24 +116,6 @@ void acxmem_dump_mem(acx_device_t *adev, u32 start, int length); #endif // Data Access -#if 0 -INLINE_IO u32 read_id_register(acx_device_t *adev); -INLINE_IO u32 read_reg32(acx_device_t *adev, unsigned int offset); -INLINE_IO u16 read_reg16(acx_device_t *adev, unsigned int offset); -INLINE_IO u8 read_reg8(acx_device_t *adev, unsigned int offset); -INLINE_IO void write_reg32(acx_device_t *adev, unsigned int offset, u32 val); -INLINE_IO void write_reg16(acx_device_t *adev, unsigned int offset, u16 val); -INLINE_IO void write_reg8(acx_device_t *adev, unsigned int offset, u8 val); -INLINE_IO void write_flush(acx_device_t *adev); -INLINE_IO void set_regbits(acx_device_t *adev, unsigned int offset, u32 bits); -INLINE_IO void clear_regbits(acx_device_t *adev, unsigned int offset, u32 bits); -INLINE_IO void write_slavemem32(acx_device_t *adev, u32 slave_address, u32 val); -INLINE_IO u32 read_slavemem32(acx_device_t *adev, u32 slave_address); -INLINE_IO void write_slavemem8(acx_device_t *adev, u32 slave_address, u8 val); -INLINE_IO u8 read_slavemem8(acx_device_t *adev, u32 slave_address); -INLINE_IO void write_slavemem16(acx_device_t *adev, u32 slave_address, u16 val); -INLINE_IO u16 read_slavemem16(acx_device_t *adev, u32 slave_address); -#endif //= static void acxmem_copy_from_slavemem(acx_device_t *adev, u8 *destination, u32 source, int count); //= static @@ -277,42 +259,6 @@ void __exit acxmem_cleanup_module(void); #include "mem-inlines.h" -#if 0 -static void acxmem_log_rxbuffer(const acx_device_t *adev) { - register const struct rxhostdesc *rxhostdesc; - int i; - /* no FN_ENTER here, we don't want that */ - - rxhostdesc = adev->rxhostdesc_start; - if (unlikely(!rxhostdesc)) return; - for (i = 0; i < RX_CNT; i++) { - if ((rxhostdesc->Ctl_16 & cpu_to_le16(DESC_CTL_HOSTOWN)) - && (rxhostdesc->Status & cpu_to_le32(DESC_STATUS_FULL))) - pr_acx("rx: buf %d full\n", i); - rxhostdesc++; - } -} - -static void acxmem_log_txbuffer(acx_device_t *adev) { - txdesc_t *txdesc; - int i; - u8 Ctl_8; - - /* no FN_ENTER here, we don't want that */ - /* no locks here, since it's entirely non-critical code */ - txdesc = adev->txdesc_start; - if (unlikely(!txdesc)) - return; - pr_acx("tx: desc->Ctl8's: "); - for (i = 0; i < TX_CNT; i++) { - Ctl_8 = read_slavemem8(adev, (u32) &(txdesc->Ctl_8)); - printk("%02X ", Ctl_8); - txdesc = acxmem_advance_txdesc(adev, txdesc, 1); - } - printk("\n"); -} -#endif - #if DUMP_MEM_DEFINED > 0 //= static void acxmem_dump_mem(acx_device_t *adev, u32 start, int length) { @@ -587,18 +533,6 @@ void acxmem_chaincopy_from_slavemem(acx_device_t *adev, u8 *destination, } } -#if 0 -int acxmem_create_hostdesc_queues(acx_device_t *adev) -{ - int result; - result = acxmem_create_tx_host_desc_queue(adev); - if (OK != result) - return result; - result = acxmem_create_rx_host_desc_queue(adev); - return result; -} -#endif - /* * acxmem_s_create_rx_host_desc_queue * @@ -668,120 +602,6 @@ int acxmem_create_rx_host_desc_queue(acx_device_t *adev) * only use we have for the host descriptors is to store the packets * on the way out. */ -#if 0 -//static -int acxmem_create_tx_host_desc_queue(acx_device_t *adev) -{ - txhostdesc_t *hostdesc; - u8 *txbuf; - int i; - - FN_ENTER; - - /* allocate TX buffer */ - /* WLAN_A4FR_MAXLEN_WEP_FCS */ - adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; - - adev->txbuf_start - = acx_allocate(adev, adev->txbuf_area_size, - &adev->txbuf_startphy, "txbuf_start"); - if (!adev->txbuf_start) - goto fail; - - /* allocate the TX host descriptor queue pool */ - adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); - - adev->txhostdesc_start - = acx_allocate(adev, adev->txhostdesc_area_size, - &adev->txhostdesc_startphy, "txhostdesc_start"); - if (!adev->txhostdesc_start) - goto fail; - - /* check for proper alignment of TX host descriptor pool */ - if ((long) adev->txhostdesc_start & 3) { - pr_acx("driver bug: dma alloc returns unaligned address\n"); - goto fail; - } - - hostdesc = adev->txhostdesc_start; - txbuf = adev->txbuf_start; - -#if 0 - /* Each tx buffer is accessed by hardware via - ** txdesc -> txhostdesc(s) -> txbuffer(s). - ** We use only one txhostdesc per txdesc, but it looks like - ** acx111 is buggy: it accesses second txhostdesc - ** (via hostdesc.desc_phy_next field) even if - ** txdesc->length == hostdesc->length and thus - ** entire packet was placed into first txhostdesc. - ** Due to this bug acx111 hangs unless second txhostdesc - ** has le16_to_cpu(hostdesc.length) = 3 (or larger) - ** Storing NULL into hostdesc.desc_phy_next - ** doesn't seem to help. - ** - ** Update: although it worked on Xterasys XN-2522g - ** with len=3 trick, WG311v2 is even more bogus, doesn't work. - ** Keeping this code (#ifdef'ed out) for documentational purposes. - */ - for (i = 0; i < TX_CNT*2; i++) { - hostdesc_phy += sizeof(*hostdesc); - if (!(i & 1)) { - hostdesc->data_phy = cpu2acx(txbuf_phy); - /* hostdesc->data_offset = ... */ - /* hostdesc->reserved = ... */ - hostdesc->Ctl_16 = cpu_to_le16(DESC_CTL_HOSTOWN); - /* hostdesc->length = ... */ - hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); - hostdesc->pNext = ptr2acx(NULL); - /* hostdesc->Status = ... */ - /* below: non-hardware fields */ - hostdesc->data = txbuf; - - txbuf += WLAN_A4FR_MAXLEN_WEP_FCS; - txbuf_phy += WLAN_A4FR_MAXLEN_WEP_FCS; - } else { - /* hostdesc->data_phy = ... */ - /* hostdesc->data_offset = ... */ - /* hostdesc->reserved = ... */ - /* hostdesc->Ctl_16 = ... */ - hostdesc->length = cpu_to_le16(3); /* bug workaround */ - /* hostdesc->desc_phy_next = ... */ - /* hostdesc->pNext = ... */ - /* hostdesc->Status = ... */ - /* below: non-hardware fields */ - /* hostdesc->data = ... */ - } - hostdesc++; - } -#endif - - /* We initialize two hostdescs so that they point to adjacent - * memory areas. Thus txbuf is really just a contiguous memory area */ - for (i = 0; i < TX_CNT * 2; i++) { - /* ->data is a non-hardware field: */ - hostdesc->data = txbuf; - - if (!(i & 1)) { - txbuf += WLAN_HDR_A3_LEN; - } else { - txbuf += WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN; - } - hostdesc++; - } - hostdesc--; - - FN_EXIT1(OK); - return OK; - -fail: - // OW FIXME Logging - pr_acx("create_tx_host_desc_queue FAILED\n"); - /* dealloc will be done by free function on error case */ - - FN_EXIT1(NOT_OK); - return NOT_OK; -} -#endif void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, u32 rx_queue_start) @@ -959,34 +779,6 @@ void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) * others have been initialised to NULL so this * function can be used if only part of the queues were allocated. */ -#if 0 -void acxmem_free_desc_queues(acx_device_t *adev) -{ - -#define ACX_FREE_QUEUE(size, ptr, phyaddr) \ - if (ptr) { \ - kfree(ptr); \ - ptr = NULL; \ - size = 0; \ - } - - FN_ENTER; - - ACX_FREE_QUEUE(adev->txhostdesc_area_size, adev->txhostdesc_start, - adev->txhostdesc_startphy); - ACX_FREE_QUEUE(adev->txbuf_area_size, adev->txbuf_start, - adev->txbuf_startphy); - adev->txdesc_start = NULL; - - ACX_FREE_QUEUE(adev->rxhostdesc_area_size, adev->rxhostdesc_start, - adev->rxhostdesc_startphy); - ACX_FREE_QUEUE(adev->rxbuf_area_size, adev->rxbuf_start, - adev->rxbuf_startphy); - adev->rxdesc_start = NULL; - - FN_EXIT0; -} -#endif STATick void acxmem_delete_dma_regions(acx_device_t *adev) { @@ -1010,30 +802,6 @@ STATick void acxmem_delete_dma_regions(acx_device_t *adev) { FN_EXIT0; } -#if 0 -STATick -void* acxmem_allocate(acx_device_t *adev, size_t size, - dma_addr_t *phy, const char *msg) -{ - void *ptr; - ptr = kmalloc(size, GFP_KERNEL); - /* - * The ACX can't use the physical address, so we'll have to fake it - * later and it might be handy to have the virtual address. - */ - *phy = (dma_addr_t) NULL; - - if (ptr) { - log(L_DEBUG, "%s sz=%d adr=0x%p phy=0x%08llx\n", - msg, (int)size, ptr, (unsigned long long)*phy); - memset(ptr, 0, size); - return ptr; - } - pr_err("acx: %s allocation FAILED (%d bytes)\n", - msg, (int) size); - return NULL; -} -#endif /* * BOM Firmware, EEPROM, Phy @@ -1045,75 +813,6 @@ void* acxmem_allocate(acx_device_t *adev, size_t size, * * Uploads the appropriate radio module firmware into the card. */ -#if 0 // now in merge.c -int acxmem_upload_radio(acx_device_t *adev) { - acx_ie_memmap_t mm; - firmware_image_t *radio_image; - acx_cmd_radioinit_t radioinit; - int res = NOT_OK; - int try; - u32 offset; - u32 size; - char filename[sizeof("RADIONN.BIN")]; - - acxmem_lock_flags; - - if (!adev->need_radio_fw) - return OK; - - FN_ENTER; - - acx_interrogate(adev, &mm, ACX1xx_IE_MEMORY_MAP); - offset = le32_to_cpu(mm.CodeEnd); - - snprintf(filename, sizeof(filename), "RADIO%02x.BIN", adev->radio_type); - radio_image = acx_read_fw(adev->bus_dev, filename, &size); - if (!radio_image) { - pr_acx("can't load radio module '%s'\n", filename); - goto fail; - } - - acx_issue_cmd(adev, ACX1xx_CMD_SLEEP, NULL, 0); - - for (try = 1; try <= 5; try++) { - acxmem_lock(); - res = acxmem_write_fw(adev, radio_image, offset); - log(L_DEBUG|L_INIT, "acx_write_fw (radio): %d\n", res); - if (OK == res) { - res = acxmem_validate_fw(adev, radio_image, offset); - log(L_DEBUG|L_INIT, "acx_validate_fw (radio): %d\n", res); - } - acxmem_unlock(); - - if (OK == res) - break; - pr_acx("radio firmware upload attempt #%d FAILED, " - "retrying...\n", try); - acx_mwait(1000); /* better wait for a while... */ - } - - acx_issue_cmd(adev, ACX1xx_CMD_WAKE, NULL, 0); - radioinit.offset = cpu_to_le32(offset); - - /* no endian conversion needed, remains in card CPU area: */ - radioinit.len = radio_image->size; - - vfree(radio_image); - - if (OK != res) - goto fail; - - /* will take a moment so let's have a big timeout */ - acx_issue_cmd_timeo(adev, ACX1xx_CMD_RADIOINIT, - &radioinit, sizeof(radioinit), CMD_TIMEOUT_MS(1000)); - - res = acx_interrogate(adev, &mm, ACX1xx_IE_MEMORY_MAP); - - fail: - FN_EXIT1(res); - return res; -} -#endif /* * acxmem_read_eeprom_byte @@ -3038,14 +2737,6 @@ acxmem_get_txdesc(acx_device_t *adev, int index) { return (txdesc_t*) (((u8*) adev->txdesc_start) + index * adev->txdesc_size); } -#if 0 -// STATick inline -txdesc_t* -acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc) { - return (txdesc_t*) (((u8*) txdesc) + inc * adev->txdesc_size); -} -#endif - STATick txhostdesc_t* acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { int index = (u8*) txdesc - (u8*) adev->txdesc_start; @@ -3686,18 +3377,6 @@ void acxmem_irq_work(struct work_struct *work) /* * acxmem_handle_info_irq */ -#if 0 -/* scan is complete. all frames now on the receive queue are valid */ -#define INFO_SCAN_COMPLETE 0x0001 -#define INFO_WEP_KEY_NOT_FOUND 0x0002 -/* hw has been reset as the result of a watchdog timer timeout */ -#define INFO_WATCH_DOG_RESET 0x0003 -/* failed to send out NULL frame from PS mode notification to AP */ -/* recommended action: try entering 802.11 PS mode again */ -#define INFO_PS_FAIL 0x0004 -/* encryption/decryption process on a packet failed */ -#define INFO_IV_ICV_FAILURE 0x0005 -#endif /* Info mailbox format: 2 bytes: type @@ -3721,50 +3400,6 @@ void acxmem_irq_work(struct work_struct *work) */ #if 0 -STATick void acxmem_handle_info_irq(acx_device_t *adev) -{ -#if ACX_DEBUG - static const char * const info_type_msg[] = { - "(unknown)", - "scan complete", - "WEP key not found", - "internal watchdog reset was done", - "failed to send powersave (NULL frame) notification to AP", - "encrypt/decrypt on a packet has failed", - "TKIP tx keys disabled", - "TKIP rx keys disabled", - "TKIP rx: key ID not found", - "???", - "???", - "???", - "???", - "???", - "???", - "???", - "TKIP IV value exceeds thresh" - }; -#endif - u32 info_type, info_status; - - info_type = read_slavemem32(adev, (u32) adev->info_area); - - info_status = (info_type >> 16); - info_type = (u16) info_type; - - /* inform fw that we have read this info message */ - write_slavemem32(adev, (u32) adev->info_area, info_type | 0x00010000); - write_reg16(adev, IO_ACX_INT_TRIG, INT_TRIG_INFOACK); - write_flush(adev); - - log(L_IRQ|L_CTL, "got Info IRQ: status %04X type %04X: %s\n", - info_status, info_type, - info_type_msg[(info_type >= ARRAY_SIZE(info_type_msg)) ? - 0 : info_type] - ); -} -#endif - -#if 0 void acxmem_set_interrupt_mask(acx_device_t *adev) { FN_ENTER; @@ -4017,78 +3652,6 @@ static const struct ieee80211_ops acxmem_hw_ops = { #endif }; -#if 0 -STATick int acxmem_op_start(struct ieee80211_hw *hw) -{ - acx_device_t *adev = ieee2adev(hw); - int result = OK; - - FN_ENTER; - acx_sem_lock(adev); - - adev->initialized = 0; - - /* TODO: pci_set_power_state(pdev, PCI_D0); ? */ - - /* ifup device */ - acxmem_up(hw); - - /* We don't currently have to do anything else. - * The setup of the MAC should be subsequently completed via - * the mlme commands. - * Higher layers know we're ready from dev->start==1 and - * dev->tbusy==0. Our rx path knows to pass up received/ - * frames because of dev->flags&IFF_UP is true. - */ - - ieee80211_wake_queues(adev->ieee); - - adev->initialized = 1; - - acx_sem_unlock(adev); - FN_EXIT1(result); - - return result; -} - - -STATick void acxmem_op_stop(struct ieee80211_hw *hw) -{ - acx_device_t *adev = ieee2adev(hw); - acxmem_lock_flags; - - FN_ENTER; - acx_sem_lock(adev); - - acx_stop_queue(adev->ieee, "on ifdown"); - - /* disable all IRQs, release shared IRQ handler */ - acxmem_lock(); - acxmem_irq_disable(adev); - acxmem_unlock(); - synchronize_irq(adev->irq); - - acx_sem_unlock(adev); - cancel_work_sync(&adev->irq_work); - cancel_work_sync(&adev->tx_work); - acx_sem_lock(adev); - - acx_tx_queue_flush(adev); - - del_timer_sync(&adev->mgmt_timer); - - CLEAR_BIT(adev->dev_state_mask, ACX_STATE_IFACE_UP); - - /* TODO: pci_set_power_state(pdev, PCI_D3hot); ? */ - - adev->initialized = 0; - - log(L_INIT, "acxpci: closed device\n"); - - acx_sem_unlock(adev); - FN_EXIT0; -} -#endif /* * BOM Helpers diff --git a/pci.c b/pci.c index 0487d93..7dd80b8 100644 --- a/pci.c +++ b/pci.c @@ -74,15 +74,6 @@ // static void acxpci_log_txbuffer(acx_device_t * adev); // Data Access -#if 0 -INLINE_IO u32 read_reg32(acx_device_t * adev, unsigned int offset); -INLINE_IO u16 read_reg16(acx_device_t * adev, unsigned int offset); -INLINE_IO u8 read_reg8(acx_device_t * adev, unsigned int offset); -INLINE_IO void write_reg32(acx_device_t * adev, unsigned int offset, u32 val); -INLINE_IO void write_reg16(acx_device_t * adev, unsigned int offset, u16 val); -INLINE_IO void write_reg8(acx_device_t * adev, unsigned int offset, u8 val); -INLINE_IO void write_flush(acx_device_t * adev); -#endif // int acxpci_create_hostdesc_queues(acx_device_t * adev); //static @@ -239,261 +230,17 @@ void __exit acxpci_cleanup_module(void); * BOM Logging * ================================================== */ -#if 0 -static void acxpci_log_rxbuffer(const acx_device_t * adev) -{ - register const struct rxhostdesc *rxhostdesc; - int i; - - /* no FN_ENTER here, we don't want that */ - - rxhostdesc = adev->rxhostdesc_start; - if (unlikely(!rxhostdesc)) - return; - for (i = 0; i < RX_CNT; i++) { - if ((rxhostdesc->Ctl_16 & cpu_to_le16(DESC_CTL_HOSTOWN)) - && (rxhostdesc->Status & cpu_to_le32(DESC_STATUS_FULL))) - pr_acx("rx: buf %d full\n", i); - rxhostdesc++; - } -} - -static void acxpci_log_txbuffer(acx_device_t * adev) -{ - txdesc_t *txdesc; - int i; - - /* no FN_ENTER here, we don't want that */ - /* no locks here, since it's entirely non-critical code */ - txdesc = adev->txdesc_start; - if (unlikely(!txdesc)) - return; - pr_acx("tx: desc->Ctl8's:"); - for (i = 0; i < TX_CNT; i++) { - pr_acx(" %02X", txdesc->Ctl_8); - txdesc = acxpci_advance_txdesc(adev, txdesc, 1); - } - pr_acx("\n"); -} -#endif #include "pci-inlines.h" // ----- -#if 0 -int acxpci_create_hostdesc_queues(acx_device_t * adev) -{ - int result; - result = acxpci_create_tx_host_desc_queue(adev); - if (OK != result) - return result; - result = acxpci_create_rx_host_desc_queue(adev); - return result; -} -#endif - /* * acxpci_s_create_rx_host_desc_queue * * the whole size of a data buffer (header plus data body) * plus 32 bytes safety offset at the end */ -//static -#if 0 -int acxpci_create_rx_host_desc_queue(acx_device_t * adev) -{ - rxhostdesc_t *hostdesc; - rxbuffer_t *rxbuf; - dma_addr_t hostdesc_phy; - dma_addr_t rxbuf_phy; - int i; - - FN_ENTER; - - /* allocate the RX host descriptor queue pool */ - adev->rxhostdesc_area_size = RX_CNT * sizeof(*hostdesc); - adev->rxhostdesc_start = acxpci_allocate(adev, - adev->rxhostdesc_area_size, - &adev->rxhostdesc_startphy, "rxhostdesc_start"); - if (!adev->rxhostdesc_start) - goto fail; - /* check for proper alignment of RX host descriptor pool */ - if ((long)adev->rxhostdesc_start & 3) { - pr_acx("driver bug: dma alloc returns unaligned address\n"); - goto fail; - } - - /* allocate Rx buffer pool which will be used by the acx - * to store the whole content of the received frames in it */ - adev->rxbuf_area_size = RX_CNT * RX_BUFFER_SIZE; - adev->rxbuf_start - = acxpci_allocate(adev, adev->rxbuf_area_size, - &adev->rxbuf_startphy, "rxbuf_start"); - if (!adev->rxbuf_start) - goto fail; - - rxbuf = adev->rxbuf_start; - rxbuf_phy = adev->rxbuf_startphy; - hostdesc = adev->rxhostdesc_start; - hostdesc_phy = adev->rxhostdesc_startphy; - - /* don't make any popular C programming pointer arithmetic mistakes - * here, otherwise I'll kill you... - * (and don't dare asking me why I'm warning you about that...) */ - for (i = 0; i < RX_CNT; i++) { - hostdesc->data = rxbuf; - hostdesc->data_phy = cpu2acx(rxbuf_phy); - hostdesc->length = cpu_to_le16(RX_BUFFER_SIZE); - CLEAR_BIT(hostdesc->Ctl_16, cpu_to_le16(DESC_CTL_HOSTOWN)); - rxbuf++; - rxbuf_phy += sizeof(*rxbuf); - hostdesc_phy += sizeof(*hostdesc); - hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); - hostdesc++; - } - hostdesc--; - hostdesc->desc_phy_next = cpu2acx(adev->rxhostdesc_startphy); - FN_EXIT1(OK); - return OK; - fail: - pr_acx("create_rx_host_desc_queue FAILED\n"); - /* dealloc will be done by free function on error case */ - FN_EXIT1(NOT_OK); - return NOT_OK; -} -#endif - -#if 0 -// static -int acxpci_create_tx_host_desc_queue(acx_device_t * adev) -{ - txhostdesc_t *hostdesc; - u8 *txbuf; - dma_addr_t hostdesc_phy; - dma_addr_t txbuf_phy; - int i; - - FN_ENTER; - - /* allocate TX buffer */ - /* OW 20100513 adev->txbuf_area_size = TX_CNT - * *WLAN_A4FR_MAXLEN_WEP_FCS (30 + 2312 + 4); */ - adev->txbuf_area_size = TX_CNT * WLAN_A4FR_MAXLEN_WEP_FCS; - adev->txbuf_start - = acx_allocate(adev, adev->txbuf_area_size, - &adev->txbuf_startphy, "txbuf_start"); - if (!adev->txbuf_start) - goto fail; - - /* allocate the TX host descriptor queue pool */ - adev->txhostdesc_area_size = TX_CNT * 2 * sizeof(*hostdesc); - adev->txhostdesc_start - = acx_allocate(adev, adev->txhostdesc_area_size, - &adev->txhostdesc_startphy, - "txhostdesc_start"); - if (!adev->txhostdesc_start) - goto fail; - /* check for proper alignment of TX host descriptor pool */ - if ((long)adev->txhostdesc_start & 3) { - pr_acx("driver bug: dma alloc returns unaligned address\n"); - goto fail; - } - - hostdesc = adev->txhostdesc_start; - hostdesc_phy = adev->txhostdesc_startphy; - txbuf = adev->txbuf_start; - txbuf_phy = adev->txbuf_startphy; - -#if 0 -/* Each tx buffer is accessed by hardware via -** txdesc -> txhostdesc(s) -> txbuffer(s). -** We use only one txhostdesc per txdesc, but it looks like -** acx111 is buggy: it accesses second txhostdesc -** (via hostdesc.desc_phy_next field) even if -** txdesc->length == hostdesc->length and thus -** entire packet was placed into first txhostdesc. -** Due to this bug acx111 hangs unless second txhostdesc -** has le16_to_cpu(hostdesc.length) = 3 (or larger) -** Storing NULL into hostdesc.desc_phy_next -** doesn't seem to help. -** -** Update: although it worked on Xterasys XN-2522g -** with len=3 trick, WG311v2 is even more bogus, doesn't work. -** Keeping this code (#ifdef'ed out) for documentational purposes. -*/ - for (i = 0; i < TX_CNT * 2; i++) { - hostdesc_phy += sizeof(*hostdesc); - if (!(i & 1)) { - hostdesc->data_phy = cpu2acx(txbuf_phy); - /* hostdesc->data_offset = ... */ - /* hostdesc->reserved = ... */ - hostdesc->Ctl_16 = cpu_to_le16(DESC_CTL_HOSTOWN); - /* hostdesc->length = ... */ - hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); - hostdesc->pNext = ptr2acx(NULL); - /* hostdesc->Status = ... */ - /* below: non-hardware fields */ - hostdesc->data = txbuf; - - txbuf += WLAN_A4FR_MAXLEN_WEP_FCS; - txbuf_phy += WLAN_A4FR_MAXLEN_WEP_FCS; - } else { - /* hostdesc->data_phy = ... */ - /* hostdesc->data_offset = ... */ - /* hostdesc->reserved = ... */ - /* hostdesc->Ctl_16 = ... */ - hostdesc->length = cpu_to_le16(3); /* bug workaround */ - /* hostdesc->desc_phy_next = ... */ - /* hostdesc->pNext = ... */ - /* hostdesc->Status = ... */ - /* below: non-hardware fields */ - /* hostdesc->data = ... */ - } - hostdesc++; - } -#endif -/* We initialize two hostdescs so that they point to adjacent -** memory areas. Thus txbuf is really just a contiguous memory area */ - for (i = 0; i < TX_CNT * 2; i++) { - hostdesc_phy += sizeof(*hostdesc); - - hostdesc->data_phy = cpu2acx(txbuf_phy); - /* done by memset(0): hostdesc->data_offset = 0; */ - /* hostdesc->reserved = ... */ - hostdesc->Ctl_16 = cpu_to_le16(DESC_CTL_HOSTOWN); - /* hostdesc->length = ... */ - hostdesc->desc_phy_next = cpu2acx(hostdesc_phy); - /* done by memset(0): hostdesc->pNext = ptr2acx(NULL); */ - /* hostdesc->Status = ... */ - /* ->data is a non-hardware field: */ - hostdesc->data = txbuf; - - if (!(i & 1)) { - // OW 20100513 txbuf += 24 /*WLAN_HDR_A3_LEN*/; - // OW 20100513 txbuf_phy += 24 /*WLAN_HDR_A3_LEN*/; - txbuf += WLAN_HDR_A3_LEN; - txbuf_phy += WLAN_HDR_A3_LEN; - } else { - // OW 20100513 txbuf += 30 + 2132 + 4 - 24/*WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN*/; - // OW 20100513 txbuf_phy += 30 + 2132 +4 - 24/*WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN*/; - txbuf += WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN; - txbuf_phy += WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN; - } - hostdesc++; - } - hostdesc--; - hostdesc->desc_phy_next = cpu2acx(adev->txhostdesc_startphy); - - FN_EXIT1(OK); - return OK; -fail: - pr_acx("create_tx_host_desc_queue FAILED\n"); - /* dealloc will be done by free function on error case */ - FN_EXIT1(NOT_OK); - return NOT_OK; -} -#endif void @@ -651,36 +398,6 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, * others have been initialised to NULL so this * function can be used if only part of the queues were allocated. */ -#if 0 -void acxpci_free_desc_queues(acx_device_t * adev) -{ - -#define ACX_FREE_QUEUE(size, ptr, phyaddr) \ - if (ptr) { \ - acxpci_free_coherent(NULL, size, ptr, phyaddr); \ - ptr = NULL; \ - size = 0; \ - } - - FN_ENTER; - - ACX_FREE_QUEUE(adev->txhostdesc_area_size, adev->txhostdesc_start, - adev->txhostdesc_startphy); - ACX_FREE_QUEUE(adev->txbuf_area_size, adev->txbuf_start, - adev->txbuf_startphy); - - adev->txdesc_start = NULL; - - ACX_FREE_QUEUE(adev->rxhostdesc_area_size, adev->rxhostdesc_start, - adev->rxhostdesc_startphy); - ACX_FREE_QUEUE(adev->rxbuf_area_size, adev->rxbuf_start, - adev->rxbuf_startphy); - - adev->rxdesc_start = NULL; - - FN_EXIT0; -} -#endif static void acxpci_delete_dma_regions(acx_device_t * adev) { @@ -709,27 +426,6 @@ void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, size, vaddr, dma_handle); } -#if 0 // to merge.c -static -void *acxpci_allocate(acx_device_t * adev, size_t size, - dma_addr_t * phy, const char *msg) -{ - void *ptr; - - ptr = dma_alloc_coherent(adev->bus_dev, size, phy, GFP_KERNEL); - - if (ptr) { - log(L_DEBUG, "%s sz=%d adr=0x%p phy=0x%08llx\n", - msg, (int)size, ptr, (unsigned long long)*phy); - memset(ptr, 0, size); - return ptr; - } - pr_err("%s allocation FAILED (%d bytes)\n", - msg, (int)size); - return NULL; -} -#endif - /* * BOM Firmware, EEPROM, Phy * ================================================== @@ -742,74 +438,6 @@ void *acxpci_allocate(acx_device_t * adev, size_t size, * * Origin: Standard Read/Write to IO */ -#if 0 -int acxpci_upload_radio(acx_device_t * adev) -{ - acx_ie_memmap_t mm; - firmware_image_t *radio_image; - acx_cmd_radioinit_t radioinit; - int res = NOT_OK; - int try; - u32 offset; - u32 size; - char filename[sizeof("tiacx1NNrNN")]; - - if (!adev->need_radio_fw) - return OK; - - FN_ENTER; - - acx_interrogate(adev, &mm, ACX1xx_IE_MEMORY_MAP); - offset = le32_to_cpu(mm.CodeEnd); - - snprintf(filename, sizeof(filename), "tiacx1%02dr%02X", - IS_ACX111(adev) * 11, adev->radio_type); - radio_image = acx_read_fw(adev->bus_dev, filename, &size); - if (!radio_image) { - pr_acx("can't load radio module '%s'\n", filename); - goto fail; - } - - acx_issue_cmd(adev, ACX1xx_CMD_SLEEP, NULL, 0); - - for (try = 1; try <= 5; try++) { - res = acxpci_write_fw(adev, radio_image, offset); - log(L_DEBUG | L_INIT, "acx_write_fw (radio): %d\n", res); - if (OK == res) { - res = acxpci_validate_fw(adev, radio_image, offset); - log(L_DEBUG | L_INIT, "acx_validate_fw (radio): %d\n", - res); - } - - if (OK == res) - break; - pr_acx("radio firmware upload attempt #%d FAILED, " - "retrying...\n", try); - acx_mwait(1000); /* better wait for a while... */ - } - - acx_issue_cmd(adev, ACX1xx_CMD_WAKE, NULL, 0); - radioinit.offset = cpu_to_le32(offset); - /* no endian conversion needed, remains in card CPU area: */ - radioinit.len = radio_image->size; - - vfree(radio_image); - - if (OK != res) - goto fail; - - /* will take a moment so let's have a big timeout */ - acx_issue_cmd_timeo(adev, ACX1xx_CMD_RADIOINIT, - &radioinit, sizeof(radioinit), - CMD_TIMEOUT_MS(1000)); - - res = acx_interrogate(adev, &mm, ACX1xx_IE_MEMORY_MAP); - fail: - FN_EXIT1(res); - return res; -} - -#endif /* * acxpci_read_eeprom_byte @@ -2576,18 +2204,6 @@ void acxpci_irq_work(struct work_struct *work) /* * acxpci_handle_info_irq */ -#if 0 -/* scan is complete. all frames now on the receive queue are valid */ -#define INFO_SCAN_COMPLETE 0x0001 -#define INFO_WEP_KEY_NOT_FOUND 0x0002 -/* hw has been reset as the result of a watchdog timer timeout */ -#define INFO_WATCH_DOG_RESET 0x0003 -/* failed to send out NULL frame from PS mode notification to AP */ -/* recommended action: try entering 802.11 PS mode again */ -#define INFO_PS_FAIL 0x0004 -/* encryption/decryption process on a packet failed */ -#define INFO_IV_ICV_FAILURE 0x0005 -#endif /* Info mailbox format: 2 bytes: type 2 bytes: status @@ -2608,50 +2224,6 @@ more bytes may follow it does NOT clear bit 0x0001, and this bit will probably stay forever set after we set it once. Let's hope this will be fixed in firmware someday */ -#if 0 -static void acxpci_handle_info_irq(acx_device_t * adev) -{ -#if ACX_DEBUG - static const char *const info_type_msg[] = { - "(unknown)", - "scan complete", - "WEP key not found", - "internal watchdog reset was done", - "failed to send powersave (NULL frame) notification to AP", - "encrypt/decrypt on a packet has failed", - "TKIP tx keys disabled", - "TKIP rx keys disabled", - "TKIP rx: key ID not found", - "???", - "???", - "???", - "???", - "???", - "???", - "???", - "TKIP IV value exceeds thresh" - }; -#endif - u32 info_type, info_status; - - info_type = acx_readl(adev->info_area); - info_status = (info_type >> 16); - info_type = (u16) info_type; - - /* inform fw that we have read this info message */ - acx_writel(info_type | 0x00010000, adev->info_area); - write_reg16(adev, IO_ACX_INT_TRIG, INT_TRIG_INFOACK); - write_flush(adev); - - log(L_CTL, "info_type:%04X info_status:%04X\n", info_type, info_status); - - log(L_IRQ, "got Info IRQ: status %04X type %04X: %s\n", - info_status, info_type, - info_type_msg[(info_type >= ARRAY_SIZE(info_type_msg)) ? - 0 : info_type] - ); -} -#endif // handle-info-irq void acxpci_set_interrupt_mask(acx_device_t * adev) { @@ -2723,73 +2295,6 @@ static const struct ieee80211_ops acxpci_hw_ops = { .set_tim = acx_op_set_tim, }; -#if 0 -static int acxpci_op_start(struct ieee80211_hw *hw) -{ - acx_device_t *adev = ieee2adev(hw); - int result = OK; - - FN_ENTER; - acx_sem_lock(adev); - - adev->initialized = 0; - - /* TODO: pci_set_power_state(pdev, PCI_D0); ? */ - - /* ifup device */ - acxpci_up(hw); - - /* We don't currently have to do anything else. - * The setup of the MAC should be subsequently completed via - * the mlme commands. - * Higher layers know we're ready from dev->start==1 and - * dev->tbusy==0. Our rx path knows to pass up received/ - * frames because of dev->flags&IFF_UP is true. - */ - ieee80211_wake_queues(adev->ieee); - - adev->initialized = 1; - - acx_sem_unlock(adev); - FN_EXIT1(result); - return result; -} - -static void acxpci_op_stop(struct ieee80211_hw *hw) -{ - acx_device_t *adev = ieee2adev(hw); - - FN_ENTER; - acx_sem_lock(adev); - - acx_stop_queue(adev->ieee, "on ifdown"); - - /* disable all IRQs, release shared IRQ handler */ - acxpci_irq_disable(adev); - synchronize_irq(adev->irq); - - acx_sem_unlock(adev); - cancel_work_sync(&adev->irq_work); - cancel_work_sync(&adev->tx_work); - acx_sem_lock(adev); - - acx_tx_queue_flush(adev); - - del_timer_sync(&adev->mgmt_timer); - - CLEAR_BIT(adev->dev_state_mask, ACX_STATE_IFACE_UP); - - /* TODO: pci_set_power_state(pdev, PCI_D3hot); ? */ - - adev->initialized = 0; - - log(L_INIT, "closed device\n"); - - acx_sem_unlock(adev); - FN_EXIT0; -} -#endif - /* * BOM Helpers * ================================================== -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:37
|
pci.c: #if0 original drop "static" from acxpci_free_coherent() //= proto reformat for sdiff mem.c: #if0 original //= proto reformat for sdiff merge.c: modify ACX_FREE macro to handle both kinds of adev, call acxpci_free_coherent() for IS_PCI(adev) add some //######## fences merge.h: add proto, for common.c pci.h: //= old proto common.c: drop acx(pci|mem)_free_desc_queues() for unified, drop if/else. Tested-by: jimc - modprobes, ifups, iwconfigs Signed-off-by: Jim Cromie <jim...@gm...> --- common.c | 11 +------- mem.c | 78 ++++++++++++++++++++++++++++++++++++++++--------------------- merge.c | 52 +++++++++++++++++++++++++++++++++++++++++ merge.h | 1 + pci.c | 49 ++++++++++++++++++++++---------------- pci.h | 2 +- 6 files changed, 135 insertions(+), 58 deletions(-) diff --git a/common.c b/common.c index 9483900..66a86fc 100644 --- a/common.c +++ b/common.c @@ -1138,10 +1138,7 @@ static int acx100_create_dma_regions(acx_device_t * adev) fail: acx_mwait(1000); /* ? */ - if (IS_PCI(adev)) - acxpci_free_desc_queues(adev); - else if (IS_MEM(adev)) - acxmem_free_desc_queues(adev); + acx_free_desc_queues(adev); end: FN_EXIT1(res); return res; @@ -1247,11 +1244,7 @@ static int acx111_create_dma_regions(acx_device_t * adev) return OK; fail: - if (IS_PCI(adev)) - acxpci_free_desc_queues(adev); - else if (IS_MEM(adev)) - acxmem_free_desc_queues(adev); - + acx_free_desc_queues(adev); FN_EXIT1(NOT_OK); return NOT_OK; } diff --git a/mem.c b/mem.c index d3db2cf..f56efe9 100644 --- a/mem.c +++ b/mem.c @@ -151,7 +151,7 @@ int acxmem_create_tx_host_desc_queue(acx_device_t *adev); void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, u32 rx_queue_start); STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start); STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start); -void acxmem_free_desc_queues(acx_device_t *adev); +//= void acxmem_free_desc_queues(acx_device_t *adev); STATick void acxmem_delete_dma_regions(acx_device_t *adev); //= STATick void *acxmem_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); @@ -784,7 +784,8 @@ fail: #endif void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, - u32 rx_queue_start) { + u32 rx_queue_start) +{ u32 *p; int i; @@ -802,7 +803,9 @@ void acxmem_create_desc_queues(acx_device_t *adev, u32 tx_queue_start, } -STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) { +STATick +void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) +{ rxdesc_t *rxdesc; u32 mem_offs; int i; @@ -821,19 +824,24 @@ STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) rxdesc = adev->rxdesc_start; for (i = 0; i < RX_CNT; i++) { log(L_DEBUG, "rx descriptor %d @ 0x%p\n", i, rxdesc); - rxdesc = adev->rxdesc_start = (rxdesc_t *) acx2cpu(rxdesc->pNextDesc); + rxdesc = adev->rxdesc_start + = (rxdesc_t *) acx2cpu(rxdesc->pNextDesc); } } else { /* we didn't pre-calculate rxdesc_start in case of ACX100 */ /* rxdesc_start should be right AFTER Tx pool */ - adev->rxdesc_start = (rxdesc_t *) ((u8 *) adev->txdesc_start + (TX_CNT - * sizeof(txdesc_t))); + adev->rxdesc_start = (rxdesc_t *) + ((u8 *) adev->txdesc_start + + (TX_CNT * sizeof(txdesc_t))); + /* NB: sizeof(txdesc_t) above is valid because we know - ** we are in if (acx100) block. Beware of cut-n-pasting elsewhere! - ** acx111's txdesc is larger! */ + ** we are in the if (acx100) block. Beware of + ** cut-n-pasting elsewhere! acx111's txdesc is + ** larger! */ mem_offs = (u32) adev->rxdesc_start; - while (mem_offs < (u32) adev->rxdesc_start + (RX_CNT * sizeof(*rxdesc))) { + while (mem_offs < (u32) adev->rxdesc_start + + (RX_CNT * sizeof(*rxdesc))) { write_slavemem32(adev, mem_offs, 0); mem_offs += 4; } @@ -844,7 +852,8 @@ STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) log(L_DEBUG, "rx descriptor @ 0x%p\n", rxdesc); /* point to next rxdesc */ write_slavemem32(adev, (u32) &(rxdesc->pNextDesc), - (u32) cpu_to_le32 ((u8 *) rxdesc + sizeof(*rxdesc))); + (u32) cpu_to_le32 ((u8 *) rxdesc + + sizeof(*rxdesc))); /* go to the next one */ rxdesc++; } @@ -852,12 +861,15 @@ STATick void acxmem_create_rx_desc_queue(acx_device_t *adev, u32 rx_queue_start) rxdesc--; /* and point to the first making it a ring buffer */ - write_slavemem32(adev, (u32) &(rxdesc->pNextDesc), (u32) cpu_to_le32 (rx_queue_start)); + write_slavemem32(adev, (u32) &(rxdesc->pNextDesc), + (u32) cpu_to_le32 (rx_queue_start)); } FN_EXIT0; } -STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) { +STATick +void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) +{ txdesc_t *txdesc; u32 clr; int i; @@ -876,7 +888,7 @@ STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) adev->txdesc_start = (txdesc_t *) tx_queue_start; log(L_DEBUG, "adev->txdesc_start=%p\n", - adev->txdesc_start); + adev->txdesc_start); adev->tx_free = TX_CNT; /* done by memset: adev->tx_head = 0; */ @@ -894,14 +906,16 @@ STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) } } else { /* ACX100 Tx buffer needs to be initialized by us */ - /* clear whole send pool. sizeof is safe here (we are acx100) */ + /* clear whole send pool. sizeof is safe here (we are + * acx100) */ /* - * adev->txdesc_start refers to device memory, so we can't write - * directly to it. + * adev->txdesc_start refers to device memory, so we + * can't write directly to it. */ clr = (u32) adev->txdesc_start; - while (clr < (u32) adev->txdesc_start + (TX_CNT * sizeof(*txdesc))) { + while (clr < (u32) adev->txdesc_start + + (TX_CNT * sizeof(*txdesc))) { write_slavemem32(adev, clr, 0); clr += 4; } @@ -909,19 +923,21 @@ STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) /* loop over whole send pool */ for (i = 0; i < TX_CNT; i++) { log(L_DEBUG, "configure card tx descriptor: 0x%p, " - "size: 0x%X\n", txdesc, adev->txdesc_size); + "size: 0x%X\n", txdesc, adev->txdesc_size); /* initialise ctl */ /* * No auto DMA here */ write_slavemem8(adev, (u32) &(txdesc->Ctl_8), - (u8) (DESC_CTL_HOSTOWN| DESC_CTL_FIRSTFRAG)); + (u8) (DESC_CTL_HOSTOWN | + DESC_CTL_FIRSTFRAG)); /* done by memset(0): txdesc->Ctl2_8 = 0; */ /* point to next txdesc */ write_slavemem32(adev, (u32) &(txdesc->pNextDesc), - (u32) cpu_to_le32 ((u8 *) txdesc + adev->txdesc_size)); + (u32) cpu_to_le32 ((u8 *) txdesc + + adev->txdesc_size)); /* go to the next one */ /* ++ is safe here (we are acx100) */ @@ -930,11 +946,13 @@ STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) /* go back to the last one */ txdesc--; /* and point to the first making it a ring buffer */ - write_slavemem32(adev, (u32) &(txdesc->pNextDesc), (u32) cpu_to_le32 (tx_queue_start)); + write_slavemem32(adev, (u32) &(txdesc->pNextDesc), + (u32) cpu_to_le32 (tx_queue_start)); } FN_EXIT0; } +#if 0 /* * acxmem_free_desc_queues * @@ -942,7 +960,8 @@ STATick void acxmem_create_tx_desc_queue(acx_device_t *adev, u32 tx_queue_start) * others have been initialised to NULL so this * function can be used if only part of the queues were allocated. */ -void acxmem_free_desc_queues(acx_device_t *adev) { +void acxmem_free_desc_queues(acx_device_t *adev) +{ #define ACX_FREE_QUEUE(size, ptr, phyaddr) \ if (ptr) { \ @@ -953,16 +972,21 @@ void acxmem_free_desc_queues(acx_device_t *adev) { FN_ENTER; - ACX_FREE_QUEUE(adev->txhostdesc_area_size, adev->txhostdesc_start, adev->txhostdesc_startphy); - ACX_FREE_QUEUE(adev->txbuf_area_size, adev->txbuf_start, adev->txbuf_startphy); + ACX_FREE_QUEUE(adev->txhostdesc_area_size, adev->txhostdesc_start, + adev->txhostdesc_startphy); + ACX_FREE_QUEUE(adev->txbuf_area_size, adev->txbuf_start, + adev->txbuf_startphy); adev->txdesc_start = NULL; - ACX_FREE_QUEUE(adev->rxhostdesc_area_size, adev->rxhostdesc_start, adev->rxhostdesc_startphy); - ACX_FREE_QUEUE(adev->rxbuf_area_size, adev->rxbuf_start, adev->rxbuf_startphy); + ACX_FREE_QUEUE(adev->rxhostdesc_area_size, adev->rxhostdesc_start, + adev->rxhostdesc_startphy); + ACX_FREE_QUEUE(adev->rxbuf_area_size, adev->rxbuf_start, + adev->rxbuf_startphy); adev->rxdesc_start = NULL; FN_EXIT0; } +#endif STATick void acxmem_delete_dma_regions(acx_device_t *adev) { @@ -981,7 +1005,7 @@ STATick void acxmem_delete_dma_regions(acx_device_t *adev) { acx_mwait(100); - acxmem_free_desc_queues(adev); + acx_free_desc_queues(adev); FN_EXIT0; } diff --git a/merge.c b/merge.c index e2a96f5..e09f6e4 100644 --- a/merge.c +++ b/merge.c @@ -206,6 +206,9 @@ int acxpci_upload_radio(acx_device_t *adev) return acx_upload_radio(adev, filename); } +//########################################## +/* host desc queue stuff */ + void *acx_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg) { @@ -450,6 +453,55 @@ int acx_create_hostdesc_queues(acx_device_t *adev) return result; } +//########################################## +/* host desc queue stuff */ + +//########################################## +/* free desc queue stuff */ + +/* + * acx_free_desc_queues + * + * Releases the queues that have been allocated, the + * others have been initialised to NULL so this + * function can be used if only part of the queues were allocated. + */ +void acx_free_desc_queues(acx_device_t *adev) +{ + +#define ACX_FREE_QUEUE(adev, size, ptr, phyaddr) \ + if (ptr) { \ + if (IS_PCI(adev)) \ + acxpci_free_coherent(NULL, size, ptr, phyaddr); \ + else \ + kfree(ptr); \ + ptr = NULL; \ + size = 0; \ + } + + FN_ENTER; + + ACX_FREE_QUEUE(adev, adev->txhostdesc_area_size, + adev->txhostdesc_start, adev->txhostdesc_startphy); + + ACX_FREE_QUEUE(adev, adev->txbuf_area_size, + adev->txbuf_start, adev->txbuf_startphy); + + adev->txdesc_start = NULL; + + ACX_FREE_QUEUE(adev, adev->rxhostdesc_area_size, + adev->rxhostdesc_start, adev->rxhostdesc_startphy); + + ACX_FREE_QUEUE(adev, adev->rxbuf_area_size, + adev->rxbuf_start, adev->rxbuf_startphy); + + adev->rxdesc_start = NULL; + + FN_EXIT0; +} + +//########################################## +/* logging stuff */ void acx_log_rxbuffer(const acx_device_t *adev) { diff --git a/merge.h b/merge.h index f1e9b66..7b7ad96 100644 --- a/merge.h +++ b/merge.h @@ -19,3 +19,4 @@ void acx_handle_info_irq(acx_device_t *adev); void *acx_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); +void acx_free_desc_queues(acx_device_t *adev); diff --git a/pci.c b/pci.c index e55e328..721f2d6 100644 --- a/pci.c +++ b/pci.c @@ -94,9 +94,10 @@ void acxpci_create_desc_queues(acx_device_t * adev, u32 tx_queue_start, u32 rx_q static void acxpci_create_rx_desc_queue(acx_device_t * adev, u32 rx_queue_start); static void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start); -void acxpci_free_desc_queues(acx_device_t * adev); +//= void acxpci_free_desc_queues(acx_device_t * adev); static void acxpci_delete_dma_regions(acx_device_t * adev); -static inline void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle); +//=static inline +void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle); //= static void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg); // Firmware, EEPROM, Phy @@ -497,13 +498,14 @@ fail: void acxpci_create_desc_queues(acx_device_t * adev, u32 tx_queue_start, - u32 rx_queue_start) + u32 rx_queue_start) { acxpci_create_tx_desc_queue(adev, tx_queue_start); acxpci_create_rx_desc_queue(adev, rx_queue_start); } -static void acxpci_create_rx_desc_queue(acx_device_t * adev, u32 rx_queue_start) +static void acxpci_create_rx_desc_queue(acx_device_t * adev, + u32 rx_queue_start) { rxdesc_t *rxdesc; u32 mem_offs; @@ -525,13 +527,14 @@ static void acxpci_create_rx_desc_queue(acx_device_t * adev, u32 rx_queue_start) for (i = 0; i < RX_CNT; i++) { log(L_DEBUG, "rx descriptor %d @ 0x%p\n", i, rxdesc); rxdesc = adev->rxdesc_start = (rxdesc_t *) - (adev->iobase2 + acx2cpu(rxdesc->pNextDesc)); + (adev->iobase2 + acx2cpu(rxdesc->pNextDesc)); } } else { /* we didn't pre-calculate rxdesc_start in case of ACX100 */ /* rxdesc_start should be right AFTER Tx pool */ adev->rxdesc_start = (rxdesc_t *) - ((u8 *) adev->txdesc_start + (TX_CNT * sizeof(txdesc_t))); + ((u8 *) adev->txdesc_start + + (TX_CNT * sizeof(txdesc_t))); /* NB: sizeof(txdesc_t) above is valid because we know ** we are in if (acx100) block. Beware of cut-n-pasting elsewhere! ** acx111's txdesc is larger! */ @@ -545,7 +548,8 @@ static void acxpci_create_rx_desc_queue(acx_device_t * adev, u32 rx_queue_start) log(L_DEBUG, "rx descriptor @ 0x%p\n", rxdesc); rxdesc->Ctl_8 = DESC_CTL_RECLAIM | DESC_CTL_AUTODMA; /* point to next rxdesc */ - rxdesc->pNextDesc = cpu2acx(mem_offs + sizeof(*rxdesc)); + rxdesc->pNextDesc + = cpu2acx(mem_offs + sizeof(*rxdesc)); /* go to the next one */ mem_offs += sizeof(*rxdesc); rxdesc++; @@ -559,7 +563,8 @@ static void acxpci_create_rx_desc_queue(acx_device_t * adev, u32 rx_queue_start) FN_EXIT0; } -static void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start) +static void acxpci_create_tx_desc_queue(acx_device_t * adev, + u32 tx_queue_start) { txdesc_t *txdesc; txhostdesc_t *hostdesc; @@ -578,9 +583,9 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start) adev->txdesc_start = (txdesc_t *) (adev->iobase2 + tx_queue_start); log(L_DEBUG, "adev->iobase2=%p\n" - "acx: tx_queue_start=%08X\n" - "acx: adev->txdesc_start=%p\n", - adev->iobase2, tx_queue_start, adev->txdesc_start); + "acx: tx_queue_start=%08X\n" + "acx: adev->txdesc_start=%p\n", + adev->iobase2, tx_queue_start, adev->txdesc_start); adev->tx_free = TX_CNT; /* done by memset: adev->tx_head = 0; */ @@ -610,14 +615,15 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start) /* loop over whole send pool */ for (i = 0; i < TX_CNT; i++) { log(L_DEBUG, "configure card tx descriptor: 0x%p, " - "size: 0x%X\n", txdesc, adev->txdesc_size); + "size: 0x%X\n", txdesc, adev->txdesc_size); /* pointer to hostdesc memory */ txdesc->HostMemPtr = ptr2acx(hostmemptr); /* initialise ctl */ txdesc->Ctl_8 = (DESC_CTL_HOSTOWN | DESC_CTL_RECLAIM - | DESC_CTL_AUTODMA | - DESC_CTL_FIRSTFRAG); + | DESC_CTL_AUTODMA + | DESC_CTL_FIRSTFRAG); + /* done by memset(0): txdesc->Ctl2_8 = 0; */ /* point to next txdesc */ txdesc->pNextDesc = @@ -638,7 +644,7 @@ static void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start) FN_EXIT0; } - +#if 0 /* * acxpci_free_desc_queues * @@ -659,21 +665,22 @@ void acxpci_free_desc_queues(acx_device_t * adev) FN_ENTER; ACX_FREE_QUEUE(adev->txhostdesc_area_size, adev->txhostdesc_start, - adev->txhostdesc_startphy); + adev->txhostdesc_startphy); ACX_FREE_QUEUE(adev->txbuf_area_size, adev->txbuf_start, - adev->txbuf_startphy); + adev->txbuf_startphy); adev->txdesc_start = NULL; ACX_FREE_QUEUE(adev->rxhostdesc_area_size, adev->rxhostdesc_start, - adev->rxhostdesc_startphy); + adev->rxhostdesc_startphy); ACX_FREE_QUEUE(adev->rxbuf_area_size, adev->rxbuf_start, - adev->rxbuf_startphy); + adev->rxbuf_startphy); adev->rxdesc_start = NULL; FN_EXIT0; } +#endif static void acxpci_delete_dma_regions(acx_device_t * adev) { @@ -689,12 +696,12 @@ static void acxpci_delete_dma_regions(acx_device_t * adev) * while calling dma_free_coherent() interrupts need to be 'free' * but if you spinlock the whole function (acxpci_free_desc_queues) * you'll get an error */ - acxpci_free_desc_queues(adev); + acx_free_desc_queues(adev); FN_EXIT0; } -static inline +// static inline void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle) { diff --git a/pci.h b/pci.h index a271f3f..69bcb62 100644 --- a/pci.h +++ b/pci.h @@ -23,7 +23,7 @@ void acxpci_create_desc_queues(acx_device_t * adev, u32 tx_queue_start, u32 rx_q STATick void acxpci_create_rx_desc_queue(acx_device_t * adev, u32 rx_queue_start); STATick void acxpci_create_tx_desc_queue(acx_device_t * adev, u32 tx_queue_start); -void acxpci_free_desc_queues(acx_device_t * adev); +//= void acxpci_free_desc_queues(acx_device_t * adev); STATick void acxpci_delete_dma_regions(acx_device_t * adev); STATick inline void acxpci_free_coherent(struct pci_dev *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle); //= STATick void *acxpci_allocate(acx_device_t * adev, size_t size, dma_addr_t * phy, const char *msg); -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:38
|
pci.c: #if0 this fn-defn, //= proto merge.c: change fn-name of already copied fn. merge.h: add proto common.c: change acx_read_phy_reg() to call new fn-name Later: look at acxusb_read_phy_reg(), maybe unify it too. Tested-by: jimc - modprobes, ifups, iwconfigs Signed-off-by: Jim Cromie <jim...@gm...> --- common.c | 6 ++---- merge.c | 7 +++---- merge.h | 2 ++ pci.c | 5 +++-- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/common.c b/common.c index 66a86fc..bc6667f 100644 --- a/common.c +++ b/common.c @@ -1652,12 +1652,10 @@ acx_parse_configoption(acx_device_t * adev, int acx_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf) { - if (IS_PCI(adev)) - return acxpci_read_phy_reg(adev, reg, charbuf); + if (IS_PCI(adev) || IS_MEM(adev)) + return acxx_read_phy_reg(adev, reg, charbuf); if (IS_USB(adev)) return acxusb_read_phy_reg(adev, reg, charbuf); - if (IS_MEM(adev)) - return acxmem_read_phy_reg(adev, reg, charbuf); log(L_ANY, "%s: Unsupported dev_type=%i\n", __func__, (adev)->dev_type); return (NOT_OK); diff --git a/merge.c b/merge.c index e09f6e4..bb1ca83 100644 --- a/merge.c +++ b/merge.c @@ -719,14 +719,14 @@ static inline void acx_read_eeprom_area(acx_device_t *adev) #endif } -#if 1 // port soon to merge.c /* - * acxmem_s_read_phy_reg + * acxx_read_phy_reg - from mem.c, has locking which looks harmless for pci.c * + * common.c has acx_read_phy_reg too, called (pci|mem|usb), now (usb|x) * Messing with rx/tx disabling and enabling here * (write_reg32(adev, IO_ACX_ENABLE, 0b000000xx)) kills traffic */ -int acxmem_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf) +int acxx_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf) { int result = NOT_OK; int count; @@ -806,7 +806,6 @@ fail: FN_EXIT1(OK); // FN_EXIT0 in pci return OK; } -#endif // port soon /* * acxmem_s_write_fw diff --git a/merge.h b/merge.h index 7b7ad96..d1f04b3 100644 --- a/merge.h +++ b/merge.h @@ -20,3 +20,5 @@ void *acx_allocate(acx_device_t *adev, size_t size, dma_addr_t *phy, const char *msg); void acx_free_desc_queues(acx_device_t *adev); + +int acxx_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf); diff --git a/pci.c b/pci.c index 7dd80b8..4fcf9ba 100644 --- a/pci.c +++ b/pci.c @@ -96,7 +96,7 @@ int acxpci_upload_radio(acx_device_t * adev); int acxpci_read_eeprom_byte(acx_device_t * adev, u32 addr, u8 * charbuf); // int acxpci_s_write_eeprom(acx_device_t * adev, u32 addr, u32 len, const u8 * charbuf); static inline void acxpci_read_eeprom_area(acx_device_t * adev); -int acxpci_read_phy_reg(acx_device_t * adev, u32 reg, u8 * charbuf); +//int acxpci_read_phy_reg(acx_device_t * adev, u32 reg, u8 * charbuf); int acxpci_write_phy_reg(acx_device_t * adev, u32 reg, u8 value); // static int acxpci_write_fw(acx_device_t * adev, const firmware_image_t *fw_image, u32 offset); @@ -605,6 +605,7 @@ static inline void acxpci_read_eeprom_area(acx_device_t * adev) * Messing with rx/tx disabling and enabling here * (write_reg32(adev, IO_ACX_ENABLE, 0b000000xx)) kills traffic */ +#if 0 // in merge.c int acxpci_read_phy_reg(acx_device_t * adev, u32 reg, u8 * charbuf) { int result = NOT_OK; @@ -641,7 +642,7 @@ int acxpci_read_phy_reg(acx_device_t * adev, u32 reg, u8 * charbuf) FN_EXIT1(result); return result; } - +#endif int acxpci_write_phy_reg(acx_device_t * adev, u32 reg, u8 value) { -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:37
|
I toggled each to see why theyre there, and marked each with the reason Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 35 ++++++++++++++++++----------------- 1 files changed, 18 insertions(+), 17 deletions(-) diff --git a/mem.c b/mem.c index ac6c204..52b1d11 100644 --- a/mem.c +++ b/mem.c @@ -979,7 +979,7 @@ STATick inline void acxmem_read_eeprom_area(acx_device_t *adev) { * Messing with rx/tx disabling and enabling here * (write_reg32(adev, IO_ACX_ENABLE, 0b000000xx)) kills traffic */ -#if 0 // port soon to merge.c +#if 0 // copied to merge.c int acxmem_read_phy_reg(acx_device_t *adev, u32 reg, u8 *charbuf) { int result = NOT_OK; int count; @@ -1073,7 +1073,7 @@ int acxmem_write_phy_reg(acx_device_t *adev, u32 reg, u8 value) { * 0 success */ -#if 0 +#if 0 // copied to merge // static int acxmem_write_fw(acx_device_t *adev, const firmware_image_t *fw_image, u32 offset) { @@ -1433,7 +1433,7 @@ acx_show_card_eeprom_id(acx_device_t *adev) * Also ifup/down works more reliable on the mem device. * */ -#if 0 +#if 0 // copied to merge int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, void *buffer, unsigned buflen, unsigned cmd_timeout, const char* cmdstr) { @@ -1713,7 +1713,7 @@ STATick inline void acxmem_init_mboxes(acx_device_t *adev) { * This resets the device using low level hardware calls * as well as uploads and verifies the firmware to the card */ -#if 0 +#if 0 // copied to merge int acxmem_reset_dev(acx_device_t *adev) { const char* msg = ""; int result = NOT_OK; @@ -2014,7 +2014,7 @@ STATick void acxmem_up(struct ieee80211_hw *hw) { ** acxmem_i_set_multicast_list ** FIXME: most likely needs refinement */ -#if 0 +#if 0 // or mem.c:2019:2: error: implicit declaration of function 'ndev2adev' STATick void acxmem_i_set_multicast_list(struct net_device *ndev) { acx_device_t *adev = ndev2adev(ndev); unsigned long flags; @@ -2057,7 +2057,7 @@ STATick void acxmem_i_set_multicast_list(struct net_device *ndev) { * BOM Proc, Debug * ================================================== */ -#if 0 +#if 0 // copied to merge int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { const char *rtl, *thd, *ttl; txdesc_t *txdesc; @@ -2392,7 +2392,7 @@ STATick void acxmem_process_rxdesc(acx_device_t *adev) { * sufficiently many. */ // OW TODO Align with pci.c -#if 0 +#if 0 // copied to merge tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len) { struct txdesc *txdesc; unsigned head; @@ -2519,7 +2519,7 @@ tx_t *acxmem_alloc_tx(acx_device_t *adev, unsigned int len) { * state and move the queue head pointer back. * */ -#if 0 +#if 0 // copied to merge void acxmem_dealloc_tx(acx_device_t *adev, tx_t *tx_opaque) { /* * txdesc is the address of the descriptor on the ACX. @@ -2705,7 +2705,7 @@ STATick void acxmem_init_acx_txbuf(acx_device_t *adev) { /* Re-initialize tx-buffer list */ -#if 0 +#if 0 // copied to merge void acxmem_init_acx_txbuf2(acx_device_t *adev) { int i; @@ -2762,7 +2762,7 @@ acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { * pre-allocated tx descrs, properly setting up transfer data and * CTL_xxx flags according to fragment number. */ -#if 0 +#if 0 // copied to merge void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, struct ieee80211_tx_info *info, struct sk_buff *skb) { /* @@ -2982,7 +2982,7 @@ void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, * Everytime we get called we know where the next packet to be cleaned is. */ // OW TODO Very similar with pci: possible merging. -#if 0 +#if 0 // copied to merge unsigned int acxmem_tx_clean_txdesc(acx_device_t *adev) { txdesc_t *txdesc; txhostdesc_t *hostdesc; @@ -3210,7 +3210,8 @@ void acxmem_update_queue_indicator(acx_device_t *adev, int txqueue) { ** ** Called from network core. Must not sleep! */ -#if 0 +#if 0 // or mem.c:3242:3: warning: passing argument 1 of 'acx_wake_queue' + // from incompatible pointer type [enabled by default] STATick void acxmem_i_tx_timeout(struct net_device *ndev) { acx_device_t *adev = ndev2adev(ndev); unsigned long flags; @@ -3279,7 +3280,7 @@ STATick void acxmem_irq_disable(acx_device_t *adev) { /* Interrupt handler bottom-half */ // OW TODO Copy of pci: possible merging. -#if 0 +#if 0 // copied to merge void acxmem_irq_work(struct work_struct *work) { acx_device_t *adev = container_of(work, struct acx_device, irq_work); @@ -3399,7 +3400,7 @@ void acxmem_irq_work(struct work_struct *work) after we set it once. Let's hope this will be fixed in firmware someday */ -#if 0 +#if 0 // copied to merge void acxmem_set_interrupt_mask(acx_device_t *adev) { FN_ENTER; @@ -3452,7 +3453,7 @@ void acxmem_set_interrupt_mask(acx_device_t *adev) // OW FIXME Old interrupt handler // --- -#if 0 +#if 0 // or mem.c:3579:4: error: implicit declaration of function 'acxmem_log_unusual_irq' STATick irqreturn_t acxmem_interrupt(int irq, void *dev_id) { acx_device_t *adev = dev_id; @@ -3687,7 +3688,7 @@ STATick char acxmem_printable(char c) { } // OW TODO -#if 0 +#if 0 // or mem.c:3695:42: error: 'acx_device_t' has no member named 'wstats' STATick void update_link_quality_led(acx_device_t *adev) { int qual; @@ -3713,7 +3714,7 @@ STATick void update_link_quality_led(acx_device_t *adev) */ // OW TODO Not used in pci either !? -#if 0 +#if 0 // or mem.c:3717:5: error: conflicting types for 'acx111pci_ioctl_info' int acx111pci_ioctl_info(struct ieee80211_hw *hw, struct iw_request_info *info, struct iw_param *vwrq, char *extra) -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:41
|
acxmem_init_acx_txbuf(): only used in mem.c, make static, drop STATick, #if0 in merge.c acxmem_issue_cmd_timeo_debug(): none in pci.c, so #if0 in merge.c, keep static in mem.c (unchanged) acxmem_init_acx_txbuf2(): used in common.c too. drop STATick, #if0 in merge.c acxmem_complete_hw_reset(): no pci version, #if0 in merge, keep static in mem.c (unchanged) Tested-by: jimc - modprobes, ifups, iwconfigs Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 14 +++++++------- merge.c | 8 ++++++-- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/mem.c b/mem.c index be9acee..8164c72 100644 --- a/mem.c +++ b/mem.c @@ -187,8 +187,8 @@ void *acxmem_get_txbuf(acx_device_t *adev, tx_t *tx_opaque); STATick int acxmem_get_txbuf_space_needed(acx_device_t *adev, unsigned int len); STATick u32 acxmem_allocate_acx_txbuf_space(acx_device_t *adev, int count); STATick void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr); -STATick void acxmem_init_acx_txbuf(acx_device_t *adev); -void acxmem_init_acx_txbuf2(acx_device_t *adev); +static void acxmem_init_acx_txbuf(acx_device_t *adev); +//= static void acxmem_init_acx_txbuf2(acx_device_t *adev); STATick inline txdesc_t *acxmem_get_txdesc(acx_device_t *adev, int index); // static inline txdesc_t *acxmem_advance_txdesc(acx_device_t *adev, txdesc_t* txdesc, int inc); @@ -2689,8 +2689,8 @@ STATick void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { * block. The upper 13 bits are a control field, of which only 0x02000000 has any * meaning. The lower 19 bits are the address of the next block divided by 32. */ -STATick void acxmem_init_acx_txbuf(acx_device_t *adev) { - +static void acxmem_init_acx_txbuf(acx_device_t *adev) +{ /* * acx100_s_init_memory_pools set up txbuf_start and txbuf_numblocks for us. * All we need to do is reset the rest of the bookeeping. @@ -2710,9 +2710,9 @@ STATick void acxmem_init_acx_txbuf(acx_device_t *adev) { /* Re-initialize tx-buffer list */ -#if 0 // copied to merge -void acxmem_init_acx_txbuf2(acx_device_t *adev) { - +#if 1 // copied to merge, inappropriately +void acxmem_init_acx_txbuf2(acx_device_t *adev) +{ int i; u32 adr, next_adr; diff --git a/merge.c b/merge.c index a2297cb..4b962ce 100644 --- a/merge.c +++ b/merge.c @@ -1735,7 +1735,7 @@ end: * control field, of which only 0x02000000 has any meaning. The lower * 19 bits are the address of the next block divided by 32. */ - +#if 0 // none in pci static void acxmem_init_acx_txbuf(acx_device_t *adev) { /* @@ -1755,10 +1755,12 @@ static void acxmem_init_acx_txbuf(acx_device_t *adev) { * reset, so the ACX memory is in the state we want. */ } +#endif /* * Most of the acx specific pieces of hardware reset. */ +#if 0 // none in pci.c, doesnt belong here static int acxmem_complete_hw_reset(acx_device_t *adev) { acx111_ie_configoption_t co; @@ -1815,6 +1817,7 @@ static int acxmem_complete_hw_reset(acx_device_t *adev) return 0; } +#endif static void acxmem_irq_enable(acx_device_t *adev) { FN_ENTER; @@ -2542,6 +2545,7 @@ static void acxmem_reclaim_acx_txbuf_space(acx_device_t *adev, u32 blockptr) { /* Re-initialize tx-buffer list */ +#if 0 // none in pci, doesnt belong here void acxmem_init_acx_txbuf2(acx_device_t *adev) { int i; @@ -2566,7 +2570,7 @@ void acxmem_init_acx_txbuf2(acx_device_t *adev) { adev->acx_txbuf_blocks_free = adev->acx_txbuf_numblocks; } - +#endif // static inline txdesc_t* -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:43
|
Signed-off-by: Jim Cromie <jim...@gm...> --- mem.c | 19 ++++++++++++------- merge.c | 18 ++++++++++-------- pci.c | 12 +++++------- 3 files changed, 27 insertions(+), 22 deletions(-) diff --git a/mem.c b/mem.c index 52b1d11..be9acee 100644 --- a/mem.c +++ b/mem.c @@ -1434,9 +1434,11 @@ acx_show_card_eeprom_id(acx_device_t *adev) * */ #if 0 // copied to merge -int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, - void *buffer, unsigned buflen, unsigned cmd_timeout, const char* cmdstr) { - +int +acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, + void *buffer, unsigned buflen, + unsigned cmd_timeout, const char *cmdstr) +{ unsigned long start = jiffies; const char *devname; unsigned counter; @@ -1455,8 +1457,8 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, devname = "acx"; log(L_CTL, "%s: cmd:%s, cmd:0x%04X, buflen:%u, timeout:%ums, type:0x%04X)\n", - __func__, cmdstr, cmd, buflen, cmd_timeout, - buffer ? le16_to_cpu(((acx_ie_generic_t *)buffer)->type) : -1); + __func__, cmdstr, cmd, buflen, cmd_timeout, + buffer ? le16_to_cpu(((acx_ie_generic_t *)buffer)->type) : -1); if (!(adev->dev_state_mask & ACX_STATE_FW_LOADED)) { pr_acxmem("%s: %s: firmware is not loaded yet, cannot execute commands!\n", @@ -1714,7 +1716,8 @@ STATick inline void acxmem_init_mboxes(acx_device_t *adev) { * as well as uploads and verifies the firmware to the card */ #if 0 // copied to merge -int acxmem_reset_dev(acx_device_t *adev) { +int acxmem_reset_dev(acx_device_t *adev) +{ const char* msg = ""; int result = NOT_OK; u16 hardware_info; @@ -2058,7 +2061,9 @@ STATick void acxmem_i_set_multicast_list(struct net_device *ndev) { * ================================================== */ #if 0 // copied to merge -int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) { +int acxmem_proc_diag_output(struct seq_file *file, + acx_device_t *adev) +{ const char *rtl, *thd, *ttl; txdesc_t *txdesc; u8 Ctl_8; diff --git a/merge.c b/merge.c index bb1ca83..a2297cb 100644 --- a/merge.c +++ b/merge.c @@ -822,7 +822,8 @@ fail: */ // static int acxmem_write_fw(acx_device_t *adev, - const firmware_image_t *fw_image, u32 offset) { + const firmware_image_t *fw_image, u32 offset) +{ int len, size; u32 sum, v32; // mem.c ars @@ -1256,11 +1257,11 @@ static inline void acxmem_init_mboxes(acx_device_t *adev) * Also ifup/down works more reliable on the mem device. * */ -int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, - void *buffer, unsigned buflen, - unsigned cmd_timeout, const char* cmdstr) +int +acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, + void *buffer, unsigned buflen, + unsigned cmd_timeout, const char *cmdstr) { - unsigned long start = jiffies; const char *devname; unsigned counter; @@ -1280,8 +1281,8 @@ int acxmem_issue_cmd_timeo_debug(acx_device_t *adev, unsigned cmd, devname = "acx"; log(L_CTL, "%s: cmd:%s, cmd:0x%04X, buflen:%u, timeout:%ums, type:0x%04X)\n", - __func__, cmdstr, cmd, buflen, cmd_timeout, - buffer ? le16_to_cpu(((acx_ie_generic_t *)buffer)->type) : -1); + __func__, cmdstr, cmd, buflen, cmd_timeout, + buffer ? le16_to_cpu(((acx_ie_generic_t *)buffer)->type) : -1); if (!(adev->dev_state_mask & ACX_STATE_FW_LOADED)) { pr_acx("%s: %s: firmware is not loaded yet, cannot execute commands!\n", @@ -1910,7 +1911,8 @@ static void acxmem_i_set_multicast_list(struct net_device *ndev) * BOM Proc, Debug * ================================================== */ -int acxmem_proc_diag_output(struct seq_file *file, acx_device_t *adev) +int acxmem_proc_diag_output(struct seq_file *file, + acx_device_t *adev) { const char *rtl, *thd, *ttl; txdesc_t *txdesc; diff --git a/pci.c b/pci.c index 4fcf9ba..db74c25 100644 --- a/pci.c +++ b/pci.c @@ -982,11 +982,9 @@ static void acx_show_card_eeprom_id(acx_device_t * adev) * 2) go to waitqueue based approach: wait, not poll! */ int -acxpci_issue_cmd_timeo_debug(acx_device_t * adev, - unsigned cmd, - void *buffer, - unsigned buflen, - unsigned cmd_timeout, const char *cmdstr) +acxpci_issue_cmd_timeo_debug(acx_device_t * adev, unsigned cmd, + void *buffer, unsigned buflen, + unsigned cmd_timeout, const char *cmdstr) { unsigned long start = jiffies; const char *devname; @@ -1002,8 +1000,8 @@ acxpci_issue_cmd_timeo_debug(acx_device_t * adev, devname = "acx"; log(L_CTL, "%s: cmd=%s, buflen=%u, timeout=%ums, type=0x%04X\n", - __func__, cmdstr, buflen, cmd_timeout, - buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) : -1); + __func__, cmdstr, buflen, cmd_timeout, + buffer ? le16_to_cpu(((acx_ie_generic_t *) buffer)->type) : -1); if (!(adev->dev_state_mask & ACX_STATE_FW_LOADED)) { pr_acx("%s: %s: firmware is not loaded yet, " -- 1.7.8.1 |
From: Jim C. <jim...@gm...> - 2012-04-23 08:26:47
|
Signed-off-by: Jim Cromie <jim...@gm...> --- TODO | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----- mem.c | 2 +- 2 files changed, 59 insertions(+), 6 deletions(-) diff --git a/TODO b/TODO index e90c6c2..84008ff 100644 --- a/TODO +++ b/TODO @@ -39,13 +39,60 @@ static void acxpci_log_txbuffer(const acx_device_t * adev) BOM Data Access INLINE_IO - mem has additional blocks. -delete_dma_regions() -acx(pci|mem)_upload_radio() +acx(pci|mem)_delete_dma_regions(): + whitespace, comment diffs + called 2x from #if0d merge.c:acxmem_probe() + +acx(pci|mem)_upload_radio(): DONE + filename diffs only, #if0d in pci|mem, done + called from common.c:acx_init_mac + calls acx(pci|mem)_write_fw - TODO + +acx(pci|mem)_read_phy_reg(): DONE + Note: define acxdev_lock() mem ? acxmem_lock " void 0 + Later: look at acxusb_read_phy_reg() + +mem.c #if0s: + +acxmem_tx_data(): + extra locking + acx(pci|mem)_get_txhostdesc() usage + slave_mem - need wrappers + +acxmem_tx_clean_txdesc(): + extra tmpdesc stuff + acx(pci|mem)_get_txdesc - look at it. + slave-mem + +acxmem_tx_clean_txdesc_emergency(): + acx(pci|mem)_get_txdesc - look at it. + slave-mem + maybe make a helper for above. + grody diffs + +OTHERS + +acxmem_issue_cmd_timeo_debug(): + has locking adds + counter goofiness, cruft + copy-to-slave + acxpci_write_cmd_type_status(adev, 0, 0); + VS acxmem_write_cmd_type_status(adev, ACX1xx_CMD_RESET, 0); + + +acxmem_reset_dev(): + +acxpci_init_mboxes(): + +acxmem_proc_diag_output():. latter 2 are #if0d, maybe wrongly + grody diffs + +acx(pci|mem)_write_phy_reg() + copied from mem.c, but needs work before use + acx(pci|mem)_read_eeprom_byte() acx(pci|mem)_write_eeprom_byte() (UNUSED) -acx(pci|mem)_read_phy_reg() - define acxdev_lock() mem ? acxmem_lock " void 0 -acx(pci|mem)_write_phy_reg() + acx(pci|mem)_s_write_fw() acx(pci|mem)_s_vaidate_fw() acx_show_card_eeprom_id() @@ -66,6 +113,12 @@ acx(pci|mem)_op_start() acx111(pci|mem)_ioctl_info() (extra printks in mem --------- +refactor struct acx_device + +move (tx|rx)(host)?desc to sub-structure. +this will allow simplification of code doing buffer allocs and frees. + +--------- move or copy (tbd) all proc files to debugfs --------- diff --git a/mem.c b/mem.c index 8164c72..9cd54ec 100644 --- a/mem.c +++ b/mem.c @@ -2767,7 +2767,7 @@ acxmem_get_txhostdesc(acx_device_t *adev, txdesc_t* txdesc) { * pre-allocated tx descrs, properly setting up transfer data and * CTL_xxx flags according to fragment number. */ -#if 0 // copied to merge +#if 0 // copied to merge, pci version unmerged. void acxmem_tx_data(acx_device_t *adev, tx_t *tx_opaque, int len, struct ieee80211_tx_info *info, struct sk_buff *skb) { /* -- 1.7.8.1 |