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