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) },
49 MODULE_DEVICE_TABLE(pci
, p54p_table
);
51 static int p54p_upload_firmware(struct ieee80211_hw
*dev
)
53 struct p54p_priv
*priv
= dev
->priv
;
57 u32 remains
, left
, device_addr
;
59 P54P_WRITE(int_enable
, cpu_to_le32(0));
60 P54P_READ(int_enable
);
63 reg
= P54P_READ(ctrl_stat
);
64 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
65 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT
);
66 P54P_WRITE(ctrl_stat
, reg
);
70 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
71 P54P_WRITE(ctrl_stat
, reg
);
75 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
76 P54P_WRITE(ctrl_stat
, reg
);
79 /* wait for the firmware to reset properly */
82 err
= p54_parse_firmware(dev
, priv
->firmware
);
86 if (priv
->common
.fw_interface
!= FW_LM86
) {
87 dev_err(&priv
->pdev
->dev
, "wrong firmware, "
88 "please get a LM86(PCI) firmware a try again.\n");
92 data
= (__le32
*) priv
->firmware
->data
;
93 remains
= priv
->firmware
->size
;
94 device_addr
= ISL38XX_DEV_FIRMWARE_ADDR
;
97 left
= min((u32
)0x1000, remains
);
98 P54P_WRITE(direct_mem_base
, cpu_to_le32(device_addr
));
99 P54P_READ(int_enable
);
101 device_addr
+= 0x1000;
103 P54P_WRITE(direct_mem_win
[i
], *data
++);
108 P54P_READ(int_enable
);
111 reg
= P54P_READ(ctrl_stat
);
112 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
113 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
114 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT
);
115 P54P_WRITE(ctrl_stat
, reg
);
116 P54P_READ(ctrl_stat
);
119 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
120 P54P_WRITE(ctrl_stat
, reg
);
124 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
125 P54P_WRITE(ctrl_stat
, reg
);
129 /* wait for the firmware to boot properly */
135 static void p54p_refill_rx_ring(struct ieee80211_hw
*dev
,
136 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
137 struct sk_buff
**rx_buf
, u32 index
)
139 struct p54p_priv
*priv
= dev
->priv
;
140 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
143 idx
= le32_to_cpu(ring_control
->host_idx
[ring_index
]);
146 limit
= ring_limit
- limit
;
148 i
= idx
% ring_limit
;
149 while (limit
-- > 1) {
150 struct p54p_desc
*desc
= &ring
[i
];
152 if (!desc
->host_addr
) {
155 skb
= dev_alloc_skb(priv
->common
.rx_mtu
+ 32);
159 mapping
= pci_map_single(priv
->pdev
,
160 skb_tail_pointer(skb
),
161 priv
->common
.rx_mtu
+ 32,
164 if (pci_dma_mapping_error(priv
->pdev
, mapping
)) {
165 dev_kfree_skb_any(skb
);
166 dev_err(&priv
->pdev
->dev
,
167 "RX DMA Mapping error\n");
171 desc
->host_addr
= cpu_to_le32(mapping
);
172 desc
->device_addr
= 0;
173 desc
->len
= cpu_to_le16(priv
->common
.rx_mtu
+ 32);
184 ring_control
->host_idx
[ring_index
] = cpu_to_le32(idx
);
187 static void p54p_check_rx_ring(struct ieee80211_hw
*dev
, u32
*index
,
188 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
189 struct sk_buff
**rx_buf
)
191 struct p54p_priv
*priv
= dev
->priv
;
192 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
193 struct p54p_desc
*desc
;
196 i
= (*index
) % ring_limit
;
197 (*index
) = idx
= le32_to_cpu(ring_control
->device_idx
[ring_index
]);
203 len
= le16_to_cpu(desc
->len
);
212 if (unlikely(len
> priv
->common
.rx_mtu
)) {
214 dev_err(&priv
->pdev
->dev
, "rx'd frame size "
215 "exceeds length threshold.\n");
217 len
= priv
->common
.rx_mtu
;
221 if (p54_rx(dev
, skb
)) {
222 pci_unmap_single(priv
->pdev
,
223 le32_to_cpu(desc
->host_addr
),
224 priv
->common
.rx_mtu
+ 32,
230 desc
->len
= cpu_to_le16(priv
->common
.rx_mtu
+ 32);
237 p54p_refill_rx_ring(dev
, ring_index
, ring
, ring_limit
, rx_buf
, *index
);
240 static void p54p_check_tx_ring(struct ieee80211_hw
*dev
, u32
*index
,
241 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
242 struct sk_buff
**tx_buf
)
244 struct p54p_priv
*priv
= dev
->priv
;
245 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
246 struct p54p_desc
*desc
;
250 i
= (*index
) % ring_limit
;
251 (*index
) = idx
= le32_to_cpu(ring_control
->device_idx
[ring_index
]);
260 pci_unmap_single(priv
->pdev
, le32_to_cpu(desc
->host_addr
),
261 le16_to_cpu(desc
->len
), PCI_DMA_TODEVICE
);
264 desc
->device_addr
= 0;
268 if (skb
&& FREE_AFTER_TX(skb
))
269 p54_free_skb(dev
, skb
);
276 static void p54p_tasklet(unsigned long dev_id
)
278 struct ieee80211_hw
*dev
= (struct ieee80211_hw
*)dev_id
;
279 struct p54p_priv
*priv
= dev
->priv
;
280 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
282 p54p_check_tx_ring(dev
, &priv
->tx_idx_mgmt
, 3, ring_control
->tx_mgmt
,
283 ARRAY_SIZE(ring_control
->tx_mgmt
),
286 p54p_check_tx_ring(dev
, &priv
->tx_idx_data
, 1, ring_control
->tx_data
,
287 ARRAY_SIZE(ring_control
->tx_data
),
290 p54p_check_rx_ring(dev
, &priv
->rx_idx_mgmt
, 2, ring_control
->rx_mgmt
,
291 ARRAY_SIZE(ring_control
->rx_mgmt
), priv
->rx_buf_mgmt
);
293 p54p_check_rx_ring(dev
, &priv
->rx_idx_data
, 0, ring_control
->rx_data
,
294 ARRAY_SIZE(ring_control
->rx_data
), priv
->rx_buf_data
);
297 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
300 static irqreturn_t
p54p_interrupt(int irq
, void *dev_id
)
302 struct ieee80211_hw
*dev
= dev_id
;
303 struct p54p_priv
*priv
= dev
->priv
;
306 reg
= P54P_READ(int_ident
);
307 if (unlikely(reg
== cpu_to_le32(0xFFFFFFFF))) {
310 P54P_WRITE(int_ack
, reg
);
312 reg
&= P54P_READ(int_enable
);
314 if (reg
& cpu_to_le32(ISL38XX_INT_IDENT_UPDATE
))
315 tasklet_schedule(&priv
->tasklet
);
316 else if (reg
& cpu_to_le32(ISL38XX_INT_IDENT_INIT
))
317 complete(&priv
->boot_comp
);
320 return reg
? IRQ_HANDLED
: IRQ_NONE
;
323 static void p54p_tx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
326 struct p54p_priv
*priv
= dev
->priv
;
327 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
328 struct p54p_desc
*desc
;
330 u32 device_idx
, idx
, i
;
332 spin_lock_irqsave(&priv
->lock
, flags
);
333 device_idx
= le32_to_cpu(ring_control
->device_idx
[1]);
334 idx
= le32_to_cpu(ring_control
->host_idx
[1]);
335 i
= idx
% ARRAY_SIZE(ring_control
->tx_data
);
337 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
,
339 if (pci_dma_mapping_error(priv
->pdev
, mapping
)) {
340 spin_unlock_irqrestore(&priv
->lock
, flags
);
341 p54_free_skb(dev
, skb
);
342 dev_err(&priv
->pdev
->dev
, "TX DMA mapping error\n");
345 priv
->tx_buf_data
[i
] = skb
;
347 desc
= &ring_control
->tx_data
[i
];
348 desc
->host_addr
= cpu_to_le32(mapping
);
349 desc
->device_addr
= ((struct p54_hdr
*)skb
->data
)->req_id
;
350 desc
->len
= cpu_to_le16(skb
->len
);
354 ring_control
->host_idx
[1] = cpu_to_le32(idx
+ 1);
355 spin_unlock_irqrestore(&priv
->lock
, flags
);
357 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
361 static void p54p_stop(struct ieee80211_hw
*dev
)
363 struct p54p_priv
*priv
= dev
->priv
;
364 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
366 struct p54p_desc
*desc
;
368 P54P_WRITE(int_enable
, cpu_to_le32(0));
369 P54P_READ(int_enable
);
372 free_irq(priv
->pdev
->irq
, dev
);
374 tasklet_kill(&priv
->tasklet
);
376 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_RESET
));
378 for (i
= 0; i
< ARRAY_SIZE(priv
->rx_buf_data
); i
++) {
379 desc
= &ring_control
->rx_data
[i
];
381 pci_unmap_single(priv
->pdev
,
382 le32_to_cpu(desc
->host_addr
),
383 priv
->common
.rx_mtu
+ 32,
385 kfree_skb(priv
->rx_buf_data
[i
]);
386 priv
->rx_buf_data
[i
] = NULL
;
389 for (i
= 0; i
< ARRAY_SIZE(priv
->rx_buf_mgmt
); i
++) {
390 desc
= &ring_control
->rx_mgmt
[i
];
392 pci_unmap_single(priv
->pdev
,
393 le32_to_cpu(desc
->host_addr
),
394 priv
->common
.rx_mtu
+ 32,
396 kfree_skb(priv
->rx_buf_mgmt
[i
]);
397 priv
->rx_buf_mgmt
[i
] = NULL
;
400 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_buf_data
); i
++) {
401 desc
= &ring_control
->tx_data
[i
];
403 pci_unmap_single(priv
->pdev
,
404 le32_to_cpu(desc
->host_addr
),
405 le16_to_cpu(desc
->len
),
408 p54_free_skb(dev
, priv
->tx_buf_data
[i
]);
409 priv
->tx_buf_data
[i
] = NULL
;
412 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_buf_mgmt
); i
++) {
413 desc
= &ring_control
->tx_mgmt
[i
];
415 pci_unmap_single(priv
->pdev
,
416 le32_to_cpu(desc
->host_addr
),
417 le16_to_cpu(desc
->len
),
420 p54_free_skb(dev
, priv
->tx_buf_mgmt
[i
]);
421 priv
->tx_buf_mgmt
[i
] = NULL
;
424 memset(ring_control
, 0, sizeof(*ring_control
));
427 static int p54p_open(struct ieee80211_hw
*dev
)
429 struct p54p_priv
*priv
= dev
->priv
;
432 init_completion(&priv
->boot_comp
);
433 err
= request_irq(priv
->pdev
->irq
, p54p_interrupt
,
434 IRQF_SHARED
, "p54pci", dev
);
436 dev_err(&priv
->pdev
->dev
, "failed to register IRQ handler\n");
440 memset(priv
->ring_control
, 0, sizeof(*priv
->ring_control
));
441 err
= p54p_upload_firmware(dev
);
443 free_irq(priv
->pdev
->irq
, dev
);
446 priv
->rx_idx_data
= priv
->tx_idx_data
= 0;
447 priv
->rx_idx_mgmt
= priv
->tx_idx_mgmt
= 0;
449 p54p_refill_rx_ring(dev
, 0, priv
->ring_control
->rx_data
,
450 ARRAY_SIZE(priv
->ring_control
->rx_data
), priv
->rx_buf_data
, 0);
452 p54p_refill_rx_ring(dev
, 2, priv
->ring_control
->rx_mgmt
,
453 ARRAY_SIZE(priv
->ring_control
->rx_mgmt
), priv
->rx_buf_mgmt
, 0);
455 P54P_WRITE(ring_control_base
, cpu_to_le32(priv
->ring_control_dma
));
456 P54P_READ(ring_control_base
);
460 P54P_WRITE(int_enable
, cpu_to_le32(ISL38XX_INT_IDENT_INIT
));
461 P54P_READ(int_enable
);
465 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_RESET
));
468 if (!wait_for_completion_interruptible_timeout(&priv
->boot_comp
, HZ
)) {
469 wiphy_err(dev
->wiphy
, "Cannot boot firmware!\n");
474 P54P_WRITE(int_enable
, cpu_to_le32(ISL38XX_INT_IDENT_UPDATE
));
475 P54P_READ(int_enable
);
479 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
487 static int __devinit
p54p_probe(struct pci_dev
*pdev
,
488 const struct pci_device_id
*id
)
490 struct p54p_priv
*priv
;
491 struct ieee80211_hw
*dev
;
492 unsigned long mem_addr
, mem_len
;
495 err
= pci_enable_device(pdev
);
497 dev_err(&pdev
->dev
, "Cannot enable new PCI device\n");
501 mem_addr
= pci_resource_start(pdev
, 0);
502 mem_len
= pci_resource_len(pdev
, 0);
503 if (mem_len
< sizeof(struct p54p_csr
)) {
504 dev_err(&pdev
->dev
, "Too short PCI resources\n");
505 goto err_disable_dev
;
508 err
= pci_request_regions(pdev
, "p54pci");
510 dev_err(&pdev
->dev
, "Cannot obtain PCI resources\n");
511 goto err_disable_dev
;
514 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32)) ||
515 pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32))) {
516 dev_err(&pdev
->dev
, "No suitable DMA available\n");
520 pci_set_master(pdev
);
521 pci_try_set_mwi(pdev
);
523 pci_write_config_byte(pdev
, 0x40, 0);
524 pci_write_config_byte(pdev
, 0x41, 0);
526 dev
= p54_init_common(sizeof(*priv
));
528 dev_err(&pdev
->dev
, "ieee80211 alloc failed\n");
536 SET_IEEE80211_DEV(dev
, &pdev
->dev
);
537 pci_set_drvdata(pdev
, dev
);
539 priv
->map
= ioremap(mem_addr
, mem_len
);
541 dev_err(&pdev
->dev
, "Cannot map device memory\n");
546 priv
->ring_control
= pci_alloc_consistent(pdev
, sizeof(*priv
->ring_control
),
547 &priv
->ring_control_dma
);
548 if (!priv
->ring_control
) {
549 dev_err(&pdev
->dev
, "Cannot allocate rings\n");
553 priv
->common
.open
= p54p_open
;
554 priv
->common
.stop
= p54p_stop
;
555 priv
->common
.tx
= p54p_tx
;
557 spin_lock_init(&priv
->lock
);
558 tasklet_init(&priv
->tasklet
, p54p_tasklet
, (unsigned long)dev
);
560 err
= request_firmware(&priv
->firmware
, "isl3886pci",
563 dev_err(&pdev
->dev
, "Cannot find firmware (isl3886pci)\n");
564 err
= request_firmware(&priv
->firmware
, "isl3886",
567 goto err_free_common
;
570 err
= p54p_open(dev
);
572 goto err_free_common
;
573 err
= p54_read_eeprom(dev
);
576 goto err_free_common
;
578 err
= p54_register_common(dev
, &pdev
->dev
);
580 goto err_free_common
;
585 release_firmware(priv
->firmware
);
586 pci_free_consistent(pdev
, sizeof(*priv
->ring_control
),
587 priv
->ring_control
, priv
->ring_control_dma
);
593 pci_set_drvdata(pdev
, NULL
);
594 p54_free_common(dev
);
597 pci_release_regions(pdev
);
599 pci_disable_device(pdev
);
603 static void __devexit
p54p_remove(struct pci_dev
*pdev
)
605 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
606 struct p54p_priv
*priv
;
611 p54_unregister_common(dev
);
613 release_firmware(priv
->firmware
);
614 pci_free_consistent(pdev
, sizeof(*priv
->ring_control
),
615 priv
->ring_control
, priv
->ring_control_dma
);
617 pci_release_regions(pdev
);
618 pci_disable_device(pdev
);
619 p54_free_common(dev
);
623 static int p54p_suspend(struct pci_dev
*pdev
, pm_message_t state
)
625 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
626 struct p54p_priv
*priv
= dev
->priv
;
628 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
) {
629 ieee80211_stop_queues(dev
);
633 pci_save_state(pdev
);
634 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
638 static int p54p_resume(struct pci_dev
*pdev
)
640 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
641 struct p54p_priv
*priv
= dev
->priv
;
643 pci_set_power_state(pdev
, PCI_D0
);
644 pci_restore_state(pdev
);
646 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
) {
648 ieee80211_wake_queues(dev
);
653 #endif /* CONFIG_PM */
655 static struct pci_driver p54p_driver
= {
657 .id_table
= p54p_table
,
659 .remove
= __devexit_p(p54p_remove
),
661 .suspend
= p54p_suspend
,
662 .resume
= p54p_resume
,
663 #endif /* CONFIG_PM */
666 static int __init
p54p_init(void)
668 return pci_register_driver(&p54p_driver
);
671 static void __exit
p54p_exit(void)
673 pci_unregister_driver(&p54p_driver
);
676 module_init(p54p_init
);
677 module_exit(p54p_exit
);