1 /**** (legal) claimer in README
2 ** Copyright (C) 2003 ACX100 Open Source Project
4 #define ACX_MAC80211_PCI 1
6 #include <linux/version.h>
8 /* Linux 2.6.18+ uses <linux/utsrelease.h> */
10 #include <linux/utsrelease.h>
13 #include <linux/compiler.h> /* required for Lx 2.6.8 ?? */
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/sched.h>
18 #include <linux/types.h>
19 #include <linux/skbuff.h>
20 #include <linux/slab.h>
21 #include <linux/if_arp.h>
22 #include <linux/rtnetlink.h>
23 #include <linux/wireless.h>
24 #include <net/iw_handler.h>
25 #include <linux/netdevice.h>
26 #include <linux/ioport.h>
27 #include <linux/pci.h>
29 #include <linux/vmalloc.h>
30 #include <linux/ethtool.h>
31 #include <linux/dma-mapping.h>
32 #include <linux/workqueue.h>
34 #include <linux/vlynq.h>
39 /***********************************************************************
42 #define PCI_TYPE (PCI_USES_MEM | PCI_ADDR0 | PCI_NO_ACPI_WAKE)
43 #define PCI_ACX100_REGION1 0x01
44 #define PCI_ACX100_REGION1_SIZE 0x1000 /* Memory size - 4K bytes */
45 #define PCI_ACX100_REGION2 0x02
46 #define PCI_ACX100_REGION2_SIZE 0x10000 /* Memory size - 64K bytes */
48 #define PCI_ACX111_REGION1 0x00
49 #define PCI_ACX111_REGION1_SIZE 0x2000 /* Memory size - 8K bytes */
50 #define PCI_ACX111_REGION2 0x01
51 #define PCI_ACX111_REGION2_SIZE 0x20000 /* Memory size - 128K bytes */
53 /* Texas Instruments Vendor ID */
54 #define PCI_VENDOR_ID_TI 0x104c
56 /* ACX100 22Mb/s WLAN controller */
57 #define PCI_DEVICE_ID_TI_TNETW1100A 0x8400
58 #define PCI_DEVICE_ID_TI_TNETW1100B 0x8401
60 /* ACX111 54Mb/s WLAN controller */
61 #define PCI_DEVICE_ID_TI_TNETW1130 0x9066
63 /* PCI Class & Sub-Class code, Network-'Other controller' */
64 #define PCI_CLASS_NETWORK_OTHERS 0x0280
66 #define CARD_EEPROM_ID_SIZE 6
69 /* From include/linux/pci.h */
76 #define PCI_POWER_ERROR -1
78 #endif /* CONFIG_PCI */
80 /***********************************************************************
83 static irqreturn_t
acxpci_i_interrupt(int irq
, void *dev_id
);
85 static void disable_acx_irq(acx_device_t
* adev
);
87 static int acxpci_e_open(struct ieee80211_hw
*hw
);
88 static void acxpci_e_close(struct ieee80211_hw
*hw
);
89 static void acxpci_s_up(struct ieee80211_hw
*hw
);
90 static void acxpci_s_down(struct ieee80211_hw
*hw
);
92 void acxpci_put_devname(acx_device_t
*adev
, struct ethtool_drvinfo
*info
)
94 strncpy(info
->bus_info
,pci_name(adev
->pdev
), ETHTOOL_BUSINFO_LEN
);
97 /***********************************************************************
103 /* OS I/O routines *always* be endianness-clean but having them doesn't hurt */
104 #define acx_readl(v) le32_to_cpu(readl((v)))
105 #define acx_readw(v) le16_to_cpu(readw((v)))
106 #define acx_writew(v,r) writew(le16_to_cpu((v)), r)
107 #define acx_writel(v,r) writel(le32_to_cpu((v)), r)
110 /* #define INLINE_IO static */
111 #define INLINE_IO static inline
113 INLINE_IO u32
read_reg32(acx_device_t
* adev
, unsigned int offset
)
115 #if ACX_IO_WIDTH == 32
116 return acx_readl((u8
*) adev
->iobase
+ adev
->io
[offset
]);
118 return acx_readw((u8
*) adev
->iobase
+ adev
->io
[offset
])
119 + (acx_readw((u8
*) adev
->iobase
+ adev
->io
[offset
] + 2) << 16);
123 INLINE_IO u16
read_reg16(acx_device_t
* adev
, unsigned int offset
)
125 return acx_readw((u8
*) adev
->iobase
+ adev
->io
[offset
]);
128 INLINE_IO u8
read_reg8(acx_device_t
* adev
, unsigned int offset
)
130 return readb((u8
*) adev
->iobase
+ adev
->io
[offset
]);
133 INLINE_IO
void write_reg32(acx_device_t
* adev
, unsigned int offset
, u32 val
)
135 #if ACX_IO_WIDTH == 32
136 acx_writel(val
, (u8
*) adev
->iobase
+ adev
->io
[offset
]);
138 acx_writew(val
& 0xffff, (u8
*) adev
->iobase
+ adev
->io
[offset
]);
139 acx_writew(val
>> 16, (u8
*) adev
->iobase
+ adev
->io
[offset
] + 2);
143 INLINE_IO
void write_reg16(acx_device_t
* adev
, unsigned int offset
, u16 val
)
145 acx_writew(val
, (u8
*) adev
->iobase
+ adev
->io
[offset
]);
148 INLINE_IO
void write_reg8(acx_device_t
* adev
, unsigned int offset
, u8 val
)
150 writeb(val
, (u8
*) adev
->iobase
+ adev
->io
[offset
]);
153 /* Handle PCI posting properly:
154 * Make sure that writes reach the adapter in case they require to be executed
155 * *before* the next write, by reading a random (and safely accessible) register.
156 * This call has to be made if there is no read following (which would flush the data
157 * to the adapter), yet the written data has to reach the adapter immediately. */
158 INLINE_IO
void write_flush(acx_device_t
* adev
)
160 /* readb(adev->iobase + adev->io[IO_ACX_INFO_MAILBOX_OFFS]); */
161 /* faster version (accesses the first register, IO_ACX_SOFT_RESET,
162 * which should also be safe): */
166 INLINE_IO
int adev_present(acx_device_t
* adev
)
168 /* fast version (accesses the first register, IO_ACX_SOFT_RESET,
169 * which should be safe): */
170 return acx_readl(adev
->iobase
) != 0xffffffff;
174 /***********************************************************************
176 static inline txdesc_t
*get_txdesc(acx_device_t
* adev
, int index
)
178 return (txdesc_t
*) (((u8
*) adev
->txdesc_start
) +
179 index
* adev
->txdesc_size
);
182 static inline txdesc_t
*advance_txdesc(acx_device_t
* adev
, txdesc_t
* txdesc
,
185 return (txdesc_t
*) (((u8
*) txdesc
) + inc
* adev
->txdesc_size
);
188 static txhostdesc_t
*get_txhostdesc(acx_device_t
* adev
, txdesc_t
* txdesc
)
190 int index
= (u8
*) txdesc
- (u8
*) adev
->txdesc_start
;
194 if (unlikely(ACX_DEBUG
&& (index
% adev
->txdesc_size
))) {
195 printk("bad txdesc ptr %p\n", txdesc
);
198 index
/= adev
->txdesc_size
;
199 if (unlikely(ACX_DEBUG
&& (index
>= TX_CNT
))) {
200 printk("bad txdesc ptr %p\n", txdesc
);
206 return &adev
->txhostdesc_start
[index
* 2];
213 /***********************************************************************
214 ** EEPROM and PHY read/write helpers
216 /***********************************************************************
217 ** acxpci_read_eeprom_byte
219 ** Function called to read an octet in the EEPROM.
221 ** This function is used by acxpci_e_probe to check if the
222 ** connected card is a legal one or not.
225 ** adev ptr to acx_device structure
226 ** addr address to read in the EEPROM
227 ** charbuf ptr to a char. This is where the read octet
231 int acxpci_read_eeprom_byte(acx_device_t
* adev
, u32 addr
, u8
* charbuf
)
238 write_reg32(adev
, IO_ACX_EEPROM_CFG
, 0);
239 write_reg32(adev
, IO_ACX_EEPROM_ADDR
, addr
);
241 write_reg32(adev
, IO_ACX_EEPROM_CTL
, 2);
244 while (read_reg16(adev
, IO_ACX_EEPROM_CTL
)) {
245 /* scheduling away instead of CPU burning loop
246 * doesn't seem to work here at all:
247 * awful delay, sometimes also failure.
248 * Doesn't matter anyway (only small delay). */
249 if (unlikely(!--count
)) {
250 printk("%s: timeout waiting for EEPROM read\n",
251 wiphy_name(adev
->ieee
->wiphy
));
258 *charbuf
= read_reg8(adev
, IO_ACX_EEPROM_DATA
);
259 log(L_DEBUG
, "EEPROM at 0x%04X = 0x%02X\n", addr
, *charbuf
);
268 /***********************************************************************
269 ** We don't lock hw accesses here since we never r/w eeprom in IRQ
270 ** Note: this function sleeps only because of GFP_KERNEL alloc
274 acxpci_s_write_eeprom(acx_device_t
* adev
, u32 addr
, u32 len
,
277 u8
*data_verify
= NULL
;
283 printk("acx: WARNING! I would write to EEPROM now. "
284 "Since I really DON'T want to unless you know "
285 "what you're doing (THIS CODE WILL PROBABLY "
286 "NOT WORK YET!), I will abort that now. And "
287 "definitely make sure to make a "
288 "/proc/driver/acx_wlan0_eeprom backup copy first!!! "
289 "(the EEPROM content includes the PCI config header!! "
290 "If you kill important stuff, then you WILL "
291 "get in trouble and people DID get in trouble already)\n");
296 data_verify
= kmalloc(len
, GFP_KERNEL
);
301 /* first we need to enable the OE (EEPROM Output Enable) GPIO line
302 * to be able to write to the EEPROM.
303 * NOTE: an EEPROM writing success has been reported,
304 * but you probably have to modify GPIO_OUT, too,
305 * and you probably need to activate a different GPIO
307 gpio_orig
= read_reg16(adev
, IO_ACX_GPIO_OE
);
308 write_reg16(adev
, IO_ACX_GPIO_OE
, gpio_orig
& ~1);
311 /* ok, now start writing the data out */
312 for (i
= 0; i
< len
; i
++) {
313 write_reg32(adev
, IO_ACX_EEPROM_CFG
, 0);
314 write_reg32(adev
, IO_ACX_EEPROM_ADDR
, addr
+ i
);
315 write_reg32(adev
, IO_ACX_EEPROM_DATA
, *(charbuf
+ i
));
317 write_reg32(adev
, IO_ACX_EEPROM_CTL
, 1);
320 while (read_reg16(adev
, IO_ACX_EEPROM_CTL
)) {
321 if (unlikely(!--count
)) {
322 printk("WARNING, DANGER!!! "
323 "Timeout waiting for EEPROM write\n");
330 /* disable EEPROM writing */
331 write_reg16(adev
, IO_ACX_GPIO_OE
, gpio_orig
);
334 /* now start a verification run */
335 for (i
= 0; i
< len
; i
++) {
336 write_reg32(adev
, IO_ACX_EEPROM_CFG
, 0);
337 write_reg32(adev
, IO_ACX_EEPROM_ADDR
, addr
+ i
);
339 write_reg32(adev
, IO_ACX_EEPROM_CTL
, 2);
342 while (read_reg16(adev
, IO_ACX_EEPROM_CTL
)) {
343 if (unlikely(!--count
)) {
344 printk("timeout waiting for EEPROM read\n");
350 data_verify
[i
] = read_reg16(adev
, IO_ACX_EEPROM_DATA
);
353 if (0 == memcmp(charbuf
, data_verify
, len
))
354 result
= OK
; /* read data matches, success */
364 /***********************************************************************
365 ** acxpci_s_read_phy_reg
367 ** Messing with rx/tx disabling and enabling here
368 ** (write_reg32(adev, IO_ACX_ENABLE, 0b000000xx)) kills traffic
370 int acxpci_s_read_phy_reg(acx_device_t
* adev
, u32 reg
, u8
* charbuf
)
377 write_reg32(adev
, IO_ACX_PHY_ADDR
, reg
);
379 write_reg32(adev
, IO_ACX_PHY_CTL
, 2);
382 while (read_reg32(adev
, IO_ACX_PHY_CTL
)) {
383 /* scheduling away instead of CPU burning loop
384 * doesn't seem to work here at all:
385 * awful delay, sometimes also failure.
386 * Doesn't matter anyway (only small delay). */
387 if (unlikely(!--count
)) {
388 printk("%s: timeout waiting for phy read\n",
389 wiphy_name(adev
->ieee
->wiphy
));
396 log(L_DEBUG
, "count was %u\n", count
);
397 *charbuf
= read_reg8(adev
, IO_ACX_PHY_DATA
);
399 log(L_DEBUG
, "radio PHY at 0x%04X = 0x%02X\n", *charbuf
, reg
);
401 goto fail
; /* silence compiler warning */
408 /***********************************************************************
410 int acxpci_s_write_phy_reg(acx_device_t
* adev
, u32 reg
, u8 value
)
414 /* mprusko said that 32bit accesses result in distorted sensitivity
415 * on his card. Unconfirmed, looks like it's not true (most likely since we
416 * now properly flush writes). */
417 write_reg32(adev
, IO_ACX_PHY_DATA
, value
);
418 write_reg32(adev
, IO_ACX_PHY_ADDR
, reg
);
420 write_reg32(adev
, IO_ACX_PHY_CTL
, 1);
422 log(L_DEBUG
, "radio PHY write 0x%02X at 0x%04X\n", value
, reg
);
429 #define NO_AUTO_INCREMENT 1
431 /***********************************************************************
434 ** Write the firmware image into the card.
437 ** adev wlan device structure
438 ** fw_image firmware image.
441 ** 1 firmware image corrupted
444 ** Standard csum implementation + write to IO
447 acxpci_s_write_fw(acx_device_t
* adev
, const firmware_image_t
*fw_image
,
452 /* we skip the first four bytes which contain the control sum */
454 const u8
*p
= (u8
*) fw_image
+ 4;
458 /* start the image checksum by adding the image size value */
459 sum
= p
[0] + p
[1] + p
[2] + p
[3];
462 write_reg32(adev
, IO_ACX_SLV_END_CTL
, 0);
464 #if NO_AUTO_INCREMENT
465 write_reg32(adev
, IO_ACX_SLV_MEM_CTL
, 0); /* use basic mode */
467 write_reg32(adev
, IO_ACX_SLV_MEM_CTL
, 1); /* use autoincrement mode */
468 write_reg32(adev
, IO_ACX_SLV_MEM_ADDR
, offset
); /* configure start address */
473 size
= le32_to_cpu(fw_image
->size
) & (~3);
475 while (likely(len
< size
)) {
476 v32
= be32_to_cpu(*(u32
*) p
);
477 sum
+= p
[0] + p
[1] + p
[2] + p
[3];
481 #if NO_AUTO_INCREMENT
482 write_reg32(adev
, IO_ACX_SLV_MEM_ADDR
, offset
+ len
- 4);
485 write_reg32(adev
, IO_ACX_SLV_MEM_DATA
, v32
);
488 log(L_DEBUG
, "firmware written, size:%d sum1:%x sum2:%x\n",
489 size
, sum
, le32_to_cpu(fw_image
->chksum
));
491 /* compare our checksum with the stored image checksum */
492 FN_EXIT1(sum
!= le32_to_cpu(fw_image
->chksum
));
493 return (sum
!= le32_to_cpu(fw_image
->chksum
));
497 /***********************************************************************
498 ** acxpci_s_validate_fw
500 ** Compare the firmware image given with
501 ** the firmware image written into the card.
504 ** adev wlan device structure
505 ** fw_image firmware image.
508 ** NOT_OK firmware image corrupted or not correctly written
511 ** Origin: Standard csum + Read IO
514 acxpci_s_validate_fw(acx_device_t
* adev
, const firmware_image_t
*fw_image
,
520 /* we skip the first four bytes which contain the control sum */
521 const u8
*p
= (u8
*) fw_image
+ 4;
525 /* start the image checksum by adding the image size value */
526 sum
= p
[0] + p
[1] + p
[2] + p
[3];
529 write_reg32(adev
, IO_ACX_SLV_END_CTL
, 0);
531 #if NO_AUTO_INCREMENT
532 write_reg32(adev
, IO_ACX_SLV_MEM_CTL
, 0); /* use basic mode */
534 write_reg32(adev
, IO_ACX_SLV_MEM_CTL
, 1); /* use autoincrement mode */
535 write_reg32(adev
, IO_ACX_SLV_MEM_ADDR
, offset
); /* configure start address */
539 size
= le32_to_cpu(fw_image
->size
) & (~3);
541 while (likely(len
< size
)) {
542 v32
= be32_to_cpu(*(u32
*) p
);
546 #if NO_AUTO_INCREMENT
547 write_reg32(adev
, IO_ACX_SLV_MEM_ADDR
, offset
+ len
- 4);
549 w32
= read_reg32(adev
, IO_ACX_SLV_MEM_DATA
);
551 if (unlikely(w32
!= v32
)) {
552 printk("acx: FATAL: firmware upload: "
553 "data parts at offset %d don't match (0x%08X vs. 0x%08X)! "
554 "I/O timing issues or defective memory, with DWL-xx0+? "
555 "ACX_IO_WIDTH=16 may help. Please report\n",
562 (u8
) w32
+ (u8
) (w32
>> 8) + (u8
) (w32
>> 16) +
566 /* sum control verification */
567 if (result
!= NOT_OK
) {
568 if (sum
!= le32_to_cpu(fw_image
->chksum
)) {
569 printk("acx: FATAL: firmware upload: "
570 "checksums don't match!\n");
580 /***********************************************************************
581 ** acxpci_s_upload_fw
583 ** Called from acx_reset_dev
585 ** Origin: Derived from FW dissection
587 static int acxpci_s_upload_fw(acx_device_t
* adev
)
589 firmware_image_t
*fw_image
= NULL
;
593 char filename
[sizeof("tiacx1NNcNN")];
597 /* print exact chipset and radio ID to make sure people
598 * really get a clue on which files exactly they need to provide.
599 * Firmware loading is a frequent end-user PITA with these chipsets.
601 printk( "acx: need firmware for acx1%02d chipset with radio ID %02X\n"
602 "Please provide via firmware hotplug:\n"
603 "either combined firmware (single file named 'tiacx1%02dc%02X')\n"
604 "or two files (base firmware file 'tiacx1%02d' "
605 "+ radio fw 'tiacx1%02dr%02X')\n",
606 IS_ACX111(adev
)*11, adev
->radio_type
,
607 IS_ACX111(adev
)*11, adev
->radio_type
,
609 IS_ACX111(adev
)*11, adev
->radio_type
612 /* print exact chipset and radio ID to make sure people really get a clue on which files exactly they are supposed to provide,
613 * since firmware loading is the biggest enduser PITA with these chipsets.
614 * Not printing radio ID in 0xHEX in order to not confuse them into wrong file naming */
615 printk( "acx: need to load firmware for acx1%02d chipset with radio ID %02x, please provide via firmware hotplug:\n"
616 "acx: either one file only (<c>ombined firmware image file, radio-specific) or two files (radio-less base image file *plus* separate <r>adio-specific extension file)\n",
617 IS_ACX111(adev
)*11, adev
->radio_type
);
619 /* Try combined, then main image */
620 adev
->need_radio_fw
= 0;
621 snprintf(filename
, sizeof(filename
), "tiacx1%02dc%02X",
622 IS_ACX111(adev
) * 11, adev
->radio_type
);
624 fw_image
= acx_s_read_fw(adev
->bus_dev
, filename
, &file_size
);
626 adev
->need_radio_fw
= 1;
627 filename
[sizeof("tiacx1NN") - 1] = '\0';
629 acx_s_read_fw(adev
->bus_dev
, filename
, &file_size
);
636 for (try = 1; try <= 5; try++) {
637 res
= acxpci_s_write_fw(adev
, fw_image
, 0);
638 log(L_DEBUG
| L_INIT
, "acx_write_fw (main/combined): %d\n", res
);
640 res
= acxpci_s_validate_fw(adev
, fw_image
, 0);
641 log(L_DEBUG
| L_INIT
, "acx_validate_fw "
642 "(main/combined): %d\n", res
);
646 SET_BIT(adev
->dev_state_mask
, ACX_STATE_FW_LOADED
);
649 printk("acx: firmware upload attempt #%d FAILED, "
650 "retrying...\n", try);
651 acx_s_mwait(1000); /* better wait for a while... */
661 /***********************************************************************
662 ** acxpci_s_upload_radio
664 ** Uploads the appropriate radio module firmware into the card.
666 ** Origin: Standard Read/Write to IO
668 int acxpci_s_upload_radio(acx_device_t
* adev
)
671 firmware_image_t
*radio_image
;
672 acx_cmd_radioinit_t radioinit
;
677 char filename
[sizeof("tiacx1NNrNN")];
679 if (!adev
->need_radio_fw
)
684 acx_s_interrogate(adev
, &mm
, ACX1xx_IE_MEMORY_MAP
);
685 offset
= le32_to_cpu(mm
.CodeEnd
);
687 snprintf(filename
, sizeof(filename
), "tiacx1%02dr%02X",
688 IS_ACX111(adev
) * 11, adev
->radio_type
);
689 radio_image
= acx_s_read_fw(adev
->bus_dev
, filename
, &size
);
691 printk("acx: can't load radio module '%s'\n", filename
);
695 acx_s_issue_cmd(adev
, ACX1xx_CMD_SLEEP
, NULL
, 0);
697 for (try = 1; try <= 5; try++) {
698 res
= acxpci_s_write_fw(adev
, radio_image
, offset
);
699 log(L_DEBUG
| L_INIT
, "acx_write_fw (radio): %d\n", res
);
701 res
= acxpci_s_validate_fw(adev
, radio_image
, offset
);
702 log(L_DEBUG
| L_INIT
, "acx_validate_fw (radio): %d\n",
708 printk("acx: radio firmware upload attempt #%d FAILED, "
709 "retrying...\n", try);
710 acx_s_mwait(1000); /* better wait for a while... */
713 acx_s_issue_cmd(adev
, ACX1xx_CMD_WAKE
, NULL
, 0);
714 radioinit
.offset
= cpu_to_le32(offset
);
715 /* no endian conversion needed, remains in card CPU area: */
716 radioinit
.len
= radio_image
->size
;
723 /* will take a moment so let's have a big timeout */
724 acx_s_issue_cmd_timeo(adev
, ACX1xx_CMD_RADIOINIT
,
725 &radioinit
, sizeof(radioinit
),
726 CMD_TIMEOUT_MS(1000));
728 res
= acx_s_interrogate(adev
, &mm
, ACX1xx_IE_MEMORY_MAP
);
735 /***********************************************************************
736 ** acxpci_l_reset_mac
739 ** Call context: reset_dev
741 ** Origin: Standard Read/Write to IO
743 static void acxpci_l_reset_mac(acx_device_t
* adev
)
750 temp
= read_reg16(adev
, IO_ACX_ECPU_CTRL
) | 0x1;
751 write_reg16(adev
, IO_ACX_ECPU_CTRL
, temp
);
753 /* now do soft reset of eCPU, set bit */
754 temp
= read_reg16(adev
, IO_ACX_SOFT_RESET
) | 0x1;
755 log(L_DEBUG
, "enable soft reset\n");
756 write_reg16(adev
, IO_ACX_SOFT_RESET
, temp
);
759 /* now clear bit again: deassert eCPU reset */
760 log(L_DEBUG
, "disable soft reset and go to init mode");
761 write_reg16(adev
, IO_ACX_SOFT_RESET
, temp
& ~0x1);
763 /* now start a burst read from initial EEPROM */
764 temp
= read_reg16(adev
, IO_ACX_EE_START
) | 0x1;
765 write_reg16(adev
, IO_ACX_EE_START
, temp
);
772 /***********************************************************************
773 ** acxpci_s_verify_init
775 static int acxpci_s_verify_init(acx_device_t
* adev
)
778 unsigned long timeout
;
782 timeout
= jiffies
+ 2 * HZ
;
784 u16 irqstat
= read_reg16(adev
, IO_ACX_IRQ_STATUS_NON_DES
);
785 if (irqstat
& HOST_INT_FCS_THRESHOLD
) {
787 write_reg16(adev
, IO_ACX_IRQ_ACK
,
788 HOST_INT_FCS_THRESHOLD
);
791 if (time_after(jiffies
, timeout
))
793 /* Init may take up to ~0.5 sec total */
802 /***********************************************************************
803 ** A few low-level helpers
805 ** Note: these functions are not protected by lock
806 ** and thus are never allowed to be called from IRQ.
807 ** Also they must not race with fw upload which uses same hw regs
810 /***********************************************************************
811 ** acxpci_write_cmd_type_status
813 ** Origin: Common linux implementation
817 acxpci_write_cmd_type_status(acx_device_t
* adev
, u16 type
, u16 status
)
820 acx_writel(type
| (status
<< 16), adev
->cmd_area
);
826 /***********************************************************************
827 ** acxpci_read_cmd_type_status
829 ** Origin: Common linux implementation
831 static u32
acxpci_read_cmd_type_status(acx_device_t
* adev
)
833 u32 cmd_type
, cmd_status
;
837 cmd_type
= acx_readl(adev
->cmd_area
);
838 cmd_status
= (cmd_type
>> 16);
839 cmd_type
= (u16
) cmd_type
;
841 log(L_CTL
, "cmd_type:%04X cmd_status:%04X [%s]\n",
842 cmd_type
, cmd_status
, acx_cmd_status_str(cmd_status
));
844 FN_EXIT1(cmd_status
);
849 /***********************************************************************
850 ** acxpci_s_reset_dev
853 ** netdevice that contains the adev variable
858 ** device is hard reset
862 ** This resets the device using low level hardware calls
863 ** as well as uploads and verifies the firmware to the card
866 static inline void init_mboxes(acx_device_t
* adev
)
868 u32 cmd_offs
, info_offs
;
872 cmd_offs
= read_reg32(adev
, IO_ACX_CMD_MAILBOX_OFFS
);
873 info_offs
= read_reg32(adev
, IO_ACX_INFO_MAILBOX_OFFS
);
874 adev
->cmd_area
= (u8
*) adev
->iobase2
+ cmd_offs
;
875 adev
->info_area
= (u8
*) adev
->iobase2
+ info_offs
;
876 log(L_DEBUG
, "iobase2=%p\n"
877 "cmd_mbox_offset=%X cmd_area=%p\n"
878 "info_mbox_offset=%X info_area=%p\n",
880 cmd_offs
, adev
->cmd_area
, info_offs
, adev
->info_area
);
885 static inline void read_eeprom_area(acx_device_t
* adev
)
893 for (offs
= 0x8c; offs
< 0xb9; offs
++)
894 acxpci_read_eeprom_byte(adev
, offs
, &tmp
);
901 int acxpci_s_reset_dev(acx_device_t
* adev
)
903 const char *msg
= "";
912 /* reset the device to make sure the eCPU is stopped
913 * to upload the firmware correctly */
915 acx_lock(adev
, flags
);
918 acxpci_l_reset_mac(adev
);
921 ecpu_ctrl
= read_reg16(adev
, IO_ACX_ECPU_CTRL
) & 1;
923 msg
= "eCPU is already running. ";
927 if (read_reg16(adev
, IO_ACX_SOR_CFG
) & 2) {
928 /* eCPU most likely means "embedded CPU" */
929 msg
= "eCPU did not start after boot from flash. ";
933 /* check sense on reset flags */
934 if (read_reg16(adev
, IO_ACX_SOR_CFG
) & 0x10) {
935 printk("%s: eCPU did not start after boot (SOR), "
936 "is this fatal?\n", wiphy_name(adev
->ieee
->wiphy
));
939 /* scan, if any, is stopped now, setting corresponding IRQ bit */
940 SET_BIT(adev
->irq_status
, HOST_INT_SCAN_COMPLETE
);
942 acx_unlock(adev
, flags
);
944 /* need to know radio type before fw load */
945 /* Need to wait for arrival of this information in a loop,
946 * most probably since eCPU runs some init code from EEPROM
947 * (started burst read in reset_mac()) which also
948 * sets the radio type ID */
952 hardware_info
= read_reg16(adev
, IO_ACX_EEPROM_INFORMATION
);
954 msg
= "eCPU didn't indicate radio type";
958 } while (!(hardware_info
& 0xff00)); /* radio type still zero? */
960 /* printk("DEBUG: count %d\n", count); */
961 adev
->form_factor
= hardware_info
& 0xff;
962 adev
->radio_type
= hardware_info
>> 8;
964 /* load the firmware */
965 if (OK
!= acxpci_s_upload_fw(adev
))
968 /* acx_s_mwait(10); this one really shouldn't be required */
970 /* now start eCPU by clearing bit */
971 write_reg16(adev
, IO_ACX_ECPU_CTRL
, ecpu_ctrl
& ~0x1);
972 log(L_DEBUG
, "booted eCPU up and waiting for completion...\n");
974 /* wait for eCPU bootup */
975 if (OK
!= acxpci_s_verify_init(adev
)) {
976 msg
= "timeout waiting for eCPU. ";
979 log(L_DEBUG
, "eCPU has woken up, card is ready to be configured\n");
982 acxpci_write_cmd_type_status(adev
, 0, 0);
984 /* test that EEPROM is readable */
985 read_eeprom_area(adev
);
990 /* Finish error message. Indicate which function failed */
992 acx_unlock(adev
, flags
);
994 printk("acx: %sreset_dev() FAILED\n", msg
);
1001 /***********************************************************************
1002 ** acxpci_s_issue_cmd_timeo
1004 ** Sends command to fw, extract result
1006 ** NB: we do _not_ take lock inside, so be sure to not touch anything
1007 ** which may interfere with IRQ handler operation
1009 ** TODO: busy wait is a bit silly, so:
1010 ** 1) stop doing many iters - go to sleep after first
1011 ** 2) go to waitqueue based approach: wait, not poll!
1014 #define FUNC "issue_cmd"
1018 acxpci_s_issue_cmd_timeo(acx_device_t
* adev
,
1020 void *buffer
, unsigned buflen
, unsigned cmd_timeout
)
1024 acxpci_s_issue_cmd_timeo_debug(acx_device_t
* adev
,
1028 unsigned cmd_timeout
, const char *cmdstr
)
1030 unsigned long start
= jiffies
;
1032 const char *devname
;
1036 unsigned long timeout
;
1040 devname
= wiphy_name(adev
->ieee
->wiphy
);
1041 if (!devname
|| !devname
[0] || devname
[4] == '%')
1044 log(L_CTL
, FUNC
"(cmd:%s,buflen:%u,timeout:%ums,type:0x%04X)\n",
1045 cmdstr
, buflen
, cmd_timeout
,
1046 buffer
? le16_to_cpu(((acx_ie_generic_t
*) buffer
)->type
) : -1);
1048 if (!(adev
->dev_state_mask
& ACX_STATE_FW_LOADED
)) {
1049 printk("%s: " FUNC
"(): firmware is not loaded yet, "
1050 "cannot execute commands!\n", devname
);
1054 if ((acx_debug
& L_DEBUG
) && (cmd
!= ACX1xx_CMD_INTERROGATE
)) {
1055 printk("input buffer (len=%u):\n", buflen
);
1056 acx_dump_bytes(buffer
, buflen
);
1059 /* wait for firmware to become idle for our command submission */
1061 counter
= (timeout
* 1000 / HZ
) - 1; /* in ms */
1064 cmd_status
= acxpci_read_cmd_type_status(adev
);
1065 /* Test for IDLE state */
1068 if (counter
% 8 == 0) {
1069 if (time_after(jiffies
, timeout
)) {
1073 /* we waited 8 iterations, no luck. Sleep 8 ms */
1076 } while (likely(--counter
));
1079 /* the card doesn't get idle, we're in trouble */
1080 printk("%s: " FUNC
"(): cmd_status is not IDLE: 0x%04X!=0\n",
1081 devname
, cmd_status
);
1083 } else if (counter
< 190) { /* if waited >10ms... */
1084 log(L_CTL
| L_DEBUG
, FUNC
"(): waited for IDLE %dms. "
1085 "Please report\n", 199 - counter
);
1088 /* now write the parameters of the command if needed */
1089 if (buffer
&& buflen
) {
1090 /* if it's an INTERROGATE command, just pass the length
1091 * of parameters to read, as data */
1093 if (cmd
== ACX1xx_CMD_INTERROGATE
)
1094 memset_io(adev
->cmd_area
+ 4, 0xAA, buflen
);
1096 /* adev->cmd_area points to PCI device's memory, not to RAM! */
1097 memcpy_toio(adev
->cmd_area
+ 4, buffer
,
1098 (cmd
== ACX1xx_CMD_INTERROGATE
) ? 4 : buflen
);
1100 /* now write the actual command type */
1101 acxpci_write_cmd_type_status(adev
, cmd
, 0);
1102 /* execute command */
1103 write_reg16(adev
, IO_ACX_INT_TRIG
, INT_TRIG_CMD
);
1106 /* wait for firmware to process command */
1108 /* Ensure nonzero and not too large timeout.
1109 ** Also converts e.g. 100->99, 200->199
1110 ** which is nice but not essential */
1111 cmd_timeout
= (cmd_timeout
- 1) | 1;
1112 if (unlikely(cmd_timeout
> 1199))
1114 /* clear CMD_COMPLETE bit. can be set only by IRQ handler: */
1115 CLEAR_BIT(adev
->irq_status
, HOST_INT_CMD_COMPLETE
);
1116 /* we schedule away sometimes (timeout can be large) */
1117 counter
= cmd_timeout
;
1118 timeout
= jiffies
+ HZ
;
1120 if (!adev
->irqs_active
) { /* IRQ disabled: poll */
1121 irqtype
= read_reg16(adev
, IO_ACX_IRQ_STATUS_NON_DES
);
1122 if (irqtype
& HOST_INT_CMD_COMPLETE
) {
1123 write_reg16(adev
, IO_ACX_IRQ_ACK
,
1124 HOST_INT_CMD_COMPLETE
);
1127 } else { /* Wait when IRQ will set the bit */
1128 irqtype
= adev
->irq_status
;
1129 if (irqtype
& HOST_INT_CMD_COMPLETE
)
1133 if (counter
% 8 == 0) {
1134 if (time_after(jiffies
, timeout
)) {
1138 /* we waited 8 iterations, no luck. Sleep 8 ms */
1141 } while (likely(--counter
));
1143 /* save state for debugging */
1144 cmd_status
= acxpci_read_cmd_type_status(adev
);
1146 /* put the card in IDLE state */
1147 acxpci_write_cmd_type_status(adev
, 0, 0);
1149 if ((cmd_timeout
- counter
) == 0) { /* timed out! */
1150 printk("%s: " FUNC
"(): timed out %s for CMD_COMPLETE. "
1151 "irq bits:0x%04X irq_status:0x%04X timeout:%dms "
1152 "cmd_status:%d (%s)\n",
1153 devname
, (adev
->irqs_active
) ? "waiting" : "polling",
1154 irqtype
, adev
->irq_status
, cmd_timeout
,
1155 cmd_status
, acx_cmd_status_str(cmd_status
));
1156 printk("hack: don't do: 'goto bad;'\ncounter: %d cmd_timeout: %d cmd_timeout-counter: %d\n",counter
, cmd_timeout
, cmd_timeout
- counter
);
1157 } else if (counter
== 0) { /* maybe timed out! */
1158 log(L_CTL
| L_DEBUG
, FUNC
"(): %s for CMD_COMPLETE %dms. "
1159 "count:%d. Please report\n",
1160 (adev
->irqs_active
) ? "waited" : "polled",
1161 cmd_timeout
- counter
, counter
);
1162 } else if ((cmd_timeout
- counter
) > 30) { /* if waited >30ms... */
1163 log(L_CTL
| L_DEBUG
, FUNC
"(): %s for CMD_COMPLETE %dms. "
1164 "count:%d. Please report\n",
1165 (adev
->irqs_active
) ? "waited" : "polled",
1166 cmd_timeout
- counter
, counter
);
1169 if (1 != cmd_status
) { /* it is not a 'Success' */
1170 printk("%s: " FUNC
"(): cmd_status is not SUCCESS: %d (%s). "
1171 "Took %dms of %d\n",
1172 devname
, cmd_status
, acx_cmd_status_str(cmd_status
),
1173 cmd_timeout
- counter
, cmd_timeout
);
1174 /* zero out result buffer
1175 * WARNING: this will trash stack in case of illegally large input
1177 if (buffer
&& buflen
)
1178 memset(buffer
, 0, buflen
);
1182 /* read in result parameters if needed */
1183 if (buffer
&& buflen
&& (cmd
== ACX1xx_CMD_INTERROGATE
)) {
1184 /* adev->cmd_area points to PCI device's memory, not to RAM! */
1185 memcpy_fromio(buffer
, adev
->cmd_area
+ 4, buflen
);
1186 if (acx_debug
& L_DEBUG
) {
1187 printk("output buffer (len=%u): ", buflen
);
1188 acx_dump_bytes(buffer
, buflen
);
1192 log(L_CTL
, FUNC
"(%s): took %ld jiffies to complete\n",
1193 cmdstr
, jiffies
- start
);
1198 /* Give enough info so that callers can avoid
1199 ** printing their own diagnostic messages */
1201 printk("%s: " FUNC
"(cmd:%s) FAILED\n", devname
, cmdstr
);
1203 printk("%s: " FUNC
"(cmd:0x%04X) FAILED\n", devname
, cmd
);
1211 /***********************************************************************
1213 #ifdef NONESSENTIAL_FEATURES
1214 typedef struct device_id
{
1215 unsigned char id
[6];
1220 static const device_id_t device_ids
[] = {
1222 {'G', 'l', 'o', 'b', 'a', 'l'},
1227 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
1229 "SpeedStream SS1021 or Gigafast WF721-AEX"},
1231 {0x80, 0x81, 0x82, 0x83, 0x84, 0x85},
1233 "DrayTek Vigor 520"},
1235 {'?', '?', '?', '?', '?', '?'},
1237 "Level One WPC-0200"},
1239 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
1244 static void acx_show_card_eeprom_id(acx_device_t
* adev
)
1246 unsigned char buffer
[CARD_EEPROM_ID_SIZE
];
1251 memset(&buffer
, 0, CARD_EEPROM_ID_SIZE
);
1252 /* use direct EEPROM access */
1253 for (i
= 0; i
< CARD_EEPROM_ID_SIZE
; i
++) {
1254 if (OK
!= acxpci_read_eeprom_byte(adev
,
1255 ACX100_EEPROM_ID_OFFSET
+ i
,
1257 printk("acx: reading EEPROM FAILED\n");
1262 for (i
= 0; i
< ARRAY_SIZE(device_ids
); i
++) {
1263 if (!memcmp(&buffer
, device_ids
[i
].id
, CARD_EEPROM_ID_SIZE
)) {
1264 if (device_ids
[i
].descr
) {
1265 printk("acx: EEPROM card ID string check "
1266 "found %s card ID: is this %s?\n",
1267 device_ids
[i
].descr
, device_ids
[i
].type
);
1272 if (i
== ARRAY_SIZE(device_ids
)) {
1273 printk("acx: EEPROM card ID string check found "
1274 "unknown card: expected 'Global', got '%.*s\'. "
1275 "Please report\n", CARD_EEPROM_ID_SIZE
, buffer
);
1279 #endif /* NONESSENTIAL_FEATURES */
1282 /***********************************************************************
1283 ** acxpci_free_desc_queues
1285 ** Releases the queues that have been allocated, the
1286 ** others have been initialised to NULL so this
1287 ** function can be used if only part of the queues were allocated.
1291 free_coherent(struct pci_dev
*hwdev
, size_t size
,
1292 void *vaddr
, dma_addr_t dma_handle
)
1294 dma_free_coherent(hwdev
== NULL
? NULL
: &hwdev
->dev
,
1295 size
, vaddr
, dma_handle
);
1299 void acxpci_free_desc_queues(acx_device_t
* adev
)
1301 unsigned long flags
;
1303 #define ACX_FREE_QUEUE(size, ptr, phyaddr) \
1305 free_coherent(NULL, size, ptr, phyaddr); \
1312 ACX_FREE_QUEUE(adev
->txhostdesc_area_size
, adev
->txhostdesc_start
,
1313 adev
->txhostdesc_startphy
);
1314 ACX_FREE_QUEUE(adev
->txbuf_area_size
, adev
->txbuf_start
,
1315 adev
->txbuf_startphy
);
1317 acx_lock(adev
, flags
);
1318 adev
->txdesc_start
= NULL
;
1319 acx_unlock(adev
, flags
);
1321 ACX_FREE_QUEUE(adev
->rxhostdesc_area_size
, adev
->rxhostdesc_start
,
1322 adev
->rxhostdesc_startphy
);
1323 ACX_FREE_QUEUE(adev
->rxbuf_area_size
, adev
->rxbuf_start
,
1324 adev
->rxbuf_startphy
);
1326 acx_lock(adev
, flags
);
1327 adev
->rxdesc_start
= NULL
;
1328 acx_unlock(adev
, flags
);
1334 /***********************************************************************
1335 ** acxpci_s_delete_dma_regions
1337 static void acxpci_s_delete_dma_regions(acx_device_t
* adev
)
1340 /* disable radio Tx/Rx. Shouldn't we use the firmware commands
1341 * here instead? Or are we that much down the road that it's no
1342 * longer possible here? */
1343 write_reg16(adev
, IO_ACX_ENABLE
, 0);
1347 /* NO locking for all parts of acxpci_free_desc_queues because:
1348 * while calling dma_free_coherent() interrupts need to be 'free'
1349 * but if you spinlock the whole function (acxpci_free_desc_queues)
1350 * you'll get an error */
1351 acxpci_free_desc_queues(adev
);
1357 /***********************************************************************
1360 ** Probe routine called when a PCI device w/ matching ID is found.
1361 ** Here's the sequence:
1362 ** - Allocate the PCI resources.
1363 ** - Read the PCMCIA attribute memory to make sure we have a WLAN card
1365 ** - Initialize the dev and wlan data
1366 ** - Initialize the MAC
1368 ** pdev - ptr to pci device structure containing info about pci configuration
1369 ** id - ptr to the device id entry that matched this device
1371 static const u16 IO_ACX100
[] = {
1372 0x0000, /* IO_ACX_SOFT_RESET */
1374 0x0014, /* IO_ACX_SLV_MEM_ADDR */
1375 0x0018, /* IO_ACX_SLV_MEM_DATA */
1376 0x001c, /* IO_ACX_SLV_MEM_CTL */
1377 0x0020, /* IO_ACX_SLV_END_CTL */
1379 0x0034, /* IO_ACX_FEMR */
1381 0x007c, /* IO_ACX_INT_TRIG */
1382 0x0098, /* IO_ACX_IRQ_MASK */
1383 0x00a4, /* IO_ACX_IRQ_STATUS_NON_DES */
1384 0x00a8, /* IO_ACX_IRQ_STATUS_CLEAR */
1385 0x00ac, /* IO_ACX_IRQ_ACK */
1386 0x00b0, /* IO_ACX_HINT_TRIG */
1388 0x0104, /* IO_ACX_ENABLE */
1390 0x0250, /* IO_ACX_EEPROM_CTL */
1391 0x0254, /* IO_ACX_EEPROM_ADDR */
1392 0x0258, /* IO_ACX_EEPROM_DATA */
1393 0x025c, /* IO_ACX_EEPROM_CFG */
1395 0x0268, /* IO_ACX_PHY_ADDR */
1396 0x026c, /* IO_ACX_PHY_DATA */
1397 0x0270, /* IO_ACX_PHY_CTL */
1399 0x0290, /* IO_ACX_GPIO_OE */
1401 0x0298, /* IO_ACX_GPIO_OUT */
1403 0x02a4, /* IO_ACX_CMD_MAILBOX_OFFS */
1404 0x02a8, /* IO_ACX_INFO_MAILBOX_OFFS */
1405 0x02ac, /* IO_ACX_EEPROM_INFORMATION */
1407 0x02d0, /* IO_ACX_EE_START */
1408 0x02d4, /* IO_ACX_SOR_CFG */
1409 0x02d8 /* IO_ACX_ECPU_CTRL */
1412 static const u16 IO_ACX111
[] = {
1413 0x0000, /* IO_ACX_SOFT_RESET */
1415 0x0014, /* IO_ACX_SLV_MEM_ADDR */
1416 0x0018, /* IO_ACX_SLV_MEM_DATA */
1417 0x001c, /* IO_ACX_SLV_MEM_CTL */
1418 0x0020, /* IO_ACX_SLV_END_CTL */
1420 0x0034, /* IO_ACX_FEMR */
1422 0x00b4, /* IO_ACX_INT_TRIG */
1423 0x00d4, /* IO_ACX_IRQ_MASK */
1424 /* we do mean NON_DES (0xf0), not NON_DES_MASK which is at 0xe0: */
1425 0x00f0, /* IO_ACX_IRQ_STATUS_NON_DES */
1426 0x00e4, /* IO_ACX_IRQ_STATUS_CLEAR */
1427 0x00e8, /* IO_ACX_IRQ_ACK */
1428 0x00ec, /* IO_ACX_HINT_TRIG */
1430 0x01d0, /* IO_ACX_ENABLE */
1432 0x0338, /* IO_ACX_EEPROM_CTL */
1433 0x033c, /* IO_ACX_EEPROM_ADDR */
1434 0x0340, /* IO_ACX_EEPROM_DATA */
1435 0x0344, /* IO_ACX_EEPROM_CFG */
1437 0x0350, /* IO_ACX_PHY_ADDR */
1438 0x0354, /* IO_ACX_PHY_DATA */
1439 0x0358, /* IO_ACX_PHY_CTL */
1441 0x0374, /* IO_ACX_GPIO_OE */
1443 0x037c, /* IO_ACX_GPIO_OUT */
1445 0x0388, /* IO_ACX_CMD_MAILBOX_OFFS */
1446 0x038c, /* IO_ACX_INFO_MAILBOX_OFFS */
1447 0x0390, /* IO_ACX_EEPROM_INFORMATION */
1449 0x0100, /* IO_ACX_EE_START */
1450 0x0104, /* IO_ACX_SOR_CFG */
1451 0x0108, /* IO_ACX_ECPU_CTRL */
1454 static const struct ieee80211_ops acxpci_hw_ops
= {
1455 .tx
= acx_i_start_xmit
,
1456 .conf_tx
= acx_net_conf_tx
,
1457 .add_interface
= acx_add_interface
,
1458 .remove_interface
= acx_remove_interface
,
1459 .start
= acxpci_e_open
,
1460 .configure_filter
= acx_i_set_multicast_list
,
1461 .stop
= acxpci_e_close
,
1462 .config
= acx_net_config
,
1463 .config_interface
= acx_config_interface
,
1464 .set_key
= acx_net_set_key
,
1465 .get_stats
= acx_e_get_stats
,
1466 .get_tx_stats
= acx_net_get_tx_stats
,
1471 static int __devinit
1472 acxpci_e_probe(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
1474 acx111_ie_configoption_t co
;
1475 unsigned long mem_region1
= 0;
1476 unsigned long mem_region2
= 0;
1477 unsigned long mem_region1_size
;
1478 unsigned long mem_region2_size
;
1479 unsigned long phymem1
;
1480 unsigned long phymem2
;
1483 acx_device_t
*adev
= NULL
;
1484 const char *chip_name
;
1488 struct ieee80211_hw
*ieee
;
1492 ieee
= ieee80211_alloc_hw(sizeof(struct acx_device
), &acxpci_hw_ops
);
1494 printk("acx: could not allocate ieee80211 structure %s\n",
1496 goto fail_alloc_netdev
;
1498 ieee
->flags
&= ~IEEE80211_HW_RX_INCLUDES_FCS
;
1499 /* TODO: mainline doesn't support the following flags yet */
1501 ~IEEE80211_HW_MONITOR_DURING_OPER &
1502 ~IEEE80211_HW_WEP_INCLUDE_IV;
1506 /* (NB: memsets to 0 entire area) */
1508 printk("acx: could not allocate ieee structure %s\n",
1510 goto fail_alloc_netdev
;
1513 adev
= ieee2adev(ieee
);
1515 memset(adev
, 0, sizeof(*adev
));
1516 /** Set up our private interface **/
1517 spin_lock_init(&adev
->spinlock
); /* initial state: unlocked */
1518 /* We do not start with downed sem: we want PARANOID_LOCKING to work */
1519 printk("mutex_init(&adev->mutex); // adev = 0x%px\n", adev
);
1520 mutex_init(&adev
->mutex
);
1521 /* since nobody can see new netdev yet, we can as well
1522 ** just _presume_ that we're under sem (instead of actually taking it): */
1523 /* acx_sem_lock(adev); */
1526 adev
->bus_dev
= &pdev
->dev
;
1527 adev
->dev_type
= DEVTYPE_PCI
;
1529 /** Finished with private interface **/
1531 /** begin board specific inits **/
1532 pci_set_drvdata(pdev
, ieee
);
1534 /* Enable the PCI device */
1535 if (pci_enable_device(pdev
)) {
1536 printk("acx: pci_enable_device() FAILED\n");
1538 goto fail_pci_enable_device
;
1541 /* enable busmastering (required for CardBus) */
1542 pci_set_master(pdev
);
1545 /* chiptype is u8 but id->driver_data is ulong
1546 ** Works for now (possible values are 1 and 2) */
1547 chip_type
= (u8
) id
->driver_data
;
1548 /* acx100 and acx111 have different PCI memory regions */
1549 if (chip_type
== CHIPTYPE_ACX100
) {
1550 chip_name
= "ACX100";
1551 mem_region1
= PCI_ACX100_REGION1
;
1552 mem_region1_size
= PCI_ACX100_REGION1_SIZE
;
1554 mem_region2
= PCI_ACX100_REGION2
;
1555 mem_region2_size
= PCI_ACX100_REGION2_SIZE
;
1556 } else if (chip_type
== CHIPTYPE_ACX111
) {
1557 chip_name
= "ACX111";
1558 mem_region1
= PCI_ACX111_REGION1
;
1559 mem_region1_size
= PCI_ACX111_REGION1_SIZE
;
1561 mem_region2
= PCI_ACX111_REGION2
;
1562 mem_region2_size
= PCI_ACX111_REGION2_SIZE
;
1564 printk("acx: unknown chip type 0x%04X\n", chip_type
);
1565 goto fail_unknown_chiptype
;
1568 /* Figure out our resources */
1569 phymem1
= pci_resource_start(pdev
, mem_region1
);
1570 phymem2
= pci_resource_start(pdev
, mem_region2
);
1571 if (!request_mem_region
1572 (phymem1
, pci_resource_len(pdev
, mem_region1
), "acx_1")) {
1573 printk("acx: cannot reserve PCI memory region 1 (are you sure "
1574 "you have CardBus support in kernel?)\n");
1575 goto fail_request_mem_region1
;
1577 if (!request_mem_region
1578 (phymem2
, pci_resource_len(pdev
, mem_region2
), "acx_2")) {
1579 printk("acx: cannot reserve PCI memory region 2\n");
1580 goto fail_request_mem_region2
;
1582 /* this used to be ioremap(), but ioremap_nocache()
1583 * is much less risky, right? (and slower?)
1584 * FIXME: we may want to go back to cached variant if it's
1585 * certain that our code really properly handles
1586 * cached operation (memory barriers, volatile?, ...)
1587 * (but always keep this comment here regardless!)
1588 * Possibly make this a driver config setting?
1591 mem1
= ioremap_nocache(phymem1
, mem_region1_size
);
1593 printk("acx: ioremap() FAILED\n");
1596 mem2
= ioremap_nocache(phymem2
, mem_region2_size
);
1598 printk("acx: ioremap() #2 FAILED\n");
1602 printk("acx: found %s-based wireless network card at %s, irq:%d, "
1603 "phymem1:0x%lX, phymem2:0x%lX, mem1:0x%p, mem1_size:%ld, "
1604 "mem2:0x%p, mem2_size:%ld\n",
1605 chip_name
, pci_name(pdev
), pdev
->irq
, phymem1
, phymem2
,
1606 mem1
, mem_region1_size
, mem2
, mem_region2_size
);
1607 log(L_ANY
, "initial debug setting is 0x%04X\n", acx_debug
);
1608 adev
->chip_type
= chip_type
;
1609 adev
->chip_name
= chip_name
;
1610 adev
->io
= (CHIPTYPE_ACX100
== chip_type
) ? IO_ACX100
: IO_ACX111
;
1611 adev
->membase
= phymem1
;
1612 adev
->iobase
= mem1
;
1613 adev
->membase2
= phymem2
;
1614 adev
->iobase2
= mem2
;
1615 adev
->irq
= pdev
->irq
;
1618 if (0 == pdev
->irq
) {
1619 printk("acx: can't use IRQ 0\n");
1622 SET_IEEE80211_DEV(ieee
, &pdev
->dev
);
1625 /* to find crashes due to weird driver access
1626 * to unconfigured interface (ifup) */
1627 adev
->mgmt_timer
.function
= (void (*)(unsigned long))0x0000dead;
1630 #ifdef NONESSENTIAL_FEATURES
1631 acx_show_card_eeprom_id(adev
);
1632 #endif /* NONESSENTIAL_FEATURES */
1635 /* ok, pci setup is finished, now start initializing the card */
1637 /* NB: read_reg() reads may return bogus data before reset_dev(),
1638 * since the firmware which directly controls large parts of the I/O
1639 * registers isn't initialized yet.
1640 * acx100 seems to be more affected than acx111 */
1641 if (OK
!= acxpci_s_reset_dev(adev
))
1644 if (IS_ACX100(adev
)) {
1645 /* ACX100: configopt struct in cmd mailbox - directly after reset */
1646 memcpy_fromio(&co
, adev
->cmd_area
, sizeof(co
));
1649 if (OK
!= acx_s_init_mac(adev
))
1652 if (IS_ACX111(adev
)) {
1653 /* ACX111: configopt struct needs to be queried after full init */
1654 acx_s_interrogate(adev
, &co
, ACX111_IE_CONFIG_OPTIONS
);
1656 /* TODO: merge them into one function, they are called just once and are the same for pci & usb */
1657 if (OK
!= acxpci_read_eeprom_byte(adev
, 0x05, &adev
->eeprom_version
))
1658 goto fail_read_eeprom_version
;
1660 acx_s_parse_configoption(adev
, &co
);
1661 acx_s_set_defaults(adev
);
1662 acx_s_get_firmware_version(adev
); /* needs to be after acx_s_init_mac() */
1663 acx_display_hardware_details(adev
);
1665 /* Register the card, AFTER everything else has been set up,
1666 * since otherwise an ioctl could step on our feet due to
1667 * firmware operations happening in parallel or uninitialized data */
1670 acx_proc_register_entries(ieee
);
1672 /* Now we have our device, so make sure the kernel doesn't try
1673 * to send packets even though we're not associated to a network yet */
1675 /* after register_netdev() userspace may start working with dev
1676 * (in particular, on other CPUs), we only need to up the sem */
1677 /* acx_sem_unlock(adev); */
1679 printk("acx " ACX_RELEASE
": net device %s, driver compiled "
1680 "against wireless extensions %d and Linux %s\n",
1681 wiphy_name(adev
->ieee
->wiphy
), WIRELESS_EXT
, UTS_RELEASE
);
1683 MAC_COPY(adev
->ieee
->wiphy
->perm_addr
, adev
->dev_addr
);
1685 log(L_IRQ
| L_INIT
, "using IRQ %d\n", pdev
->irq
);
1687 /** done with board specific setup **/
1689 /* need to be able to restore PCI state after a suspend */
1691 pci_save_state(pdev
);
1694 err
= acx_setup_modes(adev
);
1696 printk("can't register hwmode\n");
1697 goto fail_register_netdev
;
1700 acx_init_task_scheduler(adev
);
1701 err
= ieee80211_register_hw(ieee
);
1703 printk("acx: ieee80211_register_hw() FAILED: %d\n", err
);
1704 goto fail_register_netdev
;
1707 great_inquisitor(adev
);
1713 /* error paths: undo everything in reverse order... */
1716 acxpci_s_delete_dma_regions(adev
);
1717 pci_set_drvdata(pdev
, NULL
);
1720 fail_read_eeprom_version
:
1732 release_mem_region(pci_resource_start(pdev
, mem_region2
),
1733 pci_resource_len(pdev
, mem_region2
));
1734 fail_request_mem_region2
:
1736 release_mem_region(pci_resource_start(pdev
, mem_region1
),
1737 pci_resource_len(pdev
, mem_region1
));
1738 fail_request_mem_region1
:
1739 fail_unknown_chiptype
:
1741 pci_disable_device(pdev
);
1742 fail_pci_enable_device
:
1745 pci_set_power_state(pdev
, PCI_D3hot
);
1747 fail_register_netdev
:
1748 ieee80211_free_hw(ieee
);
1755 /***********************************************************************
1758 ** Shut device down (if not hot unplugged)
1759 ** and deallocate PCI resources for the acx chip.
1761 ** pdev - ptr to PCI device structure containing info about pci configuration
1763 static void __devexit
acxpci_e_remove(struct pci_dev
*pdev
)
1765 struct ieee80211_hw
*hw
= (struct ieee80211_hw
*)pci_get_drvdata(pdev
);
1766 acx_device_t
*adev
= ieee2adev(hw
);
1767 unsigned long mem_region1
, mem_region2
;
1768 unsigned long flags
;
1772 log(L_DEBUG
, "%s: card is unused. Skipping any release code\n",
1778 adev
->initialized
= 0;
1780 /* If device wasn't hot unplugged... */
1781 if (adev_present(adev
)) {
1783 /* disable both Tx and Rx to shut radio down properly */
1784 if (adev
->initialized
) {
1785 acx_s_issue_cmd(adev
, ACX1xx_CMD_DISABLE_TX
, NULL
, 0);
1786 acx_s_issue_cmd(adev
, ACX1xx_CMD_DISABLE_RX
, NULL
, 0);
1789 /* put the eCPU to sleep to save power
1790 * Halting is not possible currently,
1791 * since not supported by all firmware versions */
1792 acx_s_issue_cmd(adev
, ACX100_CMD_SLEEP
, NULL
, 0);
1794 acx_lock(adev
, flags
);
1795 /* disable power LED to save power :-) */
1796 log(L_INIT
, "switching off power LED to save power\n");
1797 acxpci_l_power_led(adev
, 0);
1799 if (IS_ACX111(adev
)) {
1800 /* FIXME: does this actually keep halting the eCPU?
1801 * I don't think so...
1803 acxpci_l_reset_mac(adev
);
1807 temp
= read_reg16(adev
, IO_ACX_ECPU_CTRL
) | 0x1;
1808 write_reg16(adev
, IO_ACX_ECPU_CTRL
, temp
);
1811 acx_unlock(adev
, flags
);
1815 /* unregister the device to not let the kernel
1816 * (e.g. ioctls) access a half-deconfigured device
1817 * NB: this will cause acxpci_e_close() to be called,
1818 * thus we shouldn't call it under sem!
1819 * Well, netdev did, but ieee80211 stack does not, so we
1820 * have to do so manually...
1823 log(L_INIT
, "removing device %s\n", wiphy_name(adev
->ieee
->wiphy
));
1824 ieee80211_unregister_hw(adev
->ieee
);
1826 /* unregister_netdev ensures that no references to us left.
1827 * For paranoid reasons we continue to follow the rules */
1830 if (adev
->dev_state_mask
& ACX_STATE_IFACE_UP
) {
1832 CLEAR_BIT(adev
->dev_state_mask
, ACX_STATE_IFACE_UP
);
1835 acx_proc_unregister_entries(adev
->ieee
);
1837 if (IS_ACX100(adev
)) {
1838 mem_region1
= PCI_ACX100_REGION1
;
1839 mem_region2
= PCI_ACX100_REGION2
;
1841 mem_region1
= PCI_ACX111_REGION1
;
1842 mem_region2
= PCI_ACX111_REGION2
;
1845 /* finally, clean up PCI bus state */
1846 acxpci_s_delete_dma_regions(adev
);
1848 iounmap(adev
->iobase
);
1850 iounmap(adev
->iobase2
);
1851 release_mem_region(pci_resource_start(pdev
, mem_region1
),
1852 pci_resource_len(pdev
, mem_region1
));
1853 release_mem_region(pci_resource_start(pdev
, mem_region2
),
1854 pci_resource_len(pdev
, mem_region2
));
1855 pci_disable_device(pdev
);
1857 /* remove dev registration */
1859 free_irq(adev
->irq
, adev
);
1860 acx_sem_unlock(adev
);
1862 /* Free netdev (quite late,
1863 * since otherwise we might get caught off-guard
1864 * by a netdev timeout handler execution
1865 * expecting to see a working dev...) */
1866 ieee80211_free_hw(adev
->ieee
);
1868 /* put device into ACPI D3 mode (shutdown) */
1870 pci_set_power_state(pdev
, PCI_D3hot
);
1877 /***********************************************************************
1878 ** TODO: PM code needs to be fixed / debugged / tested.
1882 acxpci_e_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1884 struct ieee80211_hw
*hw
= pci_get_drvdata(pdev
);
1888 printk("acx: suspend handler is experimental!\n");
1889 printk("sus: dev %p\n", hw
);
1891 /* if (!netif_running(ndev))
1894 adev
= ieee2adev(hw
);
1895 printk("sus: adev %p\n", adev
);
1899 ieee80211_unregister_hw(hw
); /* this one cannot sleep */
1901 /* down() does not set it to 0xffff, but here we really want that */
1902 write_reg16(adev
, IO_ACX_IRQ_MASK
, 0xffff);
1903 write_reg16(adev
, IO_ACX_FEMR
, 0x0);
1904 acxpci_s_delete_dma_regions(adev
);
1905 pci_save_state(pdev
);
1906 pci_set_power_state(pdev
, PCI_D3hot
);
1908 acx_sem_unlock(adev
);
1914 static int acxpci_e_resume(struct pci_dev
*pdev
)
1916 struct ieee80211_hw
*hw
= pci_get_drvdata(pdev
);
1921 printk("acx: resume handler is experimental!\n");
1922 printk("rsm: got dev %p\n", hw
);
1925 adev
= ieee2adev(hw
);
1926 printk("rsm: got adev %p\n", adev
);
1930 pci_set_power_state(pdev
, PCI_D0
);
1931 printk("rsm: power state PCI_D0 set\n");
1932 pci_restore_state(pdev
);
1933 printk("rsm: PCI state restored\n");
1935 if (OK
!= acxpci_s_reset_dev(adev
))
1937 printk("rsm: device reset done\n");
1938 if (OK
!= acx_s_init_mac(adev
))
1940 printk("rsm: init MAC done\n");
1943 printk("rsm: acx up done\n");
1945 /* now even reload all card parameters as they were before suspend,
1946 * and possibly be back in the network again already :-) */
1947 if (ACX_STATE_IFACE_UP
& adev
->dev_state_mask
) {
1948 adev
->set_mask
= GETSET_ALL
;
1949 acx_s_update_card_settings(adev
);
1950 printk("rsm: settings updated\n");
1952 ieee80211_register_hw(hw
);
1953 printk("rsm: device attached\n");
1956 acx_sem_unlock(adev
);
1957 /* we need to return OK here anyway, right? */
1961 #endif /* CONFIG_PM */
1962 #endif /* CONFIG_PCI */
1964 /***********************************************************************
1967 ** This function is called by acxpci_e_open (when ifconfig sets the device as up)
1970 ** - Enables on-card interrupt requests
1971 ** - calls acx_s_start
1974 static void enable_acx_irq(acx_device_t
* adev
)
1977 write_reg16(adev
, IO_ACX_IRQ_MASK
, adev
->irq_mask
);
1978 write_reg16(adev
, IO_ACX_FEMR
, 0x8000);
1979 adev
->irqs_active
= 1;
1983 static void acxpci_s_up(struct ieee80211_hw
*hw
)
1985 acx_device_t
*adev
= ieee2adev(hw
);
1986 unsigned long flags
;
1990 acx_lock(adev
, flags
);
1991 enable_acx_irq(adev
);
1992 acx_unlock(adev
, flags
);
1994 /* acx fw < 1.9.3.e has a hardware timer, and older drivers
1995 ** used to use it. But we don't do that anymore, our OS
1996 ** has reliable software timers */
1997 init_timer(&adev
->mgmt_timer
);
1998 adev
->mgmt_timer
.function
= acx_i_timer
;
1999 adev
->mgmt_timer
.data
= (unsigned long)adev
;
2001 /* Need to set ACX_STATE_IFACE_UP first, or else
2002 ** timer won't be started by acx_set_status() */
2003 SET_BIT(adev
->dev_state_mask
, ACX_STATE_IFACE_UP
);
2011 /***********************************************************************
2014 ** NB: device may be already hot unplugged if called from acxpci_e_remove()
2016 ** Disables on-card interrupt request, stops softirq and timer, stops queue,
2017 ** sets status == STOPPED
2020 static void disable_acx_irq(acx_device_t
* adev
)
2024 /* I guess mask is not 0xffff because acx100 won't signal
2025 ** cmd completion then (needed for ifup).
2026 ** I can't ifconfig up after ifconfig down'ing on my acx100 */
2027 write_reg16(adev
, IO_ACX_IRQ_MASK
, adev
->irq_mask_off
);
2028 write_reg16(adev
, IO_ACX_FEMR
, 0x0);
2029 adev
->irqs_active
= 0;
2034 static void acxpci_s_down(struct ieee80211_hw
*hw
)
2036 acx_device_t
*adev
= ieee2adev(hw
);
2040 /* Disable IRQs first, so that IRQs cannot race with us */
2041 /* then wait until interrupts have finished executing on other CPUs */
2042 disable_acx_irq(adev
); /* NO sem-locking here? */
2043 synchronize_irq(adev
->irq
);
2045 /* we really don't want to have an asynchronous tasklet disturb us
2046 ** after something vital for its job has been shut down, so
2047 ** end all remaining work now.
2049 ** NB: carrier_off (done by set_status below) would lead to
2050 ** not yet fully understood deadlock in flush_scheduled_work().
2051 ** That's why we do FLUSH first.
2053 ** NB2: we have a bad locking bug here: flush_scheduled_work()
2054 ** waits for acx_e_after_interrupt_task to complete if it is running
2055 ** on another CPU, but acx_e_after_interrupt_task
2056 ** will sleep on sem forever, because it is taken by us!
2057 ** Work around that by temporary sem unlock.
2058 ** This will fail miserably if we'll be hit by concurrent
2059 ** iwconfig or something in between. TODO! */
2060 acx_sem_unlock(adev
);
2061 flush_scheduled_work();
2064 /* This is possible:
2065 ** flush_scheduled_work -> acx_e_after_interrupt_task ->
2066 ** -> set_status(ASSOCIATED) -> wake_queue()
2067 ** That's why we stop queue _after_ flush_scheduled_work
2068 ** lock/unlock is just paranoia, maybe not needed */
2070 /* kernel/timer.c says it's illegal to del_timer_sync()
2071 ** a timer which restarts itself. We guarantee this cannot
2072 ** ever happen because acx_i_timer() never does this if
2073 ** status is ACX_STATUS_0_STOPPED */
2074 del_timer_sync(&adev
->mgmt_timer
);
2079 #ifdef CONFIG_NET_POLL_CONTROLLER
2080 void acxpci_net_poll_controller(struct net_device *net_dev)
2082 acx_device_t *adev = ndev2adev(net_dev);
2083 unsigned long flags;
2085 local_irq_save(flags);
2086 acxpci_i_interrupt(adev->irq, adev);
2087 local_irq_restore(flags);
2089 #endif*/ /* CONFIG_NET_POLL_CONTROLLER */
2091 /***********************************************************************
2094 ** Called as a result of SIOCSIFFLAGS ioctl changing the flags bit IFF_UP
2095 ** from clear to set. In other words: ifconfig up.
2099 ** >0 f/w reported error
2100 ** <0 driver reported error
2102 static int acxpci_e_open(struct ieee80211_hw
*hw
)
2104 acx_device_t
*adev
= ieee2adev(hw
);
2111 adev
->initialized
= 0;
2113 /* TODO: pci_set_power_state(pdev, PCI_D0); ? */
2115 /* request shared IRQ handler */
2117 (adev
->irq
, acxpci_i_interrupt
, IRQF_SHARED
, KBUILD_MODNAME
, adev
)) {
2118 printk("%s: request_irq FAILED\n", wiphy_name(adev
->ieee
->wiphy
));
2122 log(L_DEBUG
| L_IRQ
, "request_irq %d successful\n", adev
->irq
);
2127 /* We don't currently have to do anything else.
2128 * The setup of the MAC should be subsequently completed via
2129 * the mlme commands.
2130 * Higher layers know we're ready from dev->start==1 and
2131 * dev->tbusy==0. Our rx path knows to pass up received/
2132 * frames because of dev->flags&IFF_UP is true.
2134 ieee80211_start_queues(adev
->ieee
);
2136 adev
->initialized
= 1;
2138 acx_sem_unlock(adev
);
2145 /***********************************************************************
2148 ** This function stops the network functionality of the interface (invoked
2149 ** when the user calls ifconfig <wlan> down). The tx queue is halted and
2150 ** the device is marked as down.
2152 ** Called as a result of SIOCSIIFFLAGS ioctl changing the flags bit IFF_UP
2153 ** from set to clear. I.e. called by "ifconfig DEV down"
2157 ** >0 f/w reported error
2158 ** <0 driver reported error
2160 static void acxpci_e_close(struct ieee80211_hw
*hw
)
2162 acx_device_t
*adev
= ieee2adev(hw
);
2169 CLEAR_BIT(adev
->dev_state_mask
, ACX_STATE_IFACE_UP
);
2170 if (adev
->initialized
) {
2175 acx_free_modes(adev
);
2176 /* disable all IRQs, release shared IRQ handler */
2177 write_reg16(adev
, IO_ACX_IRQ_MASK
, 0xffff);
2178 write_reg16(adev
, IO_ACX_FEMR
, 0x0);
2180 /* TODO: pci_set_power_state(pdev, PCI_D3hot); ? */
2182 /* We currently don't have to do anything else.
2183 * Higher layers know we're not ready from dev->start==0 and
2184 * dev->tbusy==1. Our rx path knows to not pass up received
2185 * frames because of dev->flags&IFF_UP is false.
2187 acx_sem_unlock(adev
);
2189 log(L_INIT
, "closed device\n");
2196 /***************************************************************
2197 ** acxpci_l_process_rxdesc
2199 ** Called directly and only from the IRQ handler
2203 static inline void log_rxbuffer(const acx_device_t
* adev
)
2207 static void log_rxbuffer(const acx_device_t
* adev
)
2209 register const struct rxhostdesc
*rxhostdesc
;
2212 /* no FN_ENTER here, we don't want that */
2214 rxhostdesc
= adev
->rxhostdesc_start
;
2215 if (unlikely(!rxhostdesc
))
2217 for (i
= 0; i
< RX_CNT
; i
++) {
2218 if ((rxhostdesc
->Ctl_16
& cpu_to_le16(DESC_CTL_HOSTOWN
))
2219 && (rxhostdesc
->Status
& cpu_to_le32(DESC_STATUS_FULL
)))
2220 printk("rx: buf %d full\n", i
);
2226 static void acxpci_l_process_rxdesc(acx_device_t
* adev
)
2228 register rxhostdesc_t
*hostdesc
;
2229 unsigned count
, tail
;
2233 if (unlikely(acx_debug
& L_BUFR
))
2236 /* First, have a loop to determine the first descriptor that's
2237 * full, just in case there's a mismatch between our current
2238 * rx_tail and the full descriptor we're supposed to handle. */
2239 tail
= adev
->rx_tail
;
2242 hostdesc
= &adev
->rxhostdesc_start
[tail
];
2243 /* advance tail regardless of outcome of the below test */
2244 tail
= (tail
+ 1) % RX_CNT
;
2246 if ((hostdesc
->Ctl_16
& cpu_to_le16(DESC_CTL_HOSTOWN
))
2247 && (hostdesc
->Status
& cpu_to_le32(DESC_STATUS_FULL
)))
2248 break; /* found it! */
2250 if (unlikely(!--count
)) /* hmm, no luck: all descs empty, bail out */
2254 /* now process descriptors, starting with the first we figured out */
2256 log(L_BUFR
, "rx: tail=%u Ctl_16=%04X Status=%08X\n",
2257 tail
, hostdesc
->Ctl_16
, hostdesc
->Status
);
2259 acx_l_process_rxbuf(adev
, hostdesc
->data
);
2260 hostdesc
->Status
= 0;
2261 /* flush all writes before adapter sees CTL_HOSTOWN change */
2263 /* Host no longer owns this, needs to be LAST */
2264 CLEAR_BIT(hostdesc
->Ctl_16
, cpu_to_le16(DESC_CTL_HOSTOWN
));
2266 /* ok, descriptor is handled, now check the next descriptor */
2267 hostdesc
= &adev
->rxhostdesc_start
[tail
];
2269 /* if next descriptor is empty, then bail out */
2270 if (!(hostdesc
->Ctl_16
& cpu_to_le16(DESC_CTL_HOSTOWN
))
2271 || !(hostdesc
->Status
& cpu_to_le32(DESC_STATUS_FULL
)))
2274 tail
= (tail
+ 1) % RX_CNT
;
2277 adev
->rx_tail
= tail
;
2283 /***********************************************************************
2284 ** acxpci_i_interrupt
2286 ** IRQ handler (atomic context, must not sleep, blah, blah)
2289 /* scan is complete. all frames now on the receive queue are valid */
2290 #define INFO_SCAN_COMPLETE 0x0001
2291 #define INFO_WEP_KEY_NOT_FOUND 0x0002
2292 /* hw has been reset as the result of a watchdog timer timeout */
2293 #define INFO_WATCH_DOG_RESET 0x0003
2294 /* failed to send out NULL frame from PS mode notification to AP */
2295 /* recommended action: try entering 802.11 PS mode again */
2296 #define INFO_PS_FAIL 0x0004
2297 /* encryption/decryption process on a packet failed */
2298 #define INFO_IV_ICV_FAILURE 0x0005
2300 /* Info mailbox format:
2303 more bytes may follow
2304 rumors say about status:
2305 0x0000 info available (set by hw)
2306 0x0001 information received (must be set by host)
2307 0x1000 info available, mailbox overflowed (messages lost) (set by hw)
2308 but in practice we've seen:
2309 0x9000 when we did not set status to 0x0001 on prev message
2310 0x1001 when we did set it
2311 0x0000 was never seen
2312 conclusion: this is really a bitfield:
2313 0x1000 is 'info available' bit
2314 'mailbox overflowed' bit is 0x8000, not 0x1000
2315 value of 0x0000 probably means that there are no messages at all
2316 P.S. I dunno how in hell hw is supposed to notice that messages are lost -
2317 it does NOT clear bit 0x0001, and this bit will probably stay forever set
2318 after we set it once. Let's hope this will be fixed in firmware someday
2321 static void handle_info_irq(acx_device_t
* adev
)
2324 static const char *const info_type_msg
[] = {
2327 "WEP key not found",
2328 "internal watchdog reset was done",
2329 "failed to send powersave (NULL frame) notification to AP",
2330 "encrypt/decrypt on a packet has failed",
2331 "TKIP tx keys disabled",
2332 "TKIP rx keys disabled",
2333 "TKIP rx: key ID not found",
2341 "TKIP IV value exceeds thresh"
2344 u32 info_type
, info_status
;
2346 info_type
= acx_readl(adev
->info_area
);
2347 info_status
= (info_type
>> 16);
2348 info_type
= (u16
) info_type
;
2350 /* inform fw that we have read this info message */
2351 acx_writel(info_type
| 0x00010000, adev
->info_area
);
2352 write_reg16(adev
, IO_ACX_INT_TRIG
, INT_TRIG_INFOACK
);
2355 log(L_CTL
, "info_type:%04X info_status:%04X\n", info_type
, info_status
);
2357 log(L_IRQ
, "got Info IRQ: status %04X type %04X: %s\n",
2358 info_status
, info_type
,
2359 info_type_msg
[(info_type
>= ARRAY_SIZE(info_type_msg
)) ?
2365 static void log_unusual_irq(u16 irqtype
)
2368 if (!printk_ratelimit())
2373 if (irqtype
& HOST_INT_RX_DATA
) {
2376 /* HOST_INT_TX_COMPLETE */
2377 if (irqtype
& HOST_INT_TX_XFER
) {
2380 /* HOST_INT_RX_COMPLETE */
2381 if (irqtype
& HOST_INT_DTIM
) {
2384 if (irqtype
& HOST_INT_BEACON
) {
2387 if (irqtype
& HOST_INT_TIMER
) {
2388 log(L_IRQ
, " Timer");
2390 if (irqtype
& HOST_INT_KEY_NOT_FOUND
) {
2391 printk(" Key_Not_Found");
2393 if (irqtype
& HOST_INT_IV_ICV_FAILURE
) {
2394 printk(" IV_ICV_Failure (crypto)");
2396 /* HOST_INT_CMD_COMPLETE */
2398 if (irqtype
& HOST_INT_OVERFLOW
) {
2399 printk(" Overflow");
2401 if (irqtype
& HOST_INT_PROCESS_ERROR
) {
2402 printk(" Process_Error");
2404 /* HOST_INT_SCAN_COMPLETE */
2405 if (irqtype
& HOST_INT_FCS_THRESHOLD
) {
2406 printk(" FCS_Threshold");
2408 if (irqtype
& HOST_INT_UNKNOWN
) {
2411 printk(" IRQ(s)\n");
2414 /* FIXME: update_link_quality_led was a stub - let's comment it and avoid
2415 * compiler warnings */
2417 static void update_link_quality_led(acx_device_t * adev)
2422 acx_signal_determine_quality(adev->wstats.qual.level,
2423 adev->wstats.qual.noise);
2424 if (qual > adev->brange_max_quality)
2425 qual = adev->brange_max_quality;
2427 if (time_after(jiffies, adev->brange_time_last_state_change +
2429 HZ / 2 * (unsigned long)qual /
2430 adev->brange_max_quality))) {
2431 acxpci_l_power_led(adev, (adev->brange_last_state == 0));
2432 adev->brange_last_state ^= 1; // toggle
2433 adev->brange_time_last_state_change = jiffies;
2438 #define MAX_IRQLOOPS_PER_JIFFY (20000/HZ) /* a la orinoco.c */
2440 /* Interrupt handler bottom-half */
2441 void acx_interrupt_tasklet(struct work_struct
*work
)
2444 #ifdef CONFIG_ACX_MAC80211_DEBUG
2445 u32 _handled
= 0x00000000;
2446 # define acxirq_handled(irq) do { _handled |= (irq); } while (0)
2448 # define acxirq_handled(irq) do { /* nothing */ } while (0)
2449 #endif /* CONFIG_ACX_MAC80211_DEBUG */
2450 acx_device_t
*adev
= container_of(work
,struct acx_device
, after_interrupt_task
);
2451 // unsigned int irqcount = MAX_IRQLOOPS_PER_JIFFY;
2453 unsigned long flags
;
2457 /* LOCKING: can just spin_lock() since IRQs are disabled anyway.
2461 irqtype
= adev
->irq_reason
;
2462 adev
->irq_reason
= 0;
2464 #define IRQ_ITERATE 0
2466 if (jiffies
!= adev
->irq_last_jiffies
) {
2467 adev
->irq_loops_this_jiffy
= 0;
2468 adev
->irq_last_jiffies
= jiffies
;
2471 /* safety condition; we'll normally abort loop below
2472 * in case no IRQ type occurred */
2473 while (likely(--irqcount
)) {
2475 /* ACK all IRQs ASAP */
2477 acx_lock(adev
, flags
);
2479 /* Handle most important IRQ types first */
2480 if (irqtype
& HOST_INT_RX_COMPLETE
) {
2481 log(L_IRQ
, "got Rx_Complete IRQ\n");
2482 acxpci_l_process_rxdesc(adev
);
2484 if (irqtype
& HOST_INT_TX_COMPLETE
) {
2485 log(L_IRQ
, "got Tx_Complete IRQ\n");
2486 /* don't clean up on each Tx complete, wait a bit
2487 * unless we're going towards full, in which case
2488 * we do it immediately, too (otherwise we might lockup
2489 * with a full Tx buffer if we go into
2490 * acxpci_l_clean_txdesc() at a time when we won't wakeup
2491 * the net queue in there for some reason...) */
2492 // if (adev->tx_free <= TX_START_CLEAN) {
2493 acxpci_l_clean_txdesc(adev
);
2497 acx_unlock(adev
, flags
);
2499 /* Less frequent ones */
2501 | HOST_INT_CMD_COMPLETE
2502 | HOST_INT_INFO
| HOST_INT_SCAN_COMPLETE
)) {
2503 if (irqtype
& HOST_INT_INFO
) {
2504 handle_info_irq(adev
);
2506 if (irqtype
& HOST_INT_SCAN_COMPLETE
) {
2507 log(L_IRQ
, "got Scan_Complete IRQ\n");
2508 /* need to do that in process context */
2509 /* remember that fw is not scanning anymore */
2510 SET_BIT(adev
->irq_status
,
2511 HOST_INT_SCAN_COMPLETE
);
2515 /* These we just log, but either they happen rarely
2516 * or we keep them masked out */
2517 if (irqtype
& (0 | HOST_INT_RX_DATA
2518 /* | HOST_INT_TX_COMPLETE */
2520 /* | HOST_INT_RX_COMPLETE */
2524 | HOST_INT_KEY_NOT_FOUND
2525 | HOST_INT_IV_ICV_FAILURE
2526 /* | HOST_INT_CMD_COMPLETE */
2527 /* | HOST_INT_INFO */
2528 | HOST_INT_OVERFLOW
| HOST_INT_PROCESS_ERROR
2529 /* | HOST_INT_SCAN_COMPLETE */
2530 | HOST_INT_FCS_THRESHOLD
| HOST_INT_UNKNOWN
)) {
2531 log_unusual_irq(irqtype
);
2534 unmasked
= read_reg16(adev
, IO_ACX_IRQ_STATUS_CLEAR
);
2535 irqtype
= unmasked
& ~adev
->irq_mask
;
2536 /* Bail out if no new IRQ bits or if all are masked out */
2541 (++adev
->irq_loops_this_jiffy
> MAX_IRQLOOPS_PER_JIFFY
)) {
2543 "acx: too many interrupts per jiffy!\n");
2544 /* Looks like card floods us with IRQs! Try to stop that */
2545 write_reg16(adev
, IO_ACX_IRQ_MASK
, 0xffff);
2546 /* This will short-circuit all future attempts to handle IRQ.
2547 * We cant do much more... */
2553 /* Routine to perform blink with range
2554 * FIXME: update_link_quality_led is a stub - add proper code and enable this again:
2555 if (unlikely(adev->led_power == 2))
2556 update_link_quality_led(adev);
2559 /* write_flush(adev); - not needed, last op was read anyway */
2560 acx_sem_unlock(adev
);
2563 if (adev
->after_interrupt_jobs
)
2564 acx_e_after_interrupt_task(&adev
->after_interrupt_task
);
2572 static irqreturn_t
acxpci_i_interrupt(int irq
, void *dev_id
)
2574 acx_device_t
*adev
= dev_id
;
2575 unsigned long flags
;
2576 register u16 irqtype
;
2584 /* LOCKING: can just spin_lock() since IRQs are disabled anyway.
2587 acx_lock(adev
, flags
);
2589 unmasked
= read_reg16(adev
, IO_ACX_IRQ_STATUS_CLEAR
);
2590 if (unlikely(0xffff == unmasked
)) {
2591 /* 0xffff value hints at missing hardware,
2592 * so don't do anything.
2593 * Not very clean, but other drivers do the same... */
2594 log(L_IRQ
, "IRQ type:FFFF - device removed? IRQ_NONE\n");
2598 /* We will check only "interesting" IRQ types */
2599 irqtype
= unmasked
& ~adev
->irq_mask
;
2601 /* We are on a shared IRQ line and it wasn't our IRQ */
2603 "IRQ type:%04X, mask:%04X - all are masked, IRQ_NONE\n",
2604 unmasked
, adev
->irq_mask
);
2608 /* Go ahead and ACK our interrupt */
2609 write_reg16(adev
, IO_ACX_IRQ_ACK
, 0xffff);
2610 if (irqtype
& HOST_INT_CMD_COMPLETE
) {
2611 log(L_IRQ
, "got Command_Complete IRQ\n");
2612 /* save the state for the running issue_cmd() */
2613 SET_BIT(adev
->irq_status
, HOST_INT_CMD_COMPLETE
);
2616 /* Only accept IRQs, if we are initialized properly.
2617 * This avoids an RX race while initializing.
2618 * We should probably not enable IRQs before we are initialized
2619 * completely, but some careful work is needed to fix this. I think it
2620 * is best to stay with this cheap workaround for now... .
2622 if (likely(adev
->initialized
)) {
2623 /* disable all IRQs. They are enabled again in the bottom half. */
2624 /* save the reason code and call our bottom half. */
2625 adev
->irq_reason
= irqtype
;
2627 if ((irqtype
& HOST_INT_RX_COMPLETE
) || (irqtype
& HOST_INT_TX_COMPLETE
))
2628 acx_schedule_task(adev
, 0);
2631 acx_unlock(adev
, flags
);
2635 acx_unlock(adev
, flags
);
2642 /***********************************************************************
2643 ** acxpci_l_power_led
2645 void acxpci_l_power_led(acx_device_t
* adev
, int enable
)
2647 u16 gpio_pled
= IS_ACX111(adev
) ? 0x0040 : 0x0800;
2649 /* A hack. Not moving message rate limiting to adev->xxx
2650 * (it's only a debug message after all) */
2651 static int rate_limit
= 0;
2653 if (rate_limit
++ < 3)
2654 log(L_IOCTL
, "Please report in case toggling the power "
2655 "LED doesn't work for your card!\n");
2657 write_reg16(adev
, IO_ACX_GPIO_OUT
,
2658 read_reg16(adev
, IO_ACX_GPIO_OUT
) & ~gpio_pled
);
2660 write_reg16(adev
, IO_ACX_GPIO_OUT
,
2661 read_reg16(adev
, IO_ACX_GPIO_OUT
) | gpio_pled
);
2665 /***********************************************************************
2669 /***********************************************************************
2673 acx111pci_ioctl_info(struct net_device
*ndev
,
2674 struct iw_request_info
*info
,
2675 struct iw_param
*vwrq
, char *extra
)
2678 acx_device_t
*adev
= ndev2adev(ndev
);
2681 rxhostdesc_t
*rxhostdesc
;
2682 txhostdesc_t
*txhostdesc
;
2683 struct acx111_ie_memoryconfig memconf
;
2684 struct acx111_ie_queueconfig queueconf
;
2685 unsigned long flags
;
2690 char ratefallback
[0x5];
2692 if (!(acx_debug
& (L_IOCTL
| L_DEBUG
)))
2694 /* using printk() since we checked debug flag already */
2698 if (!IS_ACX111(adev
)) {
2699 printk("acx111-specific function called "
2700 "with non-acx111 chip, aborting\n");
2704 /* get Acx111 Memory Configuration */
2705 memset(&memconf
, 0, sizeof(memconf
));
2706 /* BTW, fails with 12 (Write only) error code.
2707 ** Retained for easy testing of issue_cmd error handling :) */
2708 acx_s_interrogate(adev
, &memconf
, ACX1xx_IE_QUEUE_CONFIG
);
2710 /* get Acx111 Queue Configuration */
2711 memset(&queueconf
, 0, sizeof(queueconf
));
2712 acx_s_interrogate(adev
, &queueconf
, ACX1xx_IE_MEMORY_CONFIG_OPTIONS
);
2714 /* get Acx111 Memory Map */
2715 memset(memmap
, 0, sizeof(memmap
));
2716 acx_s_interrogate(adev
, &memmap
, ACX1xx_IE_MEMORY_MAP
);
2718 /* get Acx111 Rx Config */
2719 memset(rxconfig
, 0, sizeof(rxconfig
));
2720 acx_s_interrogate(adev
, &rxconfig
, ACX1xx_IE_RXCONFIG
);
2722 /* get Acx111 fcs error count */
2723 memset(fcserror
, 0, sizeof(fcserror
));
2724 acx_s_interrogate(adev
, &fcserror
, ACX1xx_IE_FCS_ERROR_COUNT
);
2726 /* get Acx111 rate fallback */
2727 memset(ratefallback
, 0, sizeof(ratefallback
));
2728 acx_s_interrogate(adev
, &ratefallback
, ACX1xx_IE_RATE_FALLBACK
);
2730 /* force occurrence of a beacon interrupt */
2731 /* TODO: comment why is this necessary */
2732 write_reg16(adev
, IO_ACX_HINT_TRIG
, HOST_INT_BEACON
);
2734 /* dump Acx111 Mem Configuration */
2735 printk("dump mem config:\n"
2736 "data read: %d, struct size: %d\n"
2737 "Number of stations: %1X\n"
2738 "Memory block size: %1X\n"
2739 "tx/rx memory block allocation: %1X\n"
2740 "count rx: %X / tx: %X queues\n"
2742 "fragmentation %1X\n"
2743 "Rx Queue 1 Count Descriptors: %X\n"
2744 "Rx Queue 1 Host Memory Start: %X\n"
2745 "Tx Queue 1 Count Descriptors: %X\n"
2746 "Tx Queue 1 Attributes: %X\n",
2747 memconf
.len
, (int)sizeof(memconf
),
2748 memconf
.no_of_stations
,
2749 memconf
.memory_block_size
,
2750 memconf
.tx_rx_memory_block_allocation
,
2751 memconf
.count_rx_queues
, memconf
.count_tx_queues
,
2753 memconf
.fragmentation
,
2754 memconf
.rx_queue1_count_descs
,
2755 acx2cpu(memconf
.rx_queue1_host_rx_start
),
2756 memconf
.tx_queue1_count_descs
, memconf
.tx_queue1_attributes
);
2758 /* dump Acx111 Queue Configuration */
2759 printk("dump queue head:\n"
2760 "data read: %d, struct size: %d\n"
2761 "tx_memory_block_address (from card): %X\n"
2762 "rx_memory_block_address (from card): %X\n"
2763 "rx1_queue address (from card): %X\n"
2764 "tx1_queue address (from card): %X\n"
2765 "tx1_queue attributes (from card): %X\n",
2766 queueconf
.len
, (int)sizeof(queueconf
),
2767 queueconf
.tx_memory_block_address
,
2768 queueconf
.rx_memory_block_address
,
2769 queueconf
.rx1_queue_address
,
2770 queueconf
.tx1_queue_address
, queueconf
.tx1_attributes
);
2772 /* dump Acx111 Mem Map */
2773 printk("dump mem map:\n"
2774 "data read: %d, struct size: %d\n"
2777 "WEP default key start: %X\n"
2778 "WEP default key end: %X\n"
2779 "STA table start: %X\n"
2780 "STA table end: %X\n"
2781 "Packet template start: %X\n"
2782 "Packet template end: %X\n"
2783 "Queue memory start: %X\n"
2784 "Queue memory end: %X\n"
2785 "Packet memory pool start: %X\n"
2786 "Packet memory pool end: %X\n"
2789 *((u16
*) & memmap
[0x02]), (int)sizeof(memmap
),
2790 *((u32
*) & memmap
[0x04]),
2791 *((u32
*) & memmap
[0x08]),
2792 *((u32
*) & memmap
[0x0C]),
2793 *((u32
*) & memmap
[0x10]),
2794 *((u32
*) & memmap
[0x14]),
2795 *((u32
*) & memmap
[0x18]),
2796 *((u32
*) & memmap
[0x1C]),
2797 *((u32
*) & memmap
[0x20]),
2798 *((u32
*) & memmap
[0x24]),
2799 *((u32
*) & memmap
[0x28]),
2800 *((u32
*) & memmap
[0x2C]),
2801 *((u32
*) & memmap
[0x30]), adev
->iobase
, adev
->iobase2
);
2803 /* dump Acx111 Rx Config */
2804 printk("dump rx config:\n"
2805 "data read: %d, struct size: %d\n"
2807 "rx filter config: %X\n",
2808 *((u16
*) & rxconfig
[0x02]), (int)sizeof(rxconfig
),
2809 *((u16
*) & rxconfig
[0x04]), *((u16
*) & rxconfig
[0x06]));
2811 /* dump Acx111 fcs error */
2812 printk("dump fcserror:\n"
2813 "data read: %d, struct size: %d\n"
2815 *((u16
*) & fcserror
[0x02]), (int)sizeof(fcserror
),
2816 *((u32
*) & fcserror
[0x04]));
2818 /* dump Acx111 rate fallback */
2819 printk("dump rate fallback:\n"
2820 "data read: %d, struct size: %d\n"
2821 "ratefallback: %X\n",
2822 *((u16
*) & ratefallback
[0x02]), (int)sizeof(ratefallback
),
2823 *((u8
*) & ratefallback
[0x04]));
2825 /* protect against IRQ */
2826 acx_lock(adev
, flags
);
2828 /* dump acx111 internal rx descriptor ring buffer */
2829 rxdesc
= adev
->rxdesc_start
;
2831 /* loop over complete receive pool */
2833 for (i
= 0; i
< RX_CNT
; i
++) {
2834 printk("\ndump internal rxdesc %d:\n"
2837 "acx mem pointer (dynamic) 0x%X\n"
2838 "CTL (dynamic) 0x%X\n"
2839 "Rate (dynamic) 0x%X\n"
2840 "RxStatus (dynamic) 0x%X\n"
2841 "Mod/Pre (dynamic) 0x%X\n",
2844 acx2cpu(rxdesc
->pNextDesc
),
2845 acx2cpu(rxdesc
->ACXMemPtr
),
2847 rxdesc
->rate
, rxdesc
->error
, rxdesc
->SNR
);
2851 /* dump host rx descriptor ring buffer */
2853 rxhostdesc
= adev
->rxhostdesc_start
;
2855 /* loop over complete receive pool */
2857 for (i
= 0; i
< RX_CNT
; i
++) {
2858 printk("\ndump host rxdesc %d:\n"
2860 "buffer mem pos 0x%X\n"
2861 "buffer mem offset 0x%X\n"
2868 acx2cpu(rxhostdesc
->data_phy
),
2869 rxhostdesc
->data_offset
,
2870 le16_to_cpu(rxhostdesc
->Ctl_16
),
2871 le16_to_cpu(rxhostdesc
->length
),
2872 acx2cpu(rxhostdesc
->desc_phy_next
),
2873 rxhostdesc
->Status
);
2877 /* dump acx111 internal tx descriptor ring buffer */
2878 txdesc
= adev
->txdesc_start
;
2880 /* loop over complete transmit pool */
2882 for (i
= 0; i
< TX_CNT
; i
++) {
2883 printk("\ndump internal txdesc %d:\n"
2887 "acx mem pointer (dynamic) 0x%X\n"
2888 "host mem pointer (dynamic) 0x%X\n"
2889 "length (dynamic) 0x%X\n"
2890 "CTL (dynamic) 0x%X\n"
2891 "CTL2 (dynamic) 0x%X\n"
2892 "Status (dynamic) 0x%X\n"
2893 "Rate (dynamic) 0x%X\n",
2895 (int)sizeof(struct txdesc
),
2897 acx2cpu(txdesc
->pNextDesc
),
2898 acx2cpu(txdesc
->AcxMemPtr
),
2899 acx2cpu(txdesc
->HostMemPtr
),
2900 le16_to_cpu(txdesc
->total_length
),
2902 txdesc
->Ctl2_8
, txdesc
->error
,
2904 txdesc
= advance_txdesc(adev
, txdesc
, 1);
2907 /* dump host tx descriptor ring buffer */
2909 txhostdesc
= adev
->txhostdesc_start
;
2911 /* loop over complete host send pool */
2913 for (i
= 0; i
< TX_CNT
* 2; i
++) {
2914 printk("\ndump host txdesc %d:\n"
2916 "buffer mem pos 0x%X\n"
2917 "buffer mem offset 0x%X\n"
2924 acx2cpu(txhostdesc
->data_phy
),
2925 txhostdesc
->data_offset
,
2926 le16_to_cpu(txhostdesc
->Ctl_16
),
2927 le16_to_cpu(txhostdesc
->length
),
2928 acx2cpu(txhostdesc
->desc_phy_next
),
2929 le32_to_cpu(txhostdesc
->Status
));
2933 /* write_reg16(adev, 0xb4, 0x4); */
2935 acx_unlock(adev
, flags
);
2938 acx_sem_unlock(adev
);
2939 #endif /* ACX_DEBUG */
2944 /***********************************************************************
2947 acx100pci_ioctl_set_phy_amp_bias(struct net_device
*ndev
,
2948 struct iw_request_info
*info
,
2949 struct iw_param
*vwrq
, char *extra
)
2951 acx_device_t
*adev
= ndev2adev(ndev
);
2952 unsigned long flags
;
2955 if (!IS_ACX100(adev
)) {
2957 * Removing this check *might* damage
2958 * hardware, since we're tweaking GPIOs here after all!!!
2959 * You've been warned...
2961 printk("acx: sorry, setting bias level for non-acx100 "
2962 "is not supported yet\n");
2967 printk("acx: invalid bias parameter, range is 0-7\n");
2973 /* Need to lock accesses to [IO_ACX_GPIO_OUT]:
2974 * IRQ handler uses it to update LED */
2975 acx_lock(adev
, flags
);
2976 gpio_old
= read_reg16(adev
, IO_ACX_GPIO_OUT
);
2977 write_reg16(adev
, IO_ACX_GPIO_OUT
,
2978 (gpio_old
& 0xf8ff) | ((u16
) * extra
<< 8));
2979 acx_unlock(adev
, flags
);
2981 log(L_DEBUG
, "gpio_old: 0x%04X\n", gpio_old
);
2982 printk("%s: PHY power amplifier bias: old:%d, new:%d\n",
2983 ndev
->name
, (gpio_old
& 0x0700) >> 8, (unsigned char)*extra
);
2985 acx_sem_unlock(adev
);
2991 /***************************************************************
2992 ** acxpci_l_alloc_tx
2993 ** Actually returns a txdesc_t* ptr
2995 ** FIXME: in case of fragments, should allocate multiple descrs
2996 ** after figuring out how many we need and whether we still have
2997 ** sufficiently many.
2999 tx_t
*acxpci_l_alloc_tx(acx_device_t
* adev
)
3001 struct txdesc
*txdesc
;
3007 if (unlikely(!adev
->tx_free
)) {
3008 printk("acx: BUG: no free txdesc left\n");
3013 head
= adev
->tx_head
;
3014 txdesc
= get_txdesc(adev
, head
);
3015 ctl8
= txdesc
->Ctl_8
;
3017 /* 2005-10-11: there were several bug reports on this happening
3018 ** but now cause seems to be understood & fixed */
3019 if (unlikely(DESC_CTL_HOSTOWN
!= (ctl8
& DESC_CTL_ACXDONE_HOSTOWN
))) {
3020 /* whoops, descr at current index is not free, so probably
3021 * ring buffer already full */
3022 printk("acx: BUG: tx_head:%d Ctl8:0x%02X - failed to find "
3023 "free txdesc\n", head
, ctl8
);
3028 /* Needed in case txdesc won't be eventually submitted for tx */
3029 txdesc
->Ctl_8
= DESC_CTL_ACXDONE_HOSTOWN
;
3032 log(L_BUFT
, "tx: got desc %u, %u remain\n", head
, adev
->tx_free
);
3033 /* Keep a few free descs between head and tail of tx ring.
3034 ** It is not absolutely needed, just feels safer */
3035 if (adev
->tx_free
< TX_STOP_QUEUE
) {
3036 log(L_BUF
, "stop queue (%u tx desc left)\n", adev
->tx_free
);
3037 acx_stop_queue(adev
->ieee
, NULL
);
3040 /* returning current descriptor, so advance to next free one */
3041 adev
->tx_head
= (head
+ 1) % TX_CNT
;
3045 return (tx_t
*) txdesc
;
3049 /***********************************************************************
3051 void *acxpci_l_get_txbuf(acx_device_t
* adev
, tx_t
* tx_opaque
)
3053 return get_txhostdesc(adev
, (txdesc_t
*) tx_opaque
)->data
;
3057 /***********************************************************************
3060 ** Can be called from IRQ (rx -> (AP bridging or mgmt response) -> tx).
3061 ** Can be called from acx_i_start_xmit (data frames from net core).
3063 ** FIXME: in case of fragments, should loop over the number of
3064 ** pre-allocated tx descrs, properly setting up transfer data and
3065 ** CTL_xxx flags according to fragment number.
3068 acxpci_l_tx_data(acx_device_t
* adev
, tx_t
* tx_opaque
, int len
,
3069 struct ieee80211_tx_control
*ieeectl
,struct sk_buff
* skb
)
3071 txdesc_t
*txdesc
= (txdesc_t
*) tx_opaque
;
3072 struct ieee80211_hdr
*wireless_header
;
3073 txhostdesc_t
*hostdesc1
, *hostdesc2
;
3080 /* fw doesn't tx such packets anyhow */
3081 /* if (unlikely(len < WLAN_HDR_A3_LEN))
3084 hostdesc1
= get_txhostdesc(adev
, txdesc
);
3085 wireless_header
= (struct ieee80211_hdr
*)hostdesc1
->data
;
3086 /* modify flag status in separate variable to be able to write it back
3087 * in one big swoop later (also in order to have less device memory
3089 Ctl_8
= txdesc
->Ctl_8
;
3090 Ctl2_8
= 0; /* really need to init it to 0, not txdesc->Ctl2_8, it seems */
3092 hostdesc2
= hostdesc1
+ 1;
3094 /* DON'T simply set Ctl field to 0 here globally,
3095 * it needs to maintain a consistent flag status (those are state flags!!),
3096 * otherwise it may lead to severe disruption. Only set or reset particular
3097 * flags at the exact moment this is needed... */
3099 /* let chip do RTS/CTS handshaking before sending
3100 * in case packet size exceeds threshold */
3101 if (ieeectl
->flags
& IEEE80211_TXCTL_USE_RTS_CTS
)
3102 SET_BIT(Ctl2_8
, DESC_CTL2_RTS
);
3104 CLEAR_BIT(Ctl2_8
, DESC_CTL2_RTS
);
3106 rate_cur
= ieeectl
->tx_rate
;
3107 if (unlikely(!rate_cur
)) {
3108 printk("acx: driver bug! bad ratemask\n");
3112 /* used in tx cleanup routine for auto rate and accounting: */
3113 /* put_txcr(adev, txdesc, clt, rate_cur); deprecated by mac80211 */
3115 txdesc
->total_length
= cpu_to_le16(len
);
3116 wlhdr_len
= ieee80211_get_hdrlen(le16_to_cpu(wireless_header
->frame_control
));
3117 hostdesc2
->length
= cpu_to_le16(len
- wlhdr_len
);
3119 if (!ieeectl->do_not_encrypt && ieeectl->key_idx>= 0)
3121 u16 key_idx = (u16)(ieeectl->key_idx);
3122 struct acx_key* key = &(adev->key[key_idx]);
3126 memcpy(ieeehdr->wep_iv, ((u8*)wireless_header) + wlhdr_len, 4);
3130 if (IS_ACX111(adev
)) {
3131 /* note that if !txdesc->do_auto, txrate->cur
3132 ** has only one nonzero bit */
3133 txdesc
->u
.r2
.rate111
= cpu_to_le16(rate_cur
3134 /* WARNING: I was never able to make it work with prism54 AP.
3135 ** It was falling down to 1Mbit where shortpre is not applicable,
3136 ** and not working at all at "5,11 basic rates only" setting.
3137 ** I even didn't see tx packets in radio packet capture.
3138 ** Disabled for now --vda */
3139 /*| ((clt->shortpre && clt->cur!=RATE111_1) ? RATE111_SHORTPRE : 0) */
3141 #ifdef TODO_FIGURE_OUT_WHEN_TO_SET_THIS
3142 /* should add this to rate111 above as necessary */
3143 |(clt
->pbcc511
? RATE111_PBCC511
: 0)
3145 hostdesc1
->length
= cpu_to_le16(len
);
3146 } else { /* ACX100 */
3147 u8 rate_100
= ieeectl
->tx_rate
;
3148 txdesc
->u
.r1
.rate
= rate_100
;
3149 #ifdef TODO_FIGURE_OUT_WHEN_TO_SET_THIS
3151 if (n
== RATE100_5
|| n
== RATE100_11
)
3152 n
|= RATE100_PBCC511
;
3155 if (clt
->shortpre
&& (clt
->cur
!= RATE111_1
))
3156 SET_BIT(Ctl_8
, DESC_CTL_SHORT_PREAMBLE
); /* set Short Preamble */
3158 /* set autodma and reclaim and 1st mpdu */
3160 DESC_CTL_AUTODMA
| DESC_CTL_RECLAIM
|
3161 DESC_CTL_FIRSTFRAG
);
3162 #if ACX_FRAGMENTATION
3163 /* SET_BIT(Ctl2_8, DESC_CTL2_MORE_FRAG); cannot set it unconditionally, needs to be set for all non-last fragments */
3165 hostdesc1
->length
= cpu_to_le16(wlhdr_len
);
3167 /* don't need to clean ack/rts statistics here, already
3168 * done on descr cleanup */
3170 /* clears HOSTOWN and ACXDONE bits, thus telling that the descriptors
3171 * are now owned by the acx100; do this as LAST operation */
3172 CLEAR_BIT(Ctl_8
, DESC_CTL_ACXDONE_HOSTOWN
);
3173 /* flush writes before we release hostdesc to the adapter here */
3175 CLEAR_BIT(hostdesc1
->Ctl_16
, cpu_to_le16(DESC_CTL_HOSTOWN
));
3176 CLEAR_BIT(hostdesc2
->Ctl_16
, cpu_to_le16(DESC_CTL_HOSTOWN
));
3178 /* write back modified flags */
3179 CLEAR_BIT(Ctl2_8
, DESC_CTL2_WEP
);
3180 txdesc
->Ctl2_8
= Ctl2_8
;
3181 txdesc
->Ctl_8
= Ctl_8
;
3182 /* unused: txdesc->tx_time = cpu_to_le32(jiffies); */
3184 /* flush writes before we tell the adapter that it's its turn now */
3185 write_reg16(adev
, IO_ACX_INT_TRIG
, INT_TRIG_TXPRC
);
3187 /* log the packet content AFTER sending it,
3188 * in order to not delay sending any further than absolutely needed
3189 * Do separate logs for acx100/111 to have human-readable rates */
3190 memcpy(&(hostdesc1
->txstatus
.control
),ieeectl
,sizeof(struct ieee80211_tx_control
));
3191 hostdesc1
->skb
= skb
;
3197 /***********************************************************************
3198 ** acxpci_l_clean_txdesc
3200 ** This function resets the txdescs' status when the ACX100
3201 ** signals the TX done IRQ (txdescs have been processed), starting with
3202 ** the pool index of the descriptor which we would use next,
3203 ** in order to make sure that we can be as fast as possible
3204 ** in filling new txdescs.
3205 ** Everytime we get called we know where the next packet to be cleaned is.
3209 static inline void log_txbuffer(const acx_device_t
* adev
)
3213 static void log_txbuffer(acx_device_t
* adev
)
3218 /* no FN_ENTER here, we don't want that */
3219 /* no locks here, since it's entirely non-critical code */
3220 txdesc
= adev
->txdesc_start
;
3221 if (unlikely(!txdesc
))
3223 printk("tx: desc->Ctl8's:");
3224 for (i
= 0; i
< TX_CNT
; i
++) {
3225 printk(" %02X", txdesc
->Ctl_8
);
3226 txdesc
= advance_txdesc(adev
, txdesc
, 1);
3233 static void handle_tx_error(acx_device_t
* adev
, u8 error
, unsigned int finger
,
3234 struct ieee80211_tx_status
*status
)
3236 const char *err
= "unknown error";
3238 /* hmm, should we handle this as a mask
3239 * of *several* bits?
3240 * For now I think only caring about
3241 * individual bits is ok... */
3244 err
= "no Tx due to error in other fragment";
3245 /* adev->wstats.discard.fragment++; */
3249 adev
->stats
.tx_aborted_errors
++;
3252 err
= "Tx desc wrong parameters";
3253 /* adev->wstats.discard.misc++; */
3256 err
= "WEP key not found";
3257 /* adev->wstats.discard.misc++; */
3260 err
= "MSDU lifetime timeout? - try changing "
3261 "'iwconfig retry lifetime XXX'";
3262 /* adev->wstats.discard.misc++; */
3265 err
= "excessive Tx retries due to either distance "
3266 "too high or unable to Tx or Tx frame error - "
3267 "try changing 'iwconfig txpower XXX' or "
3268 "'sens'itivity or 'retry'";
3269 /* adev->wstats.discard.retries++; */
3270 /* Tx error 0x20 also seems to occur on
3271 * overheating, so I'm not sure whether we
3272 * actually want to do aggressive radio recalibration,
3273 * since people maybe won't notice then that their hardware
3274 * is slowly getting cooked...
3275 * Or is it still a safe long distance from utter
3276 * radio non-functionality despite many radio recalibs
3277 * to final destructive overheating of the hardware?
3278 * In this case we really should do recalib here...
3279 * I guess the only way to find out is to do a
3280 * potentially fatal self-experiment :-\
3281 * Or maybe only recalib in case we're using Tx
3282 * rate auto (on errors switching to lower speed
3283 * --> less heat?) or 802.11 power save mode?
3285 * ok, just do it. */
3286 if (++adev
->retry_errors_msg_ratelimit
% 4 == 0) {
3287 if (adev
->retry_errors_msg_ratelimit
<= 20) {
3288 printk("%s: several excessive Tx "
3289 "retry errors occurred, attempting "
3290 "to recalibrate radio. Radio "
3291 "drift might be caused by increasing "
3292 "card temperature, please check the card "
3293 "before it's too late!\n",
3294 wiphy_name(adev
->ieee
->wiphy
));
3295 if (adev
->retry_errors_msg_ratelimit
== 20)
3296 printk("disabling above message\n");
3299 acx_schedule_task(adev
,
3300 ACX_AFTER_IRQ_CMD_RADIO_RECALIB
);
3302 status
->excessive_retries
++;
3305 err
= "Tx buffer overflow";
3306 adev
->stats
.tx_fifo_errors
++;
3309 /* possibly ACPI C-state powersaving related!!!
3310 * (DMA timeout due to excessively high wakeup
3311 * latency after C-state activation!?)
3312 * Disable C-State powersaving and try again,
3313 * then PLEASE REPORT, I'm VERY interested in
3314 * whether my theory is correct that this is
3315 * actually the problem here.
3316 * In that case, use new Linux idle wakeup latency
3317 * requirements kernel API to prevent this issue. */
3319 /* adev->wstats.discard.misc++; */
3322 adev
->stats
.tx_errors
++;
3323 if (adev
->stats
.tx_errors
<= 20)
3324 printk("%s: tx error 0x%02X, buf %02u! (%s)\n",
3325 wiphy_name(adev
->ieee
->wiphy
), error
, finger
, err
);
3327 printk("%s: tx error 0x%02X, buf %02u!\n",
3328 wiphy_name(adev
->ieee
->wiphy
), error
, finger
);
3332 unsigned int acxpci_l_clean_txdesc(acx_device_t
* adev
)
3335 txhostdesc_t
*hostdesc
;
3339 u8 error
, ack_failures
, rts_failures
, rts_ok
, r100
;
3343 if (unlikely(acx_debug
& L_DEBUG
))
3346 log(L_BUFT
, "tx: cleaning up bufs from %u\n", adev
->tx_tail
);
3348 /* We know first descr which is not free yet. We advance it as far
3349 ** as we see correct bits set in following descs (if next desc
3350 ** is NOT free, we shouldn't advance at all). We know that in
3351 ** front of tx_tail may be "holes" with isolated free descs.
3352 ** We will catch up when all intermediate descs will be freed also */
3354 finger
= adev
->tx_tail
;
3356 while (likely(finger
!= adev
->tx_head
)) {
3357 txdesc
= get_txdesc(adev
, finger
);
3359 /* If we allocated txdesc on tx path but then decided
3360 ** to NOT use it, then it will be left as a free "bubble"
3361 ** in the "allocated for tx" part of the ring.
3362 ** We may meet it on the next ring pass here. */
3364 /* stop if not marked as "tx finished" and "host owned" */
3365 if ((txdesc
->Ctl_8
& DESC_CTL_ACXDONE_HOSTOWN
)
3366 != DESC_CTL_ACXDONE_HOSTOWN
) {
3367 if (unlikely(!num_cleaned
)) { /* maybe remove completely */
3368 log(L_BUFT
, "clean_txdesc: tail isn't free. "
3369 "tail:%d head:%d\n",
3370 adev
->tx_tail
, adev
->tx_head
);
3375 /* remember desc values... */
3376 error
= txdesc
->error
;
3377 ack_failures
= txdesc
->ack_failures
;
3378 rts_failures
= txdesc
->rts_failures
;
3379 rts_ok
= txdesc
->rts_ok
;
3380 r100
= txdesc
->u
.r1
.rate
;
3381 r111
= le16_to_cpu(txdesc
->u
.r2
.rate111
);
3383 /* need to check for certain error conditions before we
3384 * clean the descriptor: we still need valid descr data here */
3385 hostdesc
= get_txhostdesc(adev
, txdesc
);
3387 hostdesc
->txstatus
.flags
|= IEEE80211_TX_STATUS_ACK
;
3388 if (unlikely(0x30 & error
)) {
3389 /* only send IWEVTXDROP in case of retry or lifetime exceeded;
3390 * all other errors mean we screwed up locally */
3391 /* union iwreq_data wrqu;
3392 struct ieee80211_hdr_3addr *hdr;
3393 hdr = (struct ieee80211_hdr_3addr *) hostdesc->data;
3394 MAC_COPY(wrqu.addr.sa_data, hdr->addr1);
3396 hostdesc
->txstatus
.flags
&= ~IEEE80211_TX_STATUS_ACK
;
3399 /* ...and free the desc */
3401 txdesc
->ack_failures
= 0;
3402 txdesc
->rts_failures
= 0;
3404 /* signal host owning it LAST, since ACX already knows that this
3405 ** descriptor is finished since it set Ctl_8 accordingly. */
3406 txdesc
->Ctl_8
= DESC_CTL_HOSTOWN
;
3411 if ((adev
->tx_free
>= TX_START_QUEUE
)
3412 /* && (adev->status == ACX_STATUS_4_ASSOCIATED) */
3413 /*&& (acx_queue_stopped(adev->ieee))*/
3415 log(L_BUF
, "tx: wake queue (avail. Tx desc %u)\n",
3417 acx_wake_queue(adev
->ieee
, NULL
);
3420 /* do error checking, rate handling and logging
3421 * AFTER having done the work, it's faster */
3423 /* Rate handling is done in mac80211 */
3424 /* if (adev->rate_auto) {
3425 struct client *clt = get_txc(adev, txdesc);
3427 u16 cur = get_txr(adev, txdesc);
3428 if (clt->rate_cur == cur) {
3429 acx_l_handle_txrate_auto(adev, clt, cur,*/ /* intended rate */
3430 /*r100, r111,*/ /* actually used rate */
3431 /*(error & 0x30),*/ /* was there an error? */
3440 if (unlikely(error
))
3441 handle_tx_error(adev
, error
, finger
, &hostdesc
->txstatus
);
3443 if (IS_ACX111(adev
))
3445 "tx: cleaned %u: !ACK=%u !RTS=%u RTS=%u r111=%04X tx_free=%u\n",
3446 finger
, ack_failures
, rts_failures
, rts_ok
, r111
, adev
->tx_free
);
3449 "tx: cleaned %u: !ACK=%u !RTS=%u RTS=%u rate=%u\n",
3450 finger
, ack_failures
, rts_failures
, rts_ok
, r100
);
3452 /* And finally report upstream */
3455 hostdesc
->txstatus
.excessive_retries
= rts_failures
;
3456 hostdesc
->txstatus
.retry_count
= ack_failures
;
3457 ieee80211_tx_status(adev
->ieee
,hostdesc
->skb
,&hostdesc
->txstatus
);
3458 memset(&hostdesc
->txstatus
, 0, sizeof(struct ieee80211_tx_status
));
3460 /* update pointer for descr to be cleaned next */
3461 finger
= (finger
+ 1) % TX_CNT
;
3463 /* remember last position */
3464 adev
->tx_tail
= finger
;
3466 FN_EXIT1(num_cleaned
);
3470 /* clean *all* Tx descriptors, and regardless of their previous state.
3471 * Used for brute-force reset handling. */
3472 void acxpci_l_clean_txdesc_emergency(acx_device_t
* adev
)
3479 for (i
= 0; i
< TX_CNT
; i
++) {
3480 txdesc
= get_txdesc(adev
, i
);
3483 txdesc
->ack_failures
= 0;
3484 txdesc
->rts_failures
= 0;
3487 txdesc
->Ctl_8
= DESC_CTL_HOSTOWN
;
3490 adev
->tx_free
= TX_CNT
;
3496 /***********************************************************************
3497 ** acxpci_s_create_tx_host_desc_queue
3500 static void *allocate(acx_device_t
* adev
, size_t size
, dma_addr_t
* phy
,
3505 ptr
= dma_alloc_coherent(adev
->bus_dev
, size
, phy
, GFP_KERNEL
);
3508 log(L_DEBUG
, "%s sz=%d adr=0x%p phy=0x%08llx\n",
3509 msg
, (int)size
, ptr
, (unsigned long long)*phy
);
3510 memset(ptr
, 0, size
);
3513 printk(KERN_ERR
"acx: %s allocation FAILED (%d bytes)\n",
3519 static int acxpci_s_create_tx_host_desc_queue(acx_device_t
* adev
)
3521 txhostdesc_t
*hostdesc
;
3523 dma_addr_t hostdesc_phy
;
3524 dma_addr_t txbuf_phy
;
3529 /* allocate TX buffer */
3530 adev
->txbuf_area_size
= TX_CNT
* /*WLAN_A4FR_MAXLEN_WEP_FCS*/ (30 + 2312 + 4);
3531 adev
->txbuf_start
= allocate(adev
, adev
->txbuf_area_size
,
3532 &adev
->txbuf_startphy
, "txbuf_start");
3533 if (!adev
->txbuf_start
)
3536 /* allocate the TX host descriptor queue pool */
3537 adev
->txhostdesc_area_size
= TX_CNT
* 2 * sizeof(*hostdesc
);
3538 adev
->txhostdesc_start
= allocate(adev
, adev
->txhostdesc_area_size
,
3539 &adev
->txhostdesc_startphy
,
3540 "txhostdesc_start");
3541 if (!adev
->txhostdesc_start
)
3543 /* check for proper alignment of TX host descriptor pool */
3544 if ((long)adev
->txhostdesc_start
& 3) {
3546 ("acx: driver bug: dma alloc returns unaligned address\n");
3550 hostdesc
= adev
->txhostdesc_start
;
3551 hostdesc_phy
= adev
->txhostdesc_startphy
;
3552 txbuf
= adev
->txbuf_start
;
3553 txbuf_phy
= adev
->txbuf_startphy
;
3556 /* Each tx buffer is accessed by hardware via
3557 ** txdesc -> txhostdesc(s) -> txbuffer(s).
3558 ** We use only one txhostdesc per txdesc, but it looks like
3559 ** acx111 is buggy: it accesses second txhostdesc
3560 ** (via hostdesc.desc_phy_next field) even if
3561 ** txdesc->length == hostdesc->length and thus
3562 ** entire packet was placed into first txhostdesc.
3563 ** Due to this bug acx111 hangs unless second txhostdesc
3564 ** has le16_to_cpu(hostdesc.length) = 3 (or larger)
3565 ** Storing NULL into hostdesc.desc_phy_next
3566 ** doesn't seem to help.
3568 ** Update: although it worked on Xterasys XN-2522g
3569 ** with len=3 trick, WG311v2 is even more bogus, doesn't work.
3570 ** Keeping this code (#ifdef'ed out) for documentational purposes.
3572 for (i
= 0; i
< TX_CNT
* 2; i
++) {
3573 hostdesc_phy
+= sizeof(*hostdesc
);
3575 hostdesc
->data_phy
= cpu2acx(txbuf_phy
);
3576 /* hostdesc->data_offset = ... */
3577 /* hostdesc->reserved = ... */
3578 hostdesc
->Ctl_16
= cpu_to_le16(DESC_CTL_HOSTOWN
);
3579 /* hostdesc->length = ... */
3580 hostdesc
->desc_phy_next
= cpu2acx(hostdesc_phy
);
3581 hostdesc
->pNext
= ptr2acx(NULL
);
3582 /* hostdesc->Status = ... */
3583 /* below: non-hardware fields */
3584 hostdesc
->data
= txbuf
;
3586 txbuf
+= WLAN_A4FR_MAXLEN_WEP_FCS
;
3587 txbuf_phy
+= WLAN_A4FR_MAXLEN_WEP_FCS
;
3589 /* hostdesc->data_phy = ... */
3590 /* hostdesc->data_offset = ... */
3591 /* hostdesc->reserved = ... */
3592 /* hostdesc->Ctl_16 = ... */
3593 hostdesc
->length
= cpu_to_le16(3); /* bug workaround */
3594 /* hostdesc->desc_phy_next = ... */
3595 /* hostdesc->pNext = ... */
3596 /* hostdesc->Status = ... */
3597 /* below: non-hardware fields */
3598 /* hostdesc->data = ... */
3603 /* We initialize two hostdescs so that they point to adjacent
3604 ** memory areas. Thus txbuf is really just a contiguous memory area */
3605 for (i
= 0; i
< TX_CNT
* 2; i
++) {
3606 hostdesc_phy
+= sizeof(*hostdesc
);
3608 hostdesc
->data_phy
= cpu2acx(txbuf_phy
);
3609 /* done by memset(0): hostdesc->data_offset = 0; */
3610 /* hostdesc->reserved = ... */
3611 hostdesc
->Ctl_16
= cpu_to_le16(DESC_CTL_HOSTOWN
);
3612 /* hostdesc->length = ... */
3613 hostdesc
->desc_phy_next
= cpu2acx(hostdesc_phy
);
3614 /* done by memset(0): hostdesc->pNext = ptr2acx(NULL); */
3615 /* hostdesc->Status = ... */
3616 /* ->data is a non-hardware field: */
3617 hostdesc
->data
= txbuf
;
3620 txbuf
+= 24 /*WLAN_HDR_A3_LEN*/;
3621 txbuf_phy
+= 24 /*WLAN_HDR_A3_LEN*/;
3623 txbuf
+= 30 + 2132 + 4 - 24/*WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN*/;
3624 txbuf_phy
+= 30 + 2132 +4 - 24/*WLAN_A4FR_MAXLEN_WEP_FCS - WLAN_HDR_A3_LEN*/;
3629 hostdesc
->desc_phy_next
= cpu2acx(adev
->txhostdesc_startphy
);
3634 printk("acx: create_tx_host_desc_queue FAILED\n");
3635 /* dealloc will be done by free function on error case */
3641 /***************************************************************
3642 ** acxpci_s_create_rx_host_desc_queue
3644 /* the whole size of a data buffer (header plus data body)
3645 * plus 32 bytes safety offset at the end */
3646 #define RX_BUFFER_SIZE (sizeof(rxbuffer_t) + 32)
3648 static int acxpci_s_create_rx_host_desc_queue(acx_device_t
* adev
)
3650 rxhostdesc_t
*hostdesc
;
3652 dma_addr_t hostdesc_phy
;
3653 dma_addr_t rxbuf_phy
;
3658 /* allocate the RX host descriptor queue pool */
3659 adev
->rxhostdesc_area_size
= RX_CNT
* sizeof(*hostdesc
);
3660 adev
->rxhostdesc_start
= allocate(adev
, adev
->rxhostdesc_area_size
,
3661 &adev
->rxhostdesc_startphy
,
3662 "rxhostdesc_start");
3663 if (!adev
->rxhostdesc_start
)
3665 /* check for proper alignment of RX host descriptor pool */
3666 if ((long)adev
->rxhostdesc_start
& 3) {
3668 ("acx: driver bug: dma alloc returns unaligned address\n");
3672 /* allocate Rx buffer pool which will be used by the acx
3673 * to store the whole content of the received frames in it */
3674 adev
->rxbuf_area_size
= RX_CNT
* RX_BUFFER_SIZE
;
3675 adev
->rxbuf_start
= allocate(adev
, adev
->rxbuf_area_size
,
3676 &adev
->rxbuf_startphy
, "rxbuf_start");
3677 if (!adev
->rxbuf_start
)
3680 rxbuf
= adev
->rxbuf_start
;
3681 rxbuf_phy
= adev
->rxbuf_startphy
;
3682 hostdesc
= adev
->rxhostdesc_start
;
3683 hostdesc_phy
= adev
->rxhostdesc_startphy
;
3685 /* don't make any popular C programming pointer arithmetic mistakes
3686 * here, otherwise I'll kill you...
3687 * (and don't dare asking me why I'm warning you about that...) */
3688 for (i
= 0; i
< RX_CNT
; i
++) {
3689 hostdesc
->data
= rxbuf
;
3690 hostdesc
->data_phy
= cpu2acx(rxbuf_phy
);
3691 hostdesc
->length
= cpu_to_le16(RX_BUFFER_SIZE
);
3692 CLEAR_BIT(hostdesc
->Ctl_16
, cpu_to_le16(DESC_CTL_HOSTOWN
));
3694 rxbuf_phy
+= sizeof(*rxbuf
);
3695 hostdesc_phy
+= sizeof(*hostdesc
);
3696 hostdesc
->desc_phy_next
= cpu2acx(hostdesc_phy
);
3700 hostdesc
->desc_phy_next
= cpu2acx(adev
->rxhostdesc_startphy
);
3704 printk("acx: create_rx_host_desc_queue FAILED\n");
3705 /* dealloc will be done by free function on error case */
3711 /***************************************************************
3712 ** acxpci_s_create_hostdesc_queues
3714 int acxpci_s_create_hostdesc_queues(acx_device_t
* adev
)
3717 result
= acxpci_s_create_tx_host_desc_queue(adev
);
3720 result
= acxpci_s_create_rx_host_desc_queue(adev
);
3725 /***************************************************************
3726 ** acxpci_create_tx_desc_queue
3728 static void acxpci_create_tx_desc_queue(acx_device_t
* adev
, u32 tx_queue_start
)
3731 txhostdesc_t
*hostdesc
;
3732 dma_addr_t hostmemptr
;
3738 if (IS_ACX100(adev
))
3739 adev
->txdesc_size
= sizeof(*txdesc
);
3741 /* the acx111 txdesc is 4 bytes larger */
3742 adev
->txdesc_size
= sizeof(*txdesc
) + 4;
3744 adev
->txdesc_start
= (txdesc_t
*) (adev
->iobase2
+ tx_queue_start
);
3746 log(L_DEBUG
, "adev->iobase2=%p\n"
3747 "tx_queue_start=%08X\n"
3748 "adev->txdesc_start=%p\n",
3749 adev
->iobase2
, tx_queue_start
, adev
->txdesc_start
);
3751 adev
->tx_free
= TX_CNT
;
3752 /* done by memset: adev->tx_head = 0; */
3753 /* done by memset: adev->tx_tail = 0; */
3754 txdesc
= adev
->txdesc_start
;
3755 mem_offs
= tx_queue_start
;
3756 hostmemptr
= adev
->txhostdesc_startphy
;
3757 hostdesc
= adev
->txhostdesc_start
;
3759 if (IS_ACX111(adev
)) {
3760 /* ACX111 has a preinitialized Tx buffer! */
3761 /* loop over whole send pool */
3762 /* FIXME: do we have to do the hostmemptr stuff here?? */
3763 for (i
= 0; i
< TX_CNT
; i
++) {
3764 txdesc
->HostMemPtr
= ptr2acx(hostmemptr
);
3765 txdesc
->Ctl_8
= DESC_CTL_HOSTOWN
;
3766 /* reserve two (hdr desc and payload desc) */
3768 hostmemptr
+= 2 * sizeof(*hostdesc
);
3769 txdesc
= advance_txdesc(adev
, txdesc
, 1);
3772 /* ACX100 Tx buffer needs to be initialized by us */
3773 /* clear whole send pool. sizeof is safe here (we are acx100) */
3774 memset(adev
->txdesc_start
, 0, TX_CNT
* sizeof(*txdesc
));
3776 /* loop over whole send pool */
3777 for (i
= 0; i
< TX_CNT
; i
++) {
3778 log(L_DEBUG
, "configure card tx descriptor: 0x%p, "
3779 "size: 0x%X\n", txdesc
, adev
->txdesc_size
);
3781 /* pointer to hostdesc memory */
3782 txdesc
->HostMemPtr
= ptr2acx(hostmemptr
);
3783 /* initialise ctl */
3784 txdesc
->Ctl_8
= (DESC_CTL_HOSTOWN
| DESC_CTL_RECLAIM
3785 | DESC_CTL_AUTODMA
|
3786 DESC_CTL_FIRSTFRAG
);
3787 /* done by memset(0): txdesc->Ctl2_8 = 0; */
3788 /* point to next txdesc */
3790 cpu2acx(mem_offs
+ adev
->txdesc_size
);
3791 /* reserve two (hdr desc and payload desc) */
3793 hostmemptr
+= 2 * sizeof(*hostdesc
);
3794 /* go to the next one */
3795 mem_offs
+= adev
->txdesc_size
;
3796 /* ++ is safe here (we are acx100) */
3799 /* go back to the last one */
3801 /* and point to the first making it a ring buffer */
3802 txdesc
->pNextDesc
= cpu2acx(tx_queue_start
);
3808 /***************************************************************
3809 ** acxpci_create_rx_desc_queue
3811 static void acxpci_create_rx_desc_queue(acx_device_t
* adev
, u32 rx_queue_start
)
3819 /* done by memset: adev->rx_tail = 0; */
3821 /* ACX111 doesn't need any further config: preconfigures itself.
3822 * Simply print ring buffer for debugging */
3823 if (IS_ACX111(adev
)) {
3824 /* rxdesc_start already set here */
3826 adev
->rxdesc_start
=
3827 (rxdesc_t
*) ((u8
*) adev
->iobase2
+ rx_queue_start
);
3829 rxdesc
= adev
->rxdesc_start
;
3830 for (i
= 0; i
< RX_CNT
; i
++) {
3831 log(L_DEBUG
, "rx descriptor %d @ 0x%p\n", i
, rxdesc
);
3832 rxdesc
= adev
->rxdesc_start
= (rxdesc_t
*)
3833 (adev
->iobase2
+ acx2cpu(rxdesc
->pNextDesc
));
3836 /* we didn't pre-calculate rxdesc_start in case of ACX100 */
3837 /* rxdesc_start should be right AFTER Tx pool */
3838 adev
->rxdesc_start
= (rxdesc_t
*)
3839 ((u8
*) adev
->txdesc_start
+ (TX_CNT
* sizeof(txdesc_t
)));
3840 /* NB: sizeof(txdesc_t) above is valid because we know
3841 ** we are in if (acx100) block. Beware of cut-n-pasting elsewhere!
3842 ** acx111's txdesc is larger! */
3844 memset(adev
->rxdesc_start
, 0, RX_CNT
* sizeof(*rxdesc
));
3846 /* loop over whole receive pool */
3847 rxdesc
= adev
->rxdesc_start
;
3848 mem_offs
= rx_queue_start
;
3849 for (i
= 0; i
< RX_CNT
; i
++) {
3850 log(L_DEBUG
, "rx descriptor @ 0x%p\n", rxdesc
);
3851 rxdesc
->Ctl_8
= DESC_CTL_RECLAIM
| DESC_CTL_AUTODMA
;
3852 /* point to next rxdesc */
3853 rxdesc
->pNextDesc
= cpu2acx(mem_offs
+ sizeof(*rxdesc
));
3854 /* go to the next one */
3855 mem_offs
+= sizeof(*rxdesc
);
3858 /* go to the last one */
3861 /* and point to the first making it a ring buffer */
3862 rxdesc
->pNextDesc
= cpu2acx(rx_queue_start
);
3868 /***************************************************************
3869 ** acxpci_create_desc_queues
3872 acxpci_create_desc_queues(acx_device_t
* adev
, u32 tx_queue_start
,
3875 acxpci_create_tx_desc_queue(adev
, tx_queue_start
);
3876 acxpci_create_rx_desc_queue(adev
, rx_queue_start
);
3880 /***************************************************************
3881 ** acxpci_s_proc_diag_output
3883 char *acxpci_s_proc_diag_output(char *p
, acx_device_t
* adev
)
3885 const char *rtl
, *thd
, *ttl
;
3886 rxhostdesc_t
*rxhostdesc
;
3892 p
+= sprintf(p
, "** Rx buf **\n");
3893 rxhostdesc
= adev
->rxhostdesc_start
;
3895 for (i
= 0; i
< RX_CNT
; i
++) {
3896 rtl
= (i
== adev
->rx_tail
) ? " [tail]" : "";
3897 if ((rxhostdesc
->Ctl_16
& cpu_to_le16(DESC_CTL_HOSTOWN
))
3899 Status
& cpu_to_le32(DESC_STATUS_FULL
)))
3900 p
+= sprintf(p
, "%02u FULL%s\n", i
, rtl
);
3902 p
+= sprintf(p
, "%02u empty%s\n", i
, rtl
);
3905 /* p += sprintf(p, "** Tx buf (free %d, Linux netqueue %s) **\n",
3907 acx_queue_stopped(adev->ieee) ? "STOPPED" : "running");*/
3908 txdesc
= adev
->txdesc_start
;
3910 for (i
= 0; i
< TX_CNT
; i
++) {
3911 thd
= (i
== adev
->tx_head
) ? " [head]" : "";
3912 ttl
= (i
== adev
->tx_tail
) ? " [tail]" : "";
3913 if (txdesc
->Ctl_8
& DESC_CTL_ACXDONE
)
3914 p
+= sprintf(p
, "%02u free (%02X)%s%s\n", i
,
3915 txdesc
->Ctl_8
, thd
, ttl
);
3917 p
+= sprintf(p
, "%02u tx (%02X)%s%s\n", i
,
3918 txdesc
->Ctl_8
, thd
, ttl
);
3919 txdesc
= advance_txdesc(adev
, txdesc
, 1);
3924 "txbuf_start %p, txbuf_area_size %u, txbuf_startphy %08llx\n"
3925 "txdesc_size %u, txdesc_start %p\n"
3926 "txhostdesc_start %p, txhostdesc_area_size %u, txhostdesc_startphy %08llx\n"
3928 "rxhostdesc_start %p, rxhostdesc_area_size %u, rxhostdesc_startphy %08llx\n"
3929 "rxbuf_start %p, rxbuf_area_size %u, rxbuf_startphy %08llx\n",
3930 adev
->txbuf_start
, adev
->txbuf_area_size
,
3931 (unsigned long long)adev
->txbuf_startphy
,
3932 adev
->txdesc_size
, adev
->txdesc_start
,
3933 adev
->txhostdesc_start
, adev
->txhostdesc_area_size
,
3934 (unsigned long long)adev
->txhostdesc_startphy
,
3936 adev
->rxhostdesc_start
, adev
->rxhostdesc_area_size
,
3937 (unsigned long long)adev
->rxhostdesc_startphy
,
3938 adev
->rxbuf_start
, adev
->rxbuf_area_size
,
3939 (unsigned long long)adev
->rxbuf_startphy
);
3946 /***********************************************************************
3948 int acxpci_proc_eeprom_output(char *buf
, acx_device_t
* adev
)
3955 for (i
= 0; i
< 0x400; i
++) {
3956 acxpci_read_eeprom_byte(adev
, i
, p
++);
3964 /***********************************************************************
3967 void acxpci_set_interrupt_mask(acx_device_t
* adev
)
3969 if (IS_ACX111(adev
)) {
3970 adev
->irq_mask
= (u16
) ~ (0
3971 /* | HOST_INT_RX_DATA */
3972 | HOST_INT_TX_COMPLETE
3973 /* | HOST_INT_TX_XFER */
3974 | HOST_INT_RX_COMPLETE
3975 /* | HOST_INT_DTIM */
3976 /* | HOST_INT_BEACON */
3977 /* | HOST_INT_TIMER */
3978 /* | HOST_INT_KEY_NOT_FOUND */
3979 | HOST_INT_IV_ICV_FAILURE
3980 | HOST_INT_CMD_COMPLETE
3982 /* | HOST_INT_OVERFLOW */
3983 /* | HOST_INT_PROCESS_ERROR */
3984 | HOST_INT_SCAN_COMPLETE
3985 | HOST_INT_FCS_THRESHOLD
3986 /* | HOST_INT_UNKNOWN */
3988 /* Or else acx100 won't signal cmd completion, right? */
3989 adev
->irq_mask_off
= (u16
) ~ (HOST_INT_CMD_COMPLETE
); /* 0xfdff */
3991 adev
->irq_mask
= (u16
) ~ (0
3992 /* | HOST_INT_RX_DATA */
3993 | HOST_INT_TX_COMPLETE
3994 /* | HOST_INT_TX_XFER */
3995 | HOST_INT_RX_COMPLETE
3996 /* | HOST_INT_DTIM */
3997 /* | HOST_INT_BEACON */
3998 /* | HOST_INT_TIMER */
3999 /* | HOST_INT_KEY_NOT_FOUND */
4000 /* | HOST_INT_IV_ICV_FAILURE */
4001 | HOST_INT_CMD_COMPLETE
4003 /* | HOST_INT_OVERFLOW */
4004 /* | HOST_INT_PROCESS_ERROR */
4005 | HOST_INT_SCAN_COMPLETE
4006 /* | HOST_INT_FCS_THRESHOLD */
4007 /* | HOST_INT_UNKNOWN */
4009 adev
->irq_mask_off
= (u16
) ~ (HOST_INT_UNKNOWN
); /* 0x7fff */
4014 /***********************************************************************
4016 int acx100pci_s_set_tx_level(acx_device_t
* adev
, u8 level_dbm
)
4018 /* since it can be assumed that at least the Maxim radio has a
4019 * maximum power output of 20dBm and since it also can be
4020 * assumed that these values drive the DAC responsible for
4021 * setting the linear Tx level, I'd guess that these values
4022 * should be the corresponding linear values for a dBm value,
4023 * in other words: calculate the values from that formula:
4024 * Y [dBm] = 10 * log (X [mW])
4025 * then scale the 0..63 value range onto the 1..100mW range (0..20 dBm)
4026 * and you're done...
4027 * Hopefully that's ok, but you never know if we're actually
4028 * right... (especially since Windows XP doesn't seem to show
4029 * actual Tx dBm values :-P) */
4031 /* NOTE: on Maxim, value 30 IS 30mW, and value 10 IS 10mW - so the
4032 * values are EXACTLY mW!!! Not sure about RFMD and others,
4034 static const u8 dbm2val_maxim
[21] = {
4042 static const u8 dbm2val_rfmd
[21] = {
4052 switch (adev
->radio_type
) {
4053 case RADIO_MAXIM_0D
:
4054 table
= &dbm2val_maxim
[0];
4057 case RADIO_RALINK_15
:
4058 table
= &dbm2val_rfmd
[0];
4061 printk("%s: unknown/unsupported radio type, "
4062 "cannot modify tx power level yet!\n", wiphy_name(adev
->ieee
->wiphy
));
4065 printk("%s: changing radio power level to %u dBm (%u)\n",
4066 wiphy_name(adev
->ieee
->wiphy
), level_dbm
, table
[level_dbm
]);
4067 acxpci_s_write_phy_reg(adev
, 0x11, table
[level_dbm
]);
4072 struct vlynq_reg_config
{
4077 struct vlynq_known
{
4080 struct vlynq_mapping rx_mapping
[4];
4084 struct vlynq_reg_config regs
[10];
4087 #define CHIP_TNETW1130 0x00000009
4088 #define CHIP_TNETW1350 0x00000029
4090 static struct vlynq_known known_devices
[] = {
4092 .chip_id
= CHIP_TNETW1130
, .name
= "TI TNETW1130",
4094 { .size
= 0x22000, .offset
= 0xf0000000 },
4095 { .size
= 0x40000, .offset
= 0xc0000000 },
4096 { .size
= 0x0, .offset
= 0x0 },
4097 { .size
= 0x0, .offset
= 0x0 },
4100 .irq_type
= IRQ_TYPE_EDGE_RISING
,
4105 .value
= (0xd0000000 - PHYS_OFFSET
)
4109 .value
= (0xd0000000 - PHYS_OFFSET
)
4111 { .offset
= 0x740, .value
= 0 },
4112 { .offset
= 0x744, .value
= 0x00010000 },
4113 { .offset
= 0x764, .value
= 0x00010000 },
4117 .chip_id
= CHIP_TNETW1350
, .name
= "TI TNETW1350",
4119 { .size
= 0x100000, .offset
= 0x00300000 },
4120 { .size
= 0x80000, .offset
= 0x00000000 },
4121 { .size
= 0x0, .offset
= 0x0 },
4122 { .size
= 0x0, .offset
= 0x0 },
4125 .irq_type
= IRQ_TYPE_EDGE_RISING
,
4130 .value
= (0x60000000 - PHYS_OFFSET
)
4134 .value
= (0x60000000 - PHYS_OFFSET
)
4136 { .offset
= 0x740, .value
= 0 },
4137 { .offset
= 0x744, .value
= 0x00010000 },
4138 { .offset
= 0x764, .value
= 0x00010000 },
4143 static struct vlynq_device_id acx_vlynq_id
[] = {
4144 { CHIP_TNETW1130
, vlynq_div_auto
, 0 },
4145 { CHIP_TNETW1350
, vlynq_div_auto
, 1 },
4149 static __devinit
int vlynq_probe(struct vlynq_device
*vdev
,
4150 struct vlynq_device_id
*id
)
4152 int result
= -EIO
, i
;
4154 struct ieee80211_hw
*ieee
;
4155 acx_device_t
*adev
= NULL
;
4156 acx111_ie_configoption_t co
;
4157 struct vlynq_mapping mapping
[4] = { { 0, }, };
4158 struct vlynq_known
*match
= NULL
;
4161 result
= vlynq_enable_device(vdev
);
4165 match
= &known_devices
[id
->driver_data
];
4172 mapping
[0].offset
= ARCH_PFN_OFFSET
<< PAGE_SHIFT
;
4173 mapping
[0].size
= 0x02000000;
4174 vlynq_set_local_mapping(vdev
, vdev
->mem_start
, mapping
);
4175 vlynq_set_remote_mapping(vdev
, 0, match
->rx_mapping
);
4177 set_irq_type(vlynq_virq_to_irq(vdev
, match
->irq
), match
->irq_type
);
4179 addr
= (u32
)ioremap(vdev
->mem_start
, 0x1000);
4181 printk(KERN_ERR
"%s: failed to remap io memory\n",
4187 for (i
= 0; i
< match
->num_regs
; i
++)
4188 iowrite32(match
->regs
[i
].value
,
4189 (u32
*)(addr
+ match
->regs
[i
].offset
));
4191 iounmap((void *)addr
);
4193 ieee
= ieee80211_alloc_hw(sizeof(struct acx_device
), &acxpci_hw_ops
);
4195 printk("acx: could not allocate ieee80211 structure %s\n",
4197 goto fail_alloc_netdev
;
4199 ieee
->flags
&= ~IEEE80211_HW_RX_INCLUDES_FCS
;
4202 adev
= ieee2adev(ieee
);
4204 memset(adev
, 0, sizeof(*adev
));
4205 /** Set up our private interface **/
4206 spin_lock_init(&adev
->spinlock
); /* initial state: unlocked */
4207 /* We do not start with downed sem: we want PARANOID_LOCKING to work */
4208 mutex_init(&adev
->mutex
);
4209 /* since nobody can see new netdev yet, we can as well
4210 ** just _presume_ that we're under sem (instead of actually taking it): */
4211 /* acx_sem_lock(adev); */
4214 adev
->bus_dev
= &vdev
->dev
;
4215 adev
->dev_type
= DEVTYPE_PCI
;
4217 /** Finished with private interface **/
4219 vlynq_set_drvdata(vdev
, ieee
);
4220 if (!request_mem_region(vdev
->mem_start
, vdev
->mem_end
- vdev
->mem_start
, "acx")) {
4221 printk("acx: cannot reserve VLYNQ memory region\n");
4222 goto fail_request_mem_region
;
4224 adev
->iobase
= ioremap(vdev
->mem_start
, vdev
->mem_end
- vdev
->mem_start
);
4225 if (!adev
->iobase
) {
4226 printk("acx: ioremap() FAILED\n");
4229 adev
->iobase2
= adev
->iobase
+ match
->rx_mapping
[0].size
;
4230 adev
->chip_type
= CHIPTYPE_ACX111
;
4231 adev
->chip_name
= match
->name
;
4232 adev
->io
= IO_ACX111
;
4233 adev
->irq
= vlynq_virq_to_irq(vdev
, match
->irq
);
4235 printk("acx: found %s-based wireless network card at %s, irq:%d, "
4236 "phymem:0x%x, mem:0x%p\n",
4237 match
->name
, vdev
->dev
.bus_id
, adev
->irq
,
4238 vdev
->mem_start
, adev
->iobase
);
4239 log(L_ANY
, "initial debug setting is 0x%04X\n", acx_debug
);
4241 if (0 == adev
->irq
) {
4242 printk("acx: can't use IRQ 0\n");
4245 SET_IEEE80211_DEV(ieee
, &vdev
->dev
);
4248 /* to find crashes due to weird driver access
4249 * to unconfigured interface (ifup) */
4250 adev
->mgmt_timer
.function
= (void (*)(unsigned long))0x0000dead;
4253 /* ok, pci setup is finished, now start initializing the card */
4255 /* NB: read_reg() reads may return bogus data before reset_dev(),
4256 * since the firmware which directly controls large parts of the I/O
4257 * registers isn't initialized yet.
4258 * acx100 seems to be more affected than acx111 */
4259 if (OK
!= acxpci_s_reset_dev(adev
))
4262 if (OK
!= acx_s_init_mac(adev
))
4265 acx_s_interrogate(adev
, &co
, ACX111_IE_CONFIG_OPTIONS
);
4266 /* TODO: merge them into one function, they are called just once and are the same for pci & usb */
4267 if (OK
!= acxpci_read_eeprom_byte(adev
, 0x05, &adev
->eeprom_version
))
4268 goto fail_read_eeprom_version
;
4270 acx_s_parse_configoption(adev
, &co
);
4271 acx_s_set_defaults(adev
);
4272 acx_s_get_firmware_version(adev
); /* needs to be after acx_s_init_mac() */
4273 acx_display_hardware_details(adev
);
4275 /* Register the card, AFTER everything else has been set up,
4276 * since otherwise an ioctl could step on our feet due to
4277 * firmware operations happening in parallel or uninitialized data */
4280 acx_proc_register_entries(ieee
);
4282 /* Now we have our device, so make sure the kernel doesn't try
4283 * to send packets even though we're not associated to a network yet */
4285 /* after register_netdev() userspace may start working with dev
4286 * (in particular, on other CPUs), we only need to up the sem */
4287 /* acx_sem_unlock(adev); */
4289 printk("acx " ACX_RELEASE
": net device %s, driver compiled "
4290 "against wireless extensions %d and Linux %s\n",
4291 wiphy_name(adev
->ieee
->wiphy
), WIRELESS_EXT
, UTS_RELEASE
);
4293 MAC_COPY(adev
->ieee
->wiphy
->perm_addr
, adev
->dev_addr
);
4295 log(L_IRQ
| L_INIT
, "using IRQ %d\n", adev
->irq
);
4297 /** done with board specific setup **/
4299 err
= acx_setup_modes(adev
);
4301 printk("can't register hwmode\n");
4302 goto fail_register_netdev
;
4305 acx_init_task_scheduler(adev
);
4306 result
= ieee80211_register_hw(adev
->ieee
);
4308 printk("acx: ieee80211_register_hw() FAILED: %d\n", result
);
4309 goto fail_register_netdev
;
4312 great_inquisitor(adev
);
4318 /* error paths: undo everything in reverse order... */
4321 acxpci_s_delete_dma_regions(adev
);
4324 fail_read_eeprom_version
:
4330 iounmap(adev
->iobase
);
4333 release_mem_region(vdev
->mem_start
, vdev
->mem_end
- vdev
->mem_start
);
4334 fail_request_mem_region
:
4335 fail_register_netdev
:
4336 ieee80211_free_hw(ieee
);
4338 vlynq_disable_device(vdev
);
4344 static void vlynq_remove(struct vlynq_device
*vdev
)
4346 struct ieee80211_hw
*hw
= vlynq_get_drvdata(vdev
);
4347 acx_device_t
*adev
= ieee2adev(hw
);
4348 unsigned long flags
;
4352 log(L_DEBUG
, "%s: card is unused. Skipping any release code\n",
4358 acx_lock(adev
, flags
);
4359 acx_unlock(adev
, flags
);
4360 adev
->initialized
= 0;
4362 /* If device wasn't hot unplugged... */
4363 if (adev_present(adev
)) {
4367 /* disable both Tx and Rx to shut radio down properly */
4368 if (adev
->initialized
) {
4369 acx_s_issue_cmd(adev
, ACX1xx_CMD_DISABLE_TX
, NULL
, 0);
4370 acx_s_issue_cmd(adev
, ACX1xx_CMD_DISABLE_RX
, NULL
, 0);
4372 acx_lock(adev
, flags
);
4373 /* disable power LED to save power :-) */
4374 log(L_INIT
, "switching off power LED to save power\n");
4375 acxpci_l_power_led(adev
, 0);
4377 acx_unlock(adev
, flags
);
4379 acx_sem_unlock(adev
);
4382 /* unregister the device to not let the kernel
4383 * (e.g. ioctls) access a half-deconfigured device
4384 * NB: this will cause acxpci_e_close() to be called,
4385 * thus we shouldn't call it under sem!
4386 * Well, netdev did, but ieee80211 stack does not, so we
4387 * have to do so manually...
4390 log(L_INIT
, "removing device %s\n", wiphy_name(adev
->ieee
->wiphy
));
4391 ieee80211_unregister_hw(adev
->ieee
);
4393 /* unregister_netdev ensures that no references to us left.
4394 * For paranoid reasons we continue to follow the rules */
4397 if (adev
->dev_state_mask
& ACX_STATE_IFACE_UP
) {
4399 CLEAR_BIT(adev
->dev_state_mask
, ACX_STATE_IFACE_UP
);
4402 acx_proc_unregister_entries(adev
->ieee
);
4404 /* finally, clean up PCI bus state */
4405 acxpci_s_delete_dma_regions(adev
);
4407 iounmap(adev
->iobase
);
4409 iounmap(adev
->iobase2
);
4410 release_mem_region(vdev
->mem_start
, vdev
->mem_end
- vdev
->mem_start
);
4412 /* remove dev registration */
4414 acx_sem_unlock(adev
);
4415 vlynq_disable_device(vdev
);
4417 /* Free netdev (quite late,
4418 * since otherwise we might get caught off-guard
4419 * by a netdev timeout handler execution
4420 * expecting to see a working dev...) */
4421 ieee80211_free_hw(adev
->ieee
);
4427 static struct vlynq_driver vlynq_acx
= {
4428 .name
= "acx_vlynq",
4429 .id_table
= acx_vlynq_id
,
4430 .probe
= vlynq_probe
,
4431 .remove
= __devexit_p(vlynq_remove
),
4433 #endif /* CONFIG_VLYNQ */
4436 /***********************************************************************
4437 ** Data for init_module/cleanup_module
4440 static const struct pci_device_id acxpci_id_tbl
[] __devinitdata
= {
4442 .vendor
= PCI_VENDOR_ID_TI
,
4443 .device
= PCI_DEVICE_ID_TI_TNETW1100A
,
4444 .subvendor
= PCI_ANY_ID
,
4445 .subdevice
= PCI_ANY_ID
,
4446 .driver_data
= CHIPTYPE_ACX100
,
4449 .vendor
= PCI_VENDOR_ID_TI
,
4450 .device
= PCI_DEVICE_ID_TI_TNETW1100B
,
4451 .subvendor
= PCI_ANY_ID
,
4452 .subdevice
= PCI_ANY_ID
,
4453 .driver_data
= CHIPTYPE_ACX100
,
4456 .vendor
= PCI_VENDOR_ID_TI
,
4457 .device
= PCI_DEVICE_ID_TI_TNETW1130
,
4458 .subvendor
= PCI_ANY_ID
,
4459 .subdevice
= PCI_ANY_ID
,
4460 .driver_data
= CHIPTYPE_ACX111
,
4471 MODULE_DEVICE_TABLE(pci
, acxpci_id_tbl
);
4473 static struct pci_driver
4476 .id_table
= acxpci_id_tbl
,
4477 .probe
= acxpci_e_probe
,
4478 .remove
= __devexit_p(acxpci_e_remove
),
4480 .suspend
= acxpci_e_suspend
,
4481 .resume
= acxpci_e_resume
4482 #endif /* CONFIG_PM */
4484 #endif /* CONFIG_PCI */
4486 /***********************************************************************
4487 ** acxpci_e_init_module
4489 ** Module initialization routine, called once at module load time
4491 int __init
acxpci_e_init_module(void)
4497 #if (ACX_IO_WIDTH==32)
4498 printk("acx: compiled to use 32bit I/O access. "
4499 "I/O timing issues might occur, such as "
4500 "non-working firmware upload. Report them\n");
4502 printk("acx: compiled to use 16bit I/O access only "
4503 "(compatibility mode)\n");
4506 #ifdef __LITTLE_ENDIAN
4507 #define ENDIANNESS_STRING "running on a little-endian CPU\n"
4509 #define ENDIANNESS_STRING "running on a BIG-ENDIAN CPU\n"
4512 "acx: " ENDIANNESS_STRING
4513 "acx: PCI/VLYNQ module " ACX_RELEASE
" initialized, "
4514 "waiting for cards to probe...\n");
4517 res
= pci_register_driver(&acxpci_drv_id
);
4519 res
= vlynq_register_driver(&vlynq_acx
);
4526 /***********************************************************************
4527 ** acxpci_e_cleanup_module
4529 ** Called at module unload time. This is our last chance to
4530 ** clean up after ourselves.
4532 void __exit
acxpci_e_cleanup_module(void)
4537 pci_unregister_driver(&acxpci_drv_id
);
4539 vlynq_unregister_driver(&vlynq_acx
);
4542 "acx: PCI module " ACX_RELEASE
" unloaded\n");