Merge branch 'for-linus' of git://neil.brown.name/md
[linux-2.6] / drivers / net / wireless / rt2x00 / rt2x00pci.c
1 /*
2         Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
3         <http://rt2x00.serialmonkey.com>
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, or
8         (at your option) any later version.
9
10         This program is distributed in the hope that it will be useful,
11         but WITHOUT ANY WARRANTY; without even the implied warranty of
12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13         GNU General Public License for more details.
14
15         You should have received a copy of the GNU General Public License
16         along with this program; if not, write to the
17         Free Software Foundation, Inc.,
18         59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  */
20
21 /*
22         Module: rt2x00pci
23         Abstract: rt2x00 generic pci device routines.
24  */
25
26 #include <linux/dma-mapping.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/pci.h>
30
31 #include "rt2x00.h"
32 #include "rt2x00pci.h"
33
34 /*
35  * TX data handlers.
36  */
37 int rt2x00pci_write_tx_data(struct queue_entry *entry)
38 {
39         struct queue_entry_priv_pci *entry_priv = entry->priv_data;
40         struct skb_frame_desc *skbdesc;
41         u32 word;
42
43         rt2x00_desc_read(entry_priv->desc, 0, &word);
44
45         /*
46          * This should not happen, we already checked the entry
47          * was ours. When the hardware disagrees there has been
48          * a queue corruption!
49          */
50         if (unlikely(rt2x00_get_field32(word, TXD_ENTRY_OWNER_NIC) ||
51                      rt2x00_get_field32(word, TXD_ENTRY_VALID))) {
52                 ERROR(entry->queue->rt2x00dev,
53                       "Corrupt queue %d, accessing entry which is not ours.\n"
54                       "Please file bug report to %s.\n",
55                       entry->queue->qid, DRV_PROJECT);
56                 return -EINVAL;
57         }
58
59         /*
60          * Fill in skb descriptor
61          */
62         skbdesc = get_skb_frame_desc(entry->skb);
63         skbdesc->desc = entry_priv->desc;
64         skbdesc->desc_len = entry->queue->desc_size;
65
66         return 0;
67 }
68 EXPORT_SYMBOL_GPL(rt2x00pci_write_tx_data);
69
70 /*
71  * TX/RX data handlers.
72  */
73 void rt2x00pci_rxdone(struct rt2x00_dev *rt2x00dev)
74 {
75         struct data_queue *queue = rt2x00dev->rx;
76         struct queue_entry *entry;
77         struct queue_entry_priv_pci *entry_priv;
78         struct skb_frame_desc *skbdesc;
79         u32 word;
80
81         while (1) {
82                 entry = rt2x00queue_get_entry(queue, Q_INDEX);
83                 entry_priv = entry->priv_data;
84                 rt2x00_desc_read(entry_priv->desc, 0, &word);
85
86                 if (rt2x00_get_field32(word, RXD_ENTRY_OWNER_NIC))
87                         break;
88
89                 /*
90                  * Fill in desc fields of the skb descriptor
91                  */
92                 skbdesc = get_skb_frame_desc(entry->skb);
93                 skbdesc->desc = entry_priv->desc;
94                 skbdesc->desc_len = entry->queue->desc_size;
95
96                 /*
97                  * Send the frame to rt2x00lib for further processing.
98                  */
99                 rt2x00lib_rxdone(rt2x00dev, entry);
100         }
101 }
102 EXPORT_SYMBOL_GPL(rt2x00pci_rxdone);
103
104 /*
105  * Device initialization handlers.
106  */
107 static int rt2x00pci_alloc_queue_dma(struct rt2x00_dev *rt2x00dev,
108                                      struct data_queue *queue)
109 {
110         struct queue_entry_priv_pci *entry_priv;
111         void *addr;
112         dma_addr_t dma;
113         unsigned int i;
114
115         /*
116          * Allocate DMA memory for descriptor and buffer.
117          */
118         addr = dma_alloc_coherent(rt2x00dev->dev,
119                                   queue->limit * queue->desc_size,
120                                   &dma, GFP_KERNEL | GFP_DMA);
121         if (!addr)
122                 return -ENOMEM;
123
124         memset(addr, 0, queue->limit * queue->desc_size);
125
126         /*
127          * Initialize all queue entries to contain valid addresses.
128          */
129         for (i = 0; i < queue->limit; i++) {
130                 entry_priv = queue->entries[i].priv_data;
131                 entry_priv->desc = addr + i * queue->desc_size;
132                 entry_priv->desc_dma = dma + i * queue->desc_size;
133         }
134
135         return 0;
136 }
137
138 static void rt2x00pci_free_queue_dma(struct rt2x00_dev *rt2x00dev,
139                                      struct data_queue *queue)
140 {
141         struct queue_entry_priv_pci *entry_priv =
142             queue->entries[0].priv_data;
143
144         if (entry_priv->desc)
145                 dma_free_coherent(rt2x00dev->dev,
146                                   queue->limit * queue->desc_size,
147                                   entry_priv->desc, entry_priv->desc_dma);
148         entry_priv->desc = NULL;
149 }
150
151 int rt2x00pci_initialize(struct rt2x00_dev *rt2x00dev)
152 {
153         struct pci_dev *pci_dev = to_pci_dev(rt2x00dev->dev);
154         struct data_queue *queue;
155         int status;
156
157         /*
158          * Allocate DMA
159          */
160         queue_for_each(rt2x00dev, queue) {
161                 status = rt2x00pci_alloc_queue_dma(rt2x00dev, queue);
162                 if (status)
163                         goto exit;
164         }
165
166         /*
167          * Register interrupt handler.
168          */
169         status = request_irq(pci_dev->irq, rt2x00dev->ops->lib->irq_handler,
170                              IRQF_SHARED, pci_name(pci_dev), rt2x00dev);
171         if (status) {
172                 ERROR(rt2x00dev, "IRQ %d allocation failed (error %d).\n",
173                       pci_dev->irq, status);
174                 goto exit;
175         }
176
177         return 0;
178
179 exit:
180         queue_for_each(rt2x00dev, queue)
181                 rt2x00pci_free_queue_dma(rt2x00dev, queue);
182
183         return status;
184 }
185 EXPORT_SYMBOL_GPL(rt2x00pci_initialize);
186
187 void rt2x00pci_uninitialize(struct rt2x00_dev *rt2x00dev)
188 {
189         struct data_queue *queue;
190
191         /*
192          * Free irq line.
193          */
194         free_irq(to_pci_dev(rt2x00dev->dev)->irq, rt2x00dev);
195
196         /*
197          * Free DMA
198          */
199         queue_for_each(rt2x00dev, queue)
200                 rt2x00pci_free_queue_dma(rt2x00dev, queue);
201 }
202 EXPORT_SYMBOL_GPL(rt2x00pci_uninitialize);
203
204 /*
205  * PCI driver handlers.
206  */
207 static void rt2x00pci_free_reg(struct rt2x00_dev *rt2x00dev)
208 {
209         kfree(rt2x00dev->rf);
210         rt2x00dev->rf = NULL;
211
212         kfree(rt2x00dev->eeprom);
213         rt2x00dev->eeprom = NULL;
214
215         if (rt2x00dev->csr.base) {
216                 iounmap(rt2x00dev->csr.base);
217                 rt2x00dev->csr.base = NULL;
218         }
219 }
220
221 static int rt2x00pci_alloc_reg(struct rt2x00_dev *rt2x00dev)
222 {
223         struct pci_dev *pci_dev = to_pci_dev(rt2x00dev->dev);
224
225         rt2x00dev->csr.base = ioremap(pci_resource_start(pci_dev, 0),
226                                       pci_resource_len(pci_dev, 0));
227         if (!rt2x00dev->csr.base)
228                 goto exit;
229
230         rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
231         if (!rt2x00dev->eeprom)
232                 goto exit;
233
234         rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
235         if (!rt2x00dev->rf)
236                 goto exit;
237
238         return 0;
239
240 exit:
241         ERROR_PROBE("Failed to allocate registers.\n");
242
243         rt2x00pci_free_reg(rt2x00dev);
244
245         return -ENOMEM;
246 }
247
248 int rt2x00pci_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
249 {
250         struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_data;
251         struct ieee80211_hw *hw;
252         struct rt2x00_dev *rt2x00dev;
253         int retval;
254
255         retval = pci_request_regions(pci_dev, pci_name(pci_dev));
256         if (retval) {
257                 ERROR_PROBE("PCI request regions failed.\n");
258                 return retval;
259         }
260
261         retval = pci_enable_device(pci_dev);
262         if (retval) {
263                 ERROR_PROBE("Enable device failed.\n");
264                 goto exit_release_regions;
265         }
266
267         pci_set_master(pci_dev);
268
269         if (pci_set_mwi(pci_dev))
270                 ERROR_PROBE("MWI not available.\n");
271
272         if (dma_set_mask(&pci_dev->dev, DMA_32BIT_MASK)) {
273                 ERROR_PROBE("PCI DMA not supported.\n");
274                 retval = -EIO;
275                 goto exit_disable_device;
276         }
277
278         hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
279         if (!hw) {
280                 ERROR_PROBE("Failed to allocate hardware.\n");
281                 retval = -ENOMEM;
282                 goto exit_disable_device;
283         }
284
285         pci_set_drvdata(pci_dev, hw);
286
287         rt2x00dev = hw->priv;
288         rt2x00dev->dev = &pci_dev->dev;
289         rt2x00dev->ops = ops;
290         rt2x00dev->hw = hw;
291
292         retval = rt2x00pci_alloc_reg(rt2x00dev);
293         if (retval)
294                 goto exit_free_device;
295
296         retval = rt2x00lib_probe_dev(rt2x00dev);
297         if (retval)
298                 goto exit_free_reg;
299
300         return 0;
301
302 exit_free_reg:
303         rt2x00pci_free_reg(rt2x00dev);
304
305 exit_free_device:
306         ieee80211_free_hw(hw);
307
308 exit_disable_device:
309         if (retval != -EBUSY)
310                 pci_disable_device(pci_dev);
311
312 exit_release_regions:
313         pci_release_regions(pci_dev);
314
315         pci_set_drvdata(pci_dev, NULL);
316
317         return retval;
318 }
319 EXPORT_SYMBOL_GPL(rt2x00pci_probe);
320
321 void rt2x00pci_remove(struct pci_dev *pci_dev)
322 {
323         struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
324         struct rt2x00_dev *rt2x00dev = hw->priv;
325
326         /*
327          * Free all allocated data.
328          */
329         rt2x00lib_remove_dev(rt2x00dev);
330         rt2x00pci_free_reg(rt2x00dev);
331         ieee80211_free_hw(hw);
332
333         /*
334          * Free the PCI device data.
335          */
336         pci_set_drvdata(pci_dev, NULL);
337         pci_disable_device(pci_dev);
338         pci_release_regions(pci_dev);
339 }
340 EXPORT_SYMBOL_GPL(rt2x00pci_remove);
341
342 #ifdef CONFIG_PM
343 int rt2x00pci_suspend(struct pci_dev *pci_dev, pm_message_t state)
344 {
345         struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
346         struct rt2x00_dev *rt2x00dev = hw->priv;
347         int retval;
348
349         retval = rt2x00lib_suspend(rt2x00dev, state);
350         if (retval)
351                 return retval;
352
353         rt2x00pci_free_reg(rt2x00dev);
354
355         pci_save_state(pci_dev);
356         pci_disable_device(pci_dev);
357         return pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state));
358 }
359 EXPORT_SYMBOL_GPL(rt2x00pci_suspend);
360
361 int rt2x00pci_resume(struct pci_dev *pci_dev)
362 {
363         struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
364         struct rt2x00_dev *rt2x00dev = hw->priv;
365         int retval;
366
367         if (pci_set_power_state(pci_dev, PCI_D0) ||
368             pci_enable_device(pci_dev) ||
369             pci_restore_state(pci_dev)) {
370                 ERROR(rt2x00dev, "Failed to resume device.\n");
371                 return -EIO;
372         }
373
374         retval = rt2x00pci_alloc_reg(rt2x00dev);
375         if (retval)
376                 return retval;
377
378         retval = rt2x00lib_resume(rt2x00dev);
379         if (retval)
380                 goto exit_free_reg;
381
382         return 0;
383
384 exit_free_reg:
385         rt2x00pci_free_reg(rt2x00dev);
386
387         return retval;
388 }
389 EXPORT_SYMBOL_GPL(rt2x00pci_resume);
390 #endif /* CONFIG_PM */
391
392 /*
393  * rt2x00pci module information.
394  */
395 MODULE_AUTHOR(DRV_PROJECT);
396 MODULE_VERSION(DRV_VERSION);
397 MODULE_DESCRIPTION("rt2x00 pci library");
398 MODULE_LICENSE("GPL");