3 * Linux device driver for PCI based Prism54
5 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
6 * Copyright (c) 2008, Christian Lamparter <chunkeey@web.de>
8 * Based on the islsm (softmac prism54) driver, which is:
9 * Copyright 2004-2006 Jean-Baptiste Note <jean-baptiste.note@m4x.org>, et al.
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 #include <linux/init.h>
17 #include <linux/pci.h>
18 #include <linux/slab.h>
19 #include <linux/firmware.h>
20 #include <linux/etherdevice.h>
21 #include <linux/delay.h>
22 #include <linux/completion.h>
23 #include <net/mac80211.h>
29 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
30 MODULE_DESCRIPTION("Prism54 PCI wireless driver");
31 MODULE_LICENSE("GPL");
32 MODULE_ALIAS("prism54pci");
33 MODULE_FIRMWARE("isl3886pci");
35 static DEFINE_PCI_DEVICE_TABLE(p54p_table
) = {
36 /* Intersil PRISM Duette/Prism GT Wireless LAN adapter */
37 { PCI_DEVICE(0x1260, 0x3890) },
38 /* 3COM 3CRWE154G72 Wireless LAN adapter */
39 { PCI_DEVICE(0x10b7, 0x6001) },
40 /* Intersil PRISM Indigo Wireless LAN adapter */
41 { PCI_DEVICE(0x1260, 0x3877) },
42 /* Intersil PRISM Javelin/Xbow Wireless LAN adapter */
43 { PCI_DEVICE(0x1260, 0x3886) },
44 /* Intersil PRISM Xbow Wireless LAN adapter (Symbol AP-300) */
45 { PCI_DEVICE(0x1260, 0xffff) },
46 /* Standard Microsystems Corp SMC2802W Wireless PCI */
47 { PCI_DEVICE(0x10b8, 0x2802) },
51 MODULE_DEVICE_TABLE(pci
, p54p_table
);
53 static int p54p_upload_firmware(struct ieee80211_hw
*dev
)
55 struct p54p_priv
*priv
= dev
->priv
;
59 u32 remains
, left
, device_addr
;
61 P54P_WRITE(int_enable
, cpu_to_le32(0));
62 P54P_READ(int_enable
);
65 reg
= P54P_READ(ctrl_stat
);
66 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
67 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT
);
68 P54P_WRITE(ctrl_stat
, reg
);
72 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
73 P54P_WRITE(ctrl_stat
, reg
);
77 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
78 P54P_WRITE(ctrl_stat
, reg
);
81 /* wait for the firmware to reset properly */
84 err
= p54_parse_firmware(dev
, priv
->firmware
);
88 if (priv
->common
.fw_interface
!= FW_LM86
) {
89 dev_err(&priv
->pdev
->dev
, "wrong firmware, "
90 "please get a LM86(PCI) firmware a try again.\n");
94 data
= (__le32
*) priv
->firmware
->data
;
95 remains
= priv
->firmware
->size
;
96 device_addr
= ISL38XX_DEV_FIRMWARE_ADDR
;
99 left
= min((u32
)0x1000, remains
);
100 P54P_WRITE(direct_mem_base
, cpu_to_le32(device_addr
));
101 P54P_READ(int_enable
);
103 device_addr
+= 0x1000;
105 P54P_WRITE(direct_mem_win
[i
], *data
++);
110 P54P_READ(int_enable
);
113 reg
= P54P_READ(ctrl_stat
);
114 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
115 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
116 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT
);
117 P54P_WRITE(ctrl_stat
, reg
);
118 P54P_READ(ctrl_stat
);
121 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
122 P54P_WRITE(ctrl_stat
, reg
);
126 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
127 P54P_WRITE(ctrl_stat
, reg
);
131 /* wait for the firmware to boot properly */
137 static void p54p_refill_rx_ring(struct ieee80211_hw
*dev
,
138 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
139 struct sk_buff
**rx_buf
, u32 index
)
141 struct p54p_priv
*priv
= dev
->priv
;
142 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
145 idx
= le32_to_cpu(ring_control
->host_idx
[ring_index
]);
148 limit
= ring_limit
- limit
;
150 i
= idx
% ring_limit
;
151 while (limit
-- > 1) {
152 struct p54p_desc
*desc
= &ring
[i
];
154 if (!desc
->host_addr
) {
157 skb
= dev_alloc_skb(priv
->common
.rx_mtu
+ 32);
161 mapping
= pci_map_single(priv
->pdev
,
162 skb_tail_pointer(skb
),
163 priv
->common
.rx_mtu
+ 32,
166 if (pci_dma_mapping_error(priv
->pdev
, mapping
)) {
167 dev_kfree_skb_any(skb
);
168 dev_err(&priv
->pdev
->dev
,
169 "RX DMA Mapping error\n");
173 desc
->host_addr
= cpu_to_le32(mapping
);
174 desc
->device_addr
= 0; // FIXME: necessary?
175 desc
->len
= cpu_to_le16(priv
->common
.rx_mtu
+ 32);
186 ring_control
->host_idx
[ring_index
] = cpu_to_le32(idx
);
189 static void p54p_check_rx_ring(struct ieee80211_hw
*dev
, u32
*index
,
190 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
191 struct sk_buff
**rx_buf
)
193 struct p54p_priv
*priv
= dev
->priv
;
194 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
195 struct p54p_desc
*desc
;
198 i
= (*index
) % ring_limit
;
199 (*index
) = idx
= le32_to_cpu(ring_control
->device_idx
[ring_index
]);
205 len
= le16_to_cpu(desc
->len
);
214 if (unlikely(len
> priv
->common
.rx_mtu
)) {
216 dev_err(&priv
->pdev
->dev
, "rx'd frame size "
217 "exceeds length threshold.\n");
219 len
= priv
->common
.rx_mtu
;
223 if (p54_rx(dev
, skb
)) {
224 pci_unmap_single(priv
->pdev
,
225 le32_to_cpu(desc
->host_addr
),
226 priv
->common
.rx_mtu
+ 32,
232 desc
->len
= cpu_to_le16(priv
->common
.rx_mtu
+ 32);
239 p54p_refill_rx_ring(dev
, ring_index
, ring
, ring_limit
, rx_buf
, *index
);
242 static void p54p_check_tx_ring(struct ieee80211_hw
*dev
, u32
*index
,
243 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
244 struct sk_buff
**tx_buf
)
246 struct p54p_priv
*priv
= dev
->priv
;
247 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
248 struct p54p_desc
*desc
;
252 i
= (*index
) % ring_limit
;
253 (*index
) = idx
= le32_to_cpu(ring_control
->device_idx
[ring_index
]);
262 pci_unmap_single(priv
->pdev
, le32_to_cpu(desc
->host_addr
),
263 le16_to_cpu(desc
->len
), PCI_DMA_TODEVICE
);
266 desc
->device_addr
= 0;
270 if (skb
&& FREE_AFTER_TX(skb
))
271 p54_free_skb(dev
, skb
);
278 static void p54p_tasklet(unsigned long dev_id
)
280 struct ieee80211_hw
*dev
= (struct ieee80211_hw
*)dev_id
;
281 struct p54p_priv
*priv
= dev
->priv
;
282 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
284 p54p_check_tx_ring(dev
, &priv
->tx_idx_mgmt
, 3, ring_control
->tx_mgmt
,
285 ARRAY_SIZE(ring_control
->tx_mgmt
),
288 p54p_check_tx_ring(dev
, &priv
->tx_idx_data
, 1, ring_control
->tx_data
,
289 ARRAY_SIZE(ring_control
->tx_data
),
292 p54p_check_rx_ring(dev
, &priv
->rx_idx_mgmt
, 2, ring_control
->rx_mgmt
,
293 ARRAY_SIZE(ring_control
->rx_mgmt
), priv
->rx_buf_mgmt
);
295 p54p_check_rx_ring(dev
, &priv
->rx_idx_data
, 0, ring_control
->rx_data
,
296 ARRAY_SIZE(ring_control
->rx_data
), priv
->rx_buf_data
);
299 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
302 static irqreturn_t
p54p_interrupt(int irq
, void *dev_id
)
304 struct ieee80211_hw
*dev
= dev_id
;
305 struct p54p_priv
*priv
= dev
->priv
;
308 reg
= P54P_READ(int_ident
);
309 if (unlikely(reg
== cpu_to_le32(0xFFFFFFFF))) {
312 P54P_WRITE(int_ack
, reg
);
314 reg
&= P54P_READ(int_enable
);
316 if (reg
& cpu_to_le32(ISL38XX_INT_IDENT_UPDATE
))
317 tasklet_schedule(&priv
->tasklet
);
318 else if (reg
& cpu_to_le32(ISL38XX_INT_IDENT_INIT
))
319 complete(&priv
->boot_comp
);
322 return reg
? IRQ_HANDLED
: IRQ_NONE
;
325 static void p54p_tx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
328 struct p54p_priv
*priv
= dev
->priv
;
329 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
330 struct p54p_desc
*desc
;
332 u32 device_idx
, idx
, i
;
334 spin_lock_irqsave(&priv
->lock
, flags
);
335 device_idx
= le32_to_cpu(ring_control
->device_idx
[1]);
336 idx
= le32_to_cpu(ring_control
->host_idx
[1]);
337 i
= idx
% ARRAY_SIZE(ring_control
->tx_data
);
339 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
,
341 if (pci_dma_mapping_error(priv
->pdev
, mapping
)) {
342 spin_unlock_irqrestore(&priv
->lock
, flags
);
343 p54_free_skb(dev
, skb
);
344 dev_err(&priv
->pdev
->dev
, "TX DMA mapping error\n");
347 priv
->tx_buf_data
[i
] = skb
;
349 desc
= &ring_control
->tx_data
[i
];
350 desc
->host_addr
= cpu_to_le32(mapping
);
351 desc
->device_addr
= ((struct p54_hdr
*)skb
->data
)->req_id
;
352 desc
->len
= cpu_to_le16(skb
->len
);
356 ring_control
->host_idx
[1] = cpu_to_le32(idx
+ 1);
357 spin_unlock_irqrestore(&priv
->lock
, flags
);
359 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
363 static void p54p_stop(struct ieee80211_hw
*dev
)
365 struct p54p_priv
*priv
= dev
->priv
;
366 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
368 struct p54p_desc
*desc
;
370 P54P_WRITE(int_enable
, cpu_to_le32(0));
371 P54P_READ(int_enable
);
374 free_irq(priv
->pdev
->irq
, dev
);
376 tasklet_kill(&priv
->tasklet
);
378 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_RESET
));
380 for (i
= 0; i
< ARRAY_SIZE(priv
->rx_buf_data
); i
++) {
381 desc
= &ring_control
->rx_data
[i
];
383 pci_unmap_single(priv
->pdev
,
384 le32_to_cpu(desc
->host_addr
),
385 priv
->common
.rx_mtu
+ 32,
387 kfree_skb(priv
->rx_buf_data
[i
]);
388 priv
->rx_buf_data
[i
] = NULL
;
391 for (i
= 0; i
< ARRAY_SIZE(priv
->rx_buf_mgmt
); i
++) {
392 desc
= &ring_control
->rx_mgmt
[i
];
394 pci_unmap_single(priv
->pdev
,
395 le32_to_cpu(desc
->host_addr
),
396 priv
->common
.rx_mtu
+ 32,
398 kfree_skb(priv
->rx_buf_mgmt
[i
]);
399 priv
->rx_buf_mgmt
[i
] = NULL
;
402 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_buf_data
); i
++) {
403 desc
= &ring_control
->tx_data
[i
];
405 pci_unmap_single(priv
->pdev
,
406 le32_to_cpu(desc
->host_addr
),
407 le16_to_cpu(desc
->len
),
410 p54_free_skb(dev
, priv
->tx_buf_data
[i
]);
411 priv
->tx_buf_data
[i
] = NULL
;
414 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_buf_mgmt
); i
++) {
415 desc
= &ring_control
->tx_mgmt
[i
];
417 pci_unmap_single(priv
->pdev
,
418 le32_to_cpu(desc
->host_addr
),
419 le16_to_cpu(desc
->len
),
422 p54_free_skb(dev
, priv
->tx_buf_mgmt
[i
]);
423 priv
->tx_buf_mgmt
[i
] = NULL
;
426 memset(ring_control
, 0, sizeof(*ring_control
));
429 static int p54p_open(struct ieee80211_hw
*dev
)
431 struct p54p_priv
*priv
= dev
->priv
;
434 init_completion(&priv
->boot_comp
);
435 err
= request_irq(priv
->pdev
->irq
, p54p_interrupt
,
436 IRQF_SHARED
, "p54pci", dev
);
438 dev_err(&priv
->pdev
->dev
, "failed to register IRQ handler\n");
442 memset(priv
->ring_control
, 0, sizeof(*priv
->ring_control
));
443 err
= p54p_upload_firmware(dev
);
445 free_irq(priv
->pdev
->irq
, dev
);
448 priv
->rx_idx_data
= priv
->tx_idx_data
= 0;
449 priv
->rx_idx_mgmt
= priv
->tx_idx_mgmt
= 0;
451 p54p_refill_rx_ring(dev
, 0, priv
->ring_control
->rx_data
,
452 ARRAY_SIZE(priv
->ring_control
->rx_data
), priv
->rx_buf_data
, 0);
454 p54p_refill_rx_ring(dev
, 2, priv
->ring_control
->rx_mgmt
,
455 ARRAY_SIZE(priv
->ring_control
->rx_mgmt
), priv
->rx_buf_mgmt
, 0);
457 P54P_WRITE(ring_control_base
, cpu_to_le32(priv
->ring_control_dma
));
458 P54P_READ(ring_control_base
);
462 P54P_WRITE(int_enable
, cpu_to_le32(ISL38XX_INT_IDENT_INIT
));
463 P54P_READ(int_enable
);
467 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_RESET
));
470 if (!wait_for_completion_interruptible_timeout(&priv
->boot_comp
, HZ
)) {
471 wiphy_err(dev
->wiphy
, "cannot boot firmware!\n");
476 P54P_WRITE(int_enable
, cpu_to_le32(ISL38XX_INT_IDENT_UPDATE
));
477 P54P_READ(int_enable
);
481 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
489 static int __devinit
p54p_probe(struct pci_dev
*pdev
,
490 const struct pci_device_id
*id
)
492 struct p54p_priv
*priv
;
493 struct ieee80211_hw
*dev
;
494 unsigned long mem_addr
, mem_len
;
497 err
= pci_enable_device(pdev
);
499 dev_err(&pdev
->dev
, "Cannot enable new PCI device\n");
503 mem_addr
= pci_resource_start(pdev
, 0);
504 mem_len
= pci_resource_len(pdev
, 0);
505 if (mem_len
< sizeof(struct p54p_csr
)) {
506 dev_err(&pdev
->dev
, "Too short PCI resources\n");
507 goto err_disable_dev
;
510 err
= pci_request_regions(pdev
, "p54pci");
512 dev_err(&pdev
->dev
, "Cannot obtain PCI resources\n");
513 goto err_disable_dev
;
516 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32)) ||
517 pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32))) {
518 dev_err(&pdev
->dev
, "No suitable DMA available\n");
522 pci_set_master(pdev
);
523 pci_try_set_mwi(pdev
);
525 pci_write_config_byte(pdev
, 0x40, 0);
526 pci_write_config_byte(pdev
, 0x41, 0);
528 dev
= p54_init_common(sizeof(*priv
));
530 dev_err(&pdev
->dev
, "ieee80211 alloc failed\n");
538 SET_IEEE80211_DEV(dev
, &pdev
->dev
);
539 pci_set_drvdata(pdev
, dev
);
541 priv
->map
= ioremap(mem_addr
, mem_len
);
543 dev_err(&pdev
->dev
, "Cannot map device memory\n");
548 priv
->ring_control
= pci_alloc_consistent(pdev
, sizeof(*priv
->ring_control
),
549 &priv
->ring_control_dma
);
550 if (!priv
->ring_control
) {
551 dev_err(&pdev
->dev
, "Cannot allocate rings\n");
555 priv
->common
.open
= p54p_open
;
556 priv
->common
.stop
= p54p_stop
;
557 priv
->common
.tx
= p54p_tx
;
559 spin_lock_init(&priv
->lock
);
560 tasklet_init(&priv
->tasklet
, p54p_tasklet
, (unsigned long)dev
);
562 err
= request_firmware(&priv
->firmware
, "isl3886pci",
565 dev_err(&pdev
->dev
, "Cannot find firmware (isl3886pci)\n");
566 err
= request_firmware(&priv
->firmware
, "isl3886",
569 goto err_free_common
;
572 err
= p54p_open(dev
);
574 goto err_free_common
;
575 err
= p54_read_eeprom(dev
);
578 goto err_free_common
;
580 err
= p54_register_common(dev
, &pdev
->dev
);
582 goto err_free_common
;
587 release_firmware(priv
->firmware
);
588 pci_free_consistent(pdev
, sizeof(*priv
->ring_control
),
589 priv
->ring_control
, priv
->ring_control_dma
);
595 pci_set_drvdata(pdev
, NULL
);
596 p54_free_common(dev
);
599 pci_release_regions(pdev
);
601 pci_disable_device(pdev
);
605 static void __devexit
p54p_remove(struct pci_dev
*pdev
)
607 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
608 struct p54p_priv
*priv
;
613 p54_unregister_common(dev
);
615 release_firmware(priv
->firmware
);
616 pci_free_consistent(pdev
, sizeof(*priv
->ring_control
),
617 priv
->ring_control
, priv
->ring_control_dma
);
619 pci_release_regions(pdev
);
620 pci_disable_device(pdev
);
621 p54_free_common(dev
);
625 static int p54p_suspend(struct pci_dev
*pdev
, pm_message_t state
)
627 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
628 struct p54p_priv
*priv
= dev
->priv
;
630 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
) {
631 ieee80211_stop_queues(dev
);
635 pci_save_state(pdev
);
636 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
640 static int p54p_resume(struct pci_dev
*pdev
)
642 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
643 struct p54p_priv
*priv
= dev
->priv
;
645 pci_set_power_state(pdev
, PCI_D0
);
646 pci_restore_state(pdev
);
648 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
) {
650 ieee80211_wake_queues(dev
);
655 #endif /* CONFIG_PM */
657 static struct pci_driver p54p_driver
= {
659 .id_table
= p54p_table
,
661 .remove
= __devexit_p(p54p_remove
),
663 .suspend
= p54p_suspend
,
664 .resume
= p54p_resume
,
665 #endif /* CONFIG_PM */
668 static int __init
p54p_init(void)
670 return pci_register_driver(&p54p_driver
);
673 static void __exit
p54p_exit(void)
675 pci_unregister_driver(&p54p_driver
);
678 module_init(p54p_init
);
679 module_exit(p54p_exit
);