1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2002 Intersil Americas Inc.
4 * Copyright (C) 2003 Herbert Valerio Riedel <hvr@gnu.org>
5 */
6
7 #include <linux/interrupt.h>
8 #include <linux/module.h>
9 #include <linux/pci.h>
10 #include <linux/delay.h>
11 #include <linux/init.h> /* For __init, __exit */
12 #include <linux/dma-mapping.h>
13
14 #include "prismcompat.h"
15 #include "islpci_dev.h"
16 #include "islpci_mgt.h" /* for pc_debug */
17 #include "isl_oid.h"
18
19 MODULE_AUTHOR("[Intersil] R.Bastings and W.Termorshuizen, The prism54.org Development Team <prism54-devel@prism54.org>");
20 MODULE_DESCRIPTION("The Prism54 802.11 Wireless LAN adapter");
21 MODULE_LICENSE("GPL");
22
23 static int init_pcitm = 0;
24 module_param(init_pcitm, int, 0);
25
26 /* In this order: vendor, device, subvendor, subdevice, class, class_mask,
27 * driver_data
28 * If you have an update for this please contact prism54-devel@prism54.org
29 * The latest list can be found at http://wireless.kernel.org/en/users/Drivers/p54 */
30 static const struct pci_device_id prism54_id_tbl[] = {
31 /* Intersil PRISM Duette/Prism GT Wireless LAN adapter */
32 {
33 0x1260, 0x3890,
34 PCI_ANY_ID, PCI_ANY_ID,
35 0, 0, 0
36 },
37
38 /* 3COM 3CRWE154G72 Wireless LAN adapter */
39 {
40 PCI_VDEVICE(3COM, 0x6001), 0
41 },
42
43 /* Intersil PRISM Indigo Wireless LAN adapter */
44 {
45 0x1260, 0x3877,
46 PCI_ANY_ID, PCI_ANY_ID,
47 0, 0, 0
48 },
49
50 /* Intersil PRISM Javelin/Xbow Wireless LAN adapter */
51 {
52 0x1260, 0x3886,
53 PCI_ANY_ID, PCI_ANY_ID,
54 0, 0, 0
55 },
56
57 /* End of list */
58 {0,0,0,0,0,0,0}
59 };
60
61 /* register the device with the Hotplug facilities of the kernel */
62 MODULE_DEVICE_TABLE(pci, prism54_id_tbl);
63
64 static int prism54_probe(struct pci_dev *, const struct pci_device_id *);
65 static void prism54_remove(struct pci_dev *);
66 static int prism54_suspend(struct pci_dev *, pm_message_t state);
67 static int prism54_resume(struct pci_dev *);
68
69 static struct pci_driver prism54_driver = {
70 .name = DRV_NAME,
71 .id_table = prism54_id_tbl,
72 .probe = prism54_probe,
73 .remove = prism54_remove,
74 .suspend = prism54_suspend,
75 .resume = prism54_resume,
76 };
77
78 /******************************************************************************
79 Module initialization functions
80 ******************************************************************************/
81
82 static int
prism54_probe(struct pci_dev * pdev,const struct pci_device_id * id)83 prism54_probe(struct pci_dev *pdev, const struct pci_device_id *id)
84 {
85 struct net_device *ndev;
86 u8 latency_tmr;
87 u32 mem_addr;
88 islpci_private *priv;
89 int rvalue;
90
91 /* Enable the pci device */
92 if (pci_enable_device(pdev)) {
93 printk(KERN_ERR "%s: pci_enable_device() failed.\n", DRV_NAME);
94 return -ENODEV;
95 }
96
97 /* check whether the latency timer is set correctly */
98 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_tmr);
99 #if VERBOSE > SHOW_ERROR_MESSAGES
100 DEBUG(SHOW_TRACING, "latency timer: %x\n", latency_tmr);
101 #endif
102 if (latency_tmr < PCIDEVICE_LATENCY_TIMER_MIN) {
103 /* set the latency timer */
104 pci_write_config_byte(pdev, PCI_LATENCY_TIMER,
105 PCIDEVICE_LATENCY_TIMER_VAL);
106 }
107
108 /* enable PCI DMA */
109 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
110 printk(KERN_ERR "%s: 32-bit PCI DMA not supported", DRV_NAME);
111 goto do_pci_disable_device;
112 }
113
114 /* 0x40 is the programmable timer to configure the response timeout (TRDY_TIMEOUT)
115 * 0x41 is the programmable timer to configure the retry timeout (RETRY_TIMEOUT)
116 * The RETRY_TIMEOUT is used to set the number of retries that the core, as a
117 * Master, will perform before abandoning a cycle. The default value for
118 * RETRY_TIMEOUT is 0x80, which far exceeds the PCI 2.1 requirement for new
119 * devices. A write of zero to the RETRY_TIMEOUT register disables this
120 * function to allow use with any non-compliant legacy devices that may
121 * execute more retries.
122 *
123 * Writing zero to both these two registers will disable both timeouts and
124 * *can* solve problems caused by devices that are slow to respond.
125 * Make this configurable - MSW
126 */
127 if ( init_pcitm >= 0 ) {
128 pci_write_config_byte(pdev, 0x40, (u8)init_pcitm);
129 pci_write_config_byte(pdev, 0x41, (u8)init_pcitm);
130 } else {
131 printk(KERN_INFO "PCI TRDY/RETRY unchanged\n");
132 }
133
134 /* request the pci device I/O regions */
135 rvalue = pci_request_regions(pdev, DRV_NAME);
136 if (rvalue) {
137 printk(KERN_ERR "%s: pci_request_regions failure (rc=%d)\n",
138 DRV_NAME, rvalue);
139 goto do_pci_disable_device;
140 }
141
142 /* check if the memory window is indeed set */
143 rvalue = pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &mem_addr);
144 if (rvalue || !mem_addr) {
145 printk(KERN_ERR "%s: PCI device memory region not configured; fix your BIOS or CardBus bridge/drivers\n",
146 DRV_NAME);
147 goto do_pci_release_regions;
148 }
149
150 /* enable PCI bus-mastering */
151 DEBUG(SHOW_TRACING, "%s: pci_set_master(pdev)\n", DRV_NAME);
152 pci_set_master(pdev);
153
154 /* enable MWI */
155 pci_try_set_mwi(pdev);
156
157 /* setup the network device interface and its structure */
158 if (!(ndev = islpci_setup(pdev))) {
159 /* error configuring the driver as a network device */
160 printk(KERN_ERR "%s: could not configure network device\n",
161 DRV_NAME);
162 goto do_pci_clear_mwi;
163 }
164
165 priv = netdev_priv(ndev);
166 islpci_set_state(priv, PRV_STATE_PREBOOT); /* we are attempting to boot */
167
168 /* card is in unknown state yet, might have some interrupts pending */
169 isl38xx_disable_interrupts(priv->device_base);
170
171 /* request for the interrupt before uploading the firmware */
172 rvalue = request_irq(pdev->irq, islpci_interrupt,
173 IRQF_SHARED, ndev->name, priv);
174
175 if (rvalue) {
176 /* error, could not hook the handler to the irq */
177 printk(KERN_ERR "%s: could not install IRQ handler\n",
178 ndev->name);
179 goto do_unregister_netdev;
180 }
181
182 /* firmware upload is triggered in islpci_open */
183
184 return 0;
185
186 do_unregister_netdev:
187 unregister_netdev(ndev);
188 islpci_free_memory(priv);
189 free_netdev(ndev);
190 priv = NULL;
191 do_pci_clear_mwi:
192 pci_clear_mwi(pdev);
193 do_pci_release_regions:
194 pci_release_regions(pdev);
195 do_pci_disable_device:
196 pci_disable_device(pdev);
197 return -EIO;
198 }
199
200 /* set by cleanup_module */
201 static volatile int __in_cleanup_module = 0;
202
203 /* this one removes one(!!) instance only */
204 static void
prism54_remove(struct pci_dev * pdev)205 prism54_remove(struct pci_dev *pdev)
206 {
207 struct net_device *ndev = pci_get_drvdata(pdev);
208 islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
209 BUG_ON(!priv);
210
211 if (!__in_cleanup_module) {
212 printk(KERN_DEBUG "%s: hot unplug detected\n", ndev->name);
213 islpci_set_state(priv, PRV_STATE_OFF);
214 }
215
216 printk(KERN_DEBUG "%s: removing device\n", ndev->name);
217
218 unregister_netdev(ndev);
219
220 /* free the interrupt request */
221
222 if (islpci_get_state(priv) != PRV_STATE_OFF) {
223 isl38xx_disable_interrupts(priv->device_base);
224 islpci_set_state(priv, PRV_STATE_OFF);
225 /* This bellow causes a lockup at rmmod time. It might be
226 * because some interrupts still linger after rmmod time,
227 * see bug #17 */
228 /* pci_set_power_state(pdev, 3);*/ /* try to power-off */
229 }
230
231 free_irq(pdev->irq, priv);
232
233 /* free the PCI memory and unmap the remapped page */
234 islpci_free_memory(priv);
235
236 free_netdev(ndev);
237 priv = NULL;
238
239 pci_clear_mwi(pdev);
240
241 pci_release_regions(pdev);
242
243 pci_disable_device(pdev);
244 }
245
246 static int
prism54_suspend(struct pci_dev * pdev,pm_message_t state)247 prism54_suspend(struct pci_dev *pdev, pm_message_t state)
248 {
249 struct net_device *ndev = pci_get_drvdata(pdev);
250 islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
251 BUG_ON(!priv);
252
253
254 pci_save_state(pdev);
255
256 /* tell the device not to trigger interrupts for now... */
257 isl38xx_disable_interrupts(priv->device_base);
258
259 /* from now on assume the hardware was already powered down
260 and don't touch it anymore */
261 islpci_set_state(priv, PRV_STATE_OFF);
262
263 netif_stop_queue(ndev);
264 netif_device_detach(ndev);
265
266 return 0;
267 }
268
269 static int
prism54_resume(struct pci_dev * pdev)270 prism54_resume(struct pci_dev *pdev)
271 {
272 struct net_device *ndev = pci_get_drvdata(pdev);
273 islpci_private *priv = ndev ? netdev_priv(ndev) : NULL;
274 int err;
275
276 BUG_ON(!priv);
277
278 printk(KERN_NOTICE "%s: got resume request\n", ndev->name);
279
280 err = pci_enable_device(pdev);
281 if (err) {
282 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
283 ndev->name);
284 return err;
285 }
286
287 pci_restore_state(pdev);
288
289 /* alright let's go into the PREBOOT state */
290 islpci_reset(priv, 1);
291
292 netif_device_attach(ndev);
293 netif_start_queue(ndev);
294
295 return 0;
296 }
297
298 static int __init
prism54_module_init(void)299 prism54_module_init(void)
300 {
301 printk(KERN_INFO "Loaded %s driver, version %s\n",
302 DRV_NAME, DRV_VERSION);
303
304 __bug_on_wrong_struct_sizes ();
305
306 return pci_register_driver(&prism54_driver);
307 }
308
309 /* by the time prism54_module_exit() terminates, as a postcondition
310 * all instances will have been destroyed by calls to
311 * prism54_remove() */
312 static void __exit
prism54_module_exit(void)313 prism54_module_exit(void)
314 {
315 __in_cleanup_module = 1;
316
317 pci_unregister_driver(&prism54_driver);
318
319 printk(KERN_INFO "Unloaded %s driver\n", DRV_NAME);
320
321 __in_cleanup_module = 0;
322 }
323
324 /* register entry points */
325 module_init(prism54_module_init);
326 module_exit(prism54_module_exit);
327 /* EOF */
328
