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/firmware.h>
19 #include <linux/etherdevice.h>
20 #include <linux/delay.h>
21 #include <linux/completion.h>
22 #include <net/mac80211.h>
27 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
28 MODULE_DESCRIPTION("Prism54 PCI wireless driver");
29 MODULE_LICENSE("GPL");
30 MODULE_ALIAS("prism54pci");
31 MODULE_FIRMWARE("isl3886pci");
33 static struct pci_device_id p54p_table
[] __devinitdata
= {
34 /* Intersil PRISM Duette/Prism GT Wireless LAN adapter */
35 { PCI_DEVICE(0x1260, 0x3890) },
36 /* 3COM 3CRWE154G72 Wireless LAN adapter */
37 { PCI_DEVICE(0x10b7, 0x6001) },
38 /* Intersil PRISM Indigo Wireless LAN adapter */
39 { PCI_DEVICE(0x1260, 0x3877) },
40 /* Intersil PRISM Javelin/Xbow Wireless LAN adapter */
41 { PCI_DEVICE(0x1260, 0x3886) },
45 MODULE_DEVICE_TABLE(pci
, p54p_table
);
47 static int p54p_upload_firmware(struct ieee80211_hw
*dev
)
49 struct p54p_priv
*priv
= dev
->priv
;
53 u32 remains
, left
, device_addr
;
55 P54P_WRITE(int_enable
, cpu_to_le32(0));
56 P54P_READ(int_enable
);
59 reg
= P54P_READ(ctrl_stat
);
60 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
61 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT
);
62 P54P_WRITE(ctrl_stat
, reg
);
66 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
67 P54P_WRITE(ctrl_stat
, reg
);
71 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
72 P54P_WRITE(ctrl_stat
, reg
);
75 /* wait for the firmware to reset properly */
78 err
= p54_parse_firmware(dev
, priv
->firmware
);
82 if (priv
->common
.fw_interface
!= FW_LM86
) {
83 dev_err(&priv
->pdev
->dev
, "wrong firmware, "
84 "please get a LM86(PCI) firmware a try again.\n");
88 data
= (__le32
*) priv
->firmware
->data
;
89 remains
= priv
->firmware
->size
;
90 device_addr
= ISL38XX_DEV_FIRMWARE_ADDR
;
93 left
= min((u32
)0x1000, remains
);
94 P54P_WRITE(direct_mem_base
, cpu_to_le32(device_addr
));
95 P54P_READ(int_enable
);
97 device_addr
+= 0x1000;
99 P54P_WRITE(direct_mem_win
[i
], *data
++);
104 P54P_READ(int_enable
);
107 reg
= P54P_READ(ctrl_stat
);
108 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
109 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
110 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT
);
111 P54P_WRITE(ctrl_stat
, reg
);
112 P54P_READ(ctrl_stat
);
115 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
116 P54P_WRITE(ctrl_stat
, reg
);
120 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
121 P54P_WRITE(ctrl_stat
, reg
);
125 /* wait for the firmware to boot properly */
131 static void p54p_refill_rx_ring(struct ieee80211_hw
*dev
,
132 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
133 struct sk_buff
**rx_buf
)
135 struct p54p_priv
*priv
= dev
->priv
;
136 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
139 idx
= le32_to_cpu(ring_control
->host_idx
[ring_index
]);
141 limit
-= le32_to_cpu(ring_control
->device_idx
[ring_index
]);
142 limit
= ring_limit
- limit
;
144 i
= idx
% ring_limit
;
145 while (limit
-- > 1) {
146 struct p54p_desc
*desc
= &ring
[i
];
148 if (!desc
->host_addr
) {
151 skb
= dev_alloc_skb(priv
->common
.rx_mtu
+ 32);
155 mapping
= pci_map_single(priv
->pdev
,
156 skb_tail_pointer(skb
),
157 priv
->common
.rx_mtu
+ 32,
159 desc
->host_addr
= cpu_to_le32(mapping
);
160 desc
->device_addr
= 0; // FIXME: necessary?
161 desc
->len
= cpu_to_le16(priv
->common
.rx_mtu
+ 32);
172 ring_control
->host_idx
[ring_index
] = cpu_to_le32(idx
);
175 static void p54p_check_rx_ring(struct ieee80211_hw
*dev
, u32
*index
,
176 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
177 struct sk_buff
**rx_buf
)
179 struct p54p_priv
*priv
= dev
->priv
;
180 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
181 struct p54p_desc
*desc
;
184 i
= (*index
) % ring_limit
;
185 (*index
) = idx
= le32_to_cpu(ring_control
->device_idx
[ring_index
]);
191 len
= le16_to_cpu(desc
->len
);
201 if (p54_rx(dev
, skb
)) {
202 pci_unmap_single(priv
->pdev
,
203 le32_to_cpu(desc
->host_addr
),
204 priv
->common
.rx_mtu
+ 32,
210 desc
->len
= cpu_to_le16(priv
->common
.rx_mtu
+ 32);
217 p54p_refill_rx_ring(dev
, ring_index
, ring
, ring_limit
, rx_buf
);
220 /* caller must hold priv->lock */
221 static void p54p_check_tx_ring(struct ieee80211_hw
*dev
, u32
*index
,
222 int ring_index
, struct p54p_desc
*ring
, u32 ring_limit
,
225 struct p54p_priv
*priv
= dev
->priv
;
226 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
227 struct p54p_desc
*desc
;
230 i
= (*index
) % ring_limit
;
231 (*index
) = idx
= le32_to_cpu(ring_control
->device_idx
[1]);
237 if (FREE_AFTER_TX((struct sk_buff
*) tx_buf
[i
]))
238 p54_free_skb(dev
, tx_buf
[i
]);
241 pci_unmap_single(priv
->pdev
, le32_to_cpu(desc
->host_addr
),
242 le16_to_cpu(desc
->len
), PCI_DMA_TODEVICE
);
245 desc
->device_addr
= 0;
254 static void p54p_rx_tasklet(unsigned long dev_id
)
256 struct ieee80211_hw
*dev
= (struct ieee80211_hw
*)dev_id
;
257 struct p54p_priv
*priv
= dev
->priv
;
258 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
260 p54p_check_rx_ring(dev
, &priv
->rx_idx_mgmt
, 2, ring_control
->rx_mgmt
,
261 ARRAY_SIZE(ring_control
->rx_mgmt
), priv
->rx_buf_mgmt
);
263 p54p_check_rx_ring(dev
, &priv
->rx_idx_data
, 0, ring_control
->rx_data
,
264 ARRAY_SIZE(ring_control
->rx_data
), priv
->rx_buf_data
);
267 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
270 static irqreturn_t
p54p_interrupt(int irq
, void *dev_id
)
272 struct ieee80211_hw
*dev
= dev_id
;
273 struct p54p_priv
*priv
= dev
->priv
;
274 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
277 spin_lock(&priv
->lock
);
278 reg
= P54P_READ(int_ident
);
279 if (unlikely(reg
== cpu_to_le32(0xFFFFFFFF))) {
280 spin_unlock(&priv
->lock
);
284 P54P_WRITE(int_ack
, reg
);
286 reg
&= P54P_READ(int_enable
);
288 if (reg
& cpu_to_le32(ISL38XX_INT_IDENT_UPDATE
)) {
289 p54p_check_tx_ring(dev
, &priv
->tx_idx_mgmt
,
290 3, ring_control
->tx_mgmt
,
291 ARRAY_SIZE(ring_control
->tx_mgmt
),
294 p54p_check_tx_ring(dev
, &priv
->tx_idx_data
,
295 1, ring_control
->tx_data
,
296 ARRAY_SIZE(ring_control
->tx_data
),
299 tasklet_schedule(&priv
->rx_tasklet
);
301 } else if (reg
& cpu_to_le32(ISL38XX_INT_IDENT_INIT
))
302 complete(&priv
->boot_comp
);
304 spin_unlock(&priv
->lock
);
306 return reg
? IRQ_HANDLED
: IRQ_NONE
;
309 static void p54p_tx(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
311 struct p54p_priv
*priv
= dev
->priv
;
312 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
314 struct p54p_desc
*desc
;
316 u32 device_idx
, idx
, i
;
318 spin_lock_irqsave(&priv
->lock
, flags
);
320 device_idx
= le32_to_cpu(ring_control
->device_idx
[1]);
321 idx
= le32_to_cpu(ring_control
->host_idx
[1]);
322 i
= idx
% ARRAY_SIZE(ring_control
->tx_data
);
324 priv
->tx_buf_data
[i
] = skb
;
325 mapping
= pci_map_single(priv
->pdev
, skb
->data
, skb
->len
,
327 desc
= &ring_control
->tx_data
[i
];
328 desc
->host_addr
= cpu_to_le32(mapping
);
329 desc
->device_addr
= ((struct p54_hdr
*)skb
->data
)->req_id
;
330 desc
->len
= cpu_to_le16(skb
->len
);
334 ring_control
->host_idx
[1] = cpu_to_le32(idx
+ 1);
335 spin_unlock_irqrestore(&priv
->lock
, flags
);
337 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
341 static void p54p_stop(struct ieee80211_hw
*dev
)
343 struct p54p_priv
*priv
= dev
->priv
;
344 struct p54p_ring_control
*ring_control
= priv
->ring_control
;
346 struct p54p_desc
*desc
;
348 tasklet_kill(&priv
->rx_tasklet
);
350 P54P_WRITE(int_enable
, cpu_to_le32(0));
351 P54P_READ(int_enable
);
354 free_irq(priv
->pdev
->irq
, dev
);
356 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_RESET
));
358 for (i
= 0; i
< ARRAY_SIZE(priv
->rx_buf_data
); i
++) {
359 desc
= &ring_control
->rx_data
[i
];
361 pci_unmap_single(priv
->pdev
,
362 le32_to_cpu(desc
->host_addr
),
363 priv
->common
.rx_mtu
+ 32,
365 kfree_skb(priv
->rx_buf_data
[i
]);
366 priv
->rx_buf_data
[i
] = NULL
;
369 for (i
= 0; i
< ARRAY_SIZE(priv
->rx_buf_mgmt
); i
++) {
370 desc
= &ring_control
->rx_mgmt
[i
];
372 pci_unmap_single(priv
->pdev
,
373 le32_to_cpu(desc
->host_addr
),
374 priv
->common
.rx_mtu
+ 32,
376 kfree_skb(priv
->rx_buf_mgmt
[i
]);
377 priv
->rx_buf_mgmt
[i
] = NULL
;
380 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_buf_data
); i
++) {
381 desc
= &ring_control
->tx_data
[i
];
383 pci_unmap_single(priv
->pdev
,
384 le32_to_cpu(desc
->host_addr
),
385 le16_to_cpu(desc
->len
),
388 p54_free_skb(dev
, priv
->tx_buf_data
[i
]);
389 priv
->tx_buf_data
[i
] = NULL
;
392 for (i
= 0; i
< ARRAY_SIZE(priv
->tx_buf_mgmt
); i
++) {
393 desc
= &ring_control
->tx_mgmt
[i
];
395 pci_unmap_single(priv
->pdev
,
396 le32_to_cpu(desc
->host_addr
),
397 le16_to_cpu(desc
->len
),
400 p54_free_skb(dev
, priv
->tx_buf_mgmt
[i
]);
401 priv
->tx_buf_mgmt
[i
] = NULL
;
404 memset(ring_control
, 0, sizeof(*ring_control
));
407 static int p54p_open(struct ieee80211_hw
*dev
)
409 struct p54p_priv
*priv
= dev
->priv
;
412 init_completion(&priv
->boot_comp
);
413 err
= request_irq(priv
->pdev
->irq
, &p54p_interrupt
,
414 IRQF_SHARED
, "p54pci", dev
);
416 dev_err(&priv
->pdev
->dev
, "failed to register IRQ handler\n");
420 memset(priv
->ring_control
, 0, sizeof(*priv
->ring_control
));
421 err
= p54p_upload_firmware(dev
);
423 free_irq(priv
->pdev
->irq
, dev
);
426 priv
->rx_idx_data
= priv
->tx_idx_data
= 0;
427 priv
->rx_idx_mgmt
= priv
->tx_idx_mgmt
= 0;
429 p54p_refill_rx_ring(dev
, 0, priv
->ring_control
->rx_data
,
430 ARRAY_SIZE(priv
->ring_control
->rx_data
), priv
->rx_buf_data
);
432 p54p_refill_rx_ring(dev
, 2, priv
->ring_control
->rx_mgmt
,
433 ARRAY_SIZE(priv
->ring_control
->rx_mgmt
), priv
->rx_buf_mgmt
);
435 P54P_WRITE(ring_control_base
, cpu_to_le32(priv
->ring_control_dma
));
436 P54P_READ(ring_control_base
);
440 P54P_WRITE(int_enable
, cpu_to_le32(ISL38XX_INT_IDENT_INIT
));
441 P54P_READ(int_enable
);
445 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_RESET
));
448 if (!wait_for_completion_interruptible_timeout(&priv
->boot_comp
, HZ
)) {
449 printk(KERN_ERR
"%s: Cannot boot firmware!\n",
450 wiphy_name(dev
->wiphy
));
455 P54P_WRITE(int_enable
, cpu_to_le32(ISL38XX_INT_IDENT_UPDATE
));
456 P54P_READ(int_enable
);
460 P54P_WRITE(dev_int
, cpu_to_le32(ISL38XX_DEV_INT_UPDATE
));
468 static int __devinit
p54p_probe(struct pci_dev
*pdev
,
469 const struct pci_device_id
*id
)
471 struct p54p_priv
*priv
;
472 struct ieee80211_hw
*dev
;
473 unsigned long mem_addr
, mem_len
;
476 err
= pci_enable_device(pdev
);
478 dev_err(&pdev
->dev
, "Cannot enable new PCI device\n");
482 mem_addr
= pci_resource_start(pdev
, 0);
483 mem_len
= pci_resource_len(pdev
, 0);
484 if (mem_len
< sizeof(struct p54p_csr
)) {
485 dev_err(&pdev
->dev
, "Too short PCI resources\n");
486 goto err_disable_dev
;
489 err
= pci_request_regions(pdev
, "p54pci");
491 dev_err(&pdev
->dev
, "Cannot obtain PCI resources\n");
492 goto err_disable_dev
;
495 if (pci_set_dma_mask(pdev
, DMA_32BIT_MASK
) ||
496 pci_set_consistent_dma_mask(pdev
, DMA_32BIT_MASK
)) {
497 dev_err(&pdev
->dev
, "No suitable DMA available\n");
501 pci_set_master(pdev
);
502 pci_try_set_mwi(pdev
);
504 pci_write_config_byte(pdev
, 0x40, 0);
505 pci_write_config_byte(pdev
, 0x41, 0);
507 dev
= p54_init_common(sizeof(*priv
));
509 dev_err(&pdev
->dev
, "ieee80211 alloc failed\n");
517 SET_IEEE80211_DEV(dev
, &pdev
->dev
);
518 pci_set_drvdata(pdev
, dev
);
520 priv
->map
= ioremap(mem_addr
, mem_len
);
522 dev_err(&pdev
->dev
, "Cannot map device memory\n");
527 priv
->ring_control
= pci_alloc_consistent(pdev
, sizeof(*priv
->ring_control
),
528 &priv
->ring_control_dma
);
529 if (!priv
->ring_control
) {
530 dev_err(&pdev
->dev
, "Cannot allocate rings\n");
534 priv
->common
.open
= p54p_open
;
535 priv
->common
.stop
= p54p_stop
;
536 priv
->common
.tx
= p54p_tx
;
538 spin_lock_init(&priv
->lock
);
539 tasklet_init(&priv
->rx_tasklet
, p54p_rx_tasklet
, (unsigned long)dev
);
541 err
= request_firmware(&priv
->firmware
, "isl3886pci",
544 dev_err(&pdev
->dev
, "Cannot find firmware (isl3886pci)\n");
545 err
= request_firmware(&priv
->firmware
, "isl3886",
548 goto err_free_common
;
551 err
= p54p_open(dev
);
553 goto err_free_common
;
554 err
= p54_read_eeprom(dev
);
557 goto err_free_common
;
559 err
= p54_register_common(dev
, &pdev
->dev
);
561 goto err_free_common
;
566 release_firmware(priv
->firmware
);
567 p54_free_common(dev
);
568 pci_free_consistent(pdev
, sizeof(*priv
->ring_control
),
569 priv
->ring_control
, priv
->ring_control_dma
);
575 pci_set_drvdata(pdev
, NULL
);
576 ieee80211_free_hw(dev
);
579 pci_release_regions(pdev
);
581 pci_disable_device(pdev
);
585 static void __devexit
p54p_remove(struct pci_dev
*pdev
)
587 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
588 struct p54p_priv
*priv
;
593 ieee80211_unregister_hw(dev
);
595 release_firmware(priv
->firmware
);
596 pci_free_consistent(pdev
, sizeof(*priv
->ring_control
),
597 priv
->ring_control
, priv
->ring_control_dma
);
598 p54_free_common(dev
);
600 pci_release_regions(pdev
);
601 pci_disable_device(pdev
);
602 ieee80211_free_hw(dev
);
606 static int p54p_suspend(struct pci_dev
*pdev
, pm_message_t state
)
608 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
609 struct p54p_priv
*priv
= dev
->priv
;
611 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
) {
612 ieee80211_stop_queues(dev
);
616 pci_save_state(pdev
);
617 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
621 static int p54p_resume(struct pci_dev
*pdev
)
623 struct ieee80211_hw
*dev
= pci_get_drvdata(pdev
);
624 struct p54p_priv
*priv
= dev
->priv
;
626 pci_set_power_state(pdev
, PCI_D0
);
627 pci_restore_state(pdev
);
629 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
) {
631 ieee80211_wake_queues(dev
);
636 #endif /* CONFIG_PM */
638 static struct pci_driver p54p_driver
= {
640 .id_table
= p54p_table
,
642 .remove
= __devexit_p(p54p_remove
),
644 .suspend
= p54p_suspend
,
645 .resume
= p54p_resume
,
646 #endif /* CONFIG_PM */
649 static int __init
p54p_init(void)
651 return pci_register_driver(&p54p_driver
);
654 static void __exit
p54p_exit(void)
656 pci_unregister_driver(&p54p_driver
);
659 module_init(p54p_init
);
660 module_exit(p54p_exit
);