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