2 Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
3 <http://rt2x00.serialmonkey.com>
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.
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.
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.
23 Abstract: rt2x00 generic pci device routines.
26 #include <linux/dma-mapping.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/pci.h>
32 #include "rt2x00pci.h"
37 int rt2x00pci_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
38 struct ieee80211_tx_control *control)
40 struct rt2x00_dev *rt2x00dev = hw->priv;
41 struct queue_entry_priv_pci_tx *priv_tx;
42 struct skb_frame_desc *skbdesc;
43 struct data_queue *queue;
44 struct queue_entry *entry;
47 * Just in case mac80211 doesn't set this correctly,
48 * but we need this queue set for the descriptor
51 control->queue = IEEE80211_TX_QUEUE_BEACON;
52 queue = rt2x00queue_get_queue(rt2x00dev, control->queue);
53 entry = rt2x00queue_get_entry(queue, Q_INDEX);
54 priv_tx = entry->priv_data;
57 * Fill in skb descriptor
59 skbdesc = get_skb_frame_desc(skb);
60 memset(skbdesc, 0, sizeof(*skbdesc));
61 skbdesc->data = skb->data;
62 skbdesc->data_len = queue->data_size;
63 skbdesc->desc = priv_tx->desc;
64 skbdesc->desc_len = queue->desc_size;
65 skbdesc->entry = entry;
67 memcpy(priv_tx->data, skb->data, skb->len);
68 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
71 * Enable beacon generation.
73 rt2x00dev->ops->lib->kick_tx_queue(rt2x00dev, control->queue);
77 EXPORT_SYMBOL_GPL(rt2x00pci_beacon_update);
82 int rt2x00pci_write_tx_data(struct rt2x00_dev *rt2x00dev,
83 struct data_queue *queue, struct sk_buff *skb,
84 struct ieee80211_tx_control *control)
86 struct queue_entry *entry = rt2x00queue_get_entry(queue, Q_INDEX);
87 struct queue_entry_priv_pci_tx *priv_tx = entry->priv_data;
88 struct skb_frame_desc *skbdesc;
91 if (rt2x00queue_full(queue))
94 rt2x00_desc_read(priv_tx->desc, 0, &word);
96 if (rt2x00_get_field32(word, TXD_ENTRY_OWNER_NIC) ||
97 rt2x00_get_field32(word, TXD_ENTRY_VALID)) {
99 "Arrived at non-free entry in the non-full queue %d.\n"
100 "Please file bug report to %s.\n",
101 control->queue, DRV_PROJECT);
106 * Fill in skb descriptor
108 skbdesc = get_skb_frame_desc(skb);
109 memset(skbdesc, 0, sizeof(*skbdesc));
110 skbdesc->data = skb->data;
111 skbdesc->data_len = queue->data_size;
112 skbdesc->desc = priv_tx->desc;
113 skbdesc->desc_len = queue->desc_size;
114 skbdesc->entry = entry;
116 memcpy(priv_tx->data, skb->data, skb->len);
117 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
119 rt2x00queue_index_inc(queue, Q_INDEX);
123 EXPORT_SYMBOL_GPL(rt2x00pci_write_tx_data);
126 * TX/RX data handlers.
128 void rt2x00pci_rxdone(struct rt2x00_dev *rt2x00dev)
130 struct data_queue *queue = rt2x00dev->rx;
131 struct queue_entry *entry;
132 struct queue_entry_priv_pci_rx *priv_rx;
133 struct ieee80211_hdr *hdr;
134 struct skb_frame_desc *skbdesc;
135 struct rxdone_entry_desc rxdesc;
141 entry = rt2x00queue_get_entry(queue, Q_INDEX);
142 priv_rx = entry->priv_data;
143 rt2x00_desc_read(priv_rx->desc, 0, &word);
145 if (rt2x00_get_field32(word, RXD_ENTRY_OWNER_NIC))
148 memset(&rxdesc, 0, sizeof(rxdesc));
149 rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
151 hdr = (struct ieee80211_hdr *)priv_rx->data;
153 ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_control));
156 * The data behind the ieee80211 header must be
157 * aligned on a 4 byte boundary.
159 align = header_size % 4;
162 * Allocate the sk_buffer, initialize it and copy
165 entry->skb = dev_alloc_skb(rxdesc.size + align);
169 skb_reserve(entry->skb, align);
170 memcpy(skb_put(entry->skb, rxdesc.size),
171 priv_rx->data, rxdesc.size);
174 * Fill in skb descriptor
176 skbdesc = get_skb_frame_desc(entry->skb);
177 memset(skbdesc, 0, sizeof(*skbdesc));
178 skbdesc->data = entry->skb->data;
179 skbdesc->data_len = queue->data_size;
180 skbdesc->desc = priv_rx->desc;
181 skbdesc->desc_len = queue->desc_size;
182 skbdesc->entry = entry;
185 * Send the frame to rt2x00lib for further processing.
187 rt2x00lib_rxdone(entry, &rxdesc);
189 if (test_bit(DEVICE_ENABLED_RADIO, &queue->rt2x00dev->flags)) {
190 rt2x00_set_field32(&word, RXD_ENTRY_OWNER_NIC, 1);
191 rt2x00_desc_write(priv_rx->desc, 0, word);
194 rt2x00queue_index_inc(queue, Q_INDEX);
197 EXPORT_SYMBOL_GPL(rt2x00pci_rxdone);
199 void rt2x00pci_txdone(struct rt2x00_dev *rt2x00dev, struct queue_entry *entry,
200 struct txdone_entry_desc *txdesc)
202 struct queue_entry_priv_pci_tx *priv_tx = entry->priv_data;
205 txdesc->control = &priv_tx->control;
206 rt2x00lib_txdone(entry, txdesc);
209 * Make this entry available for reuse.
213 rt2x00_desc_read(priv_tx->desc, 0, &word);
214 rt2x00_set_field32(&word, TXD_ENTRY_OWNER_NIC, 0);
215 rt2x00_set_field32(&word, TXD_ENTRY_VALID, 0);
216 rt2x00_desc_write(priv_tx->desc, 0, word);
218 rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE);
221 * If the data queue was full before the txdone handler
222 * we must make sure the packet queue in the mac80211 stack
223 * is reenabled when the txdone handler has finished.
225 if (!rt2x00queue_full(entry->queue))
226 ieee80211_wake_queue(rt2x00dev->hw, priv_tx->control.queue);
229 EXPORT_SYMBOL_GPL(rt2x00pci_txdone);
232 * Device initialization handlers.
234 #define dma_size(__queue) \
237 ((__queue)->desc_size + (__queue)->data_size);\
240 #define priv_offset(__queue, __base, __i) \
242 (__base) + ((__i) * (__queue)->desc_size); \
245 #define data_addr_offset(__queue, __base, __i) \
248 ((__queue)->limit * (__queue)->desc_size) + \
249 ((__i) * (__queue)->data_size); \
252 #define data_dma_offset(__queue, __base, __i) \
255 ((__queue)->limit * (__queue)->desc_size) + \
256 ((__i) * (__queue)->data_size); \
259 static int rt2x00pci_alloc_queue_dma(struct rt2x00_dev *rt2x00dev,
260 struct data_queue *queue)
262 struct pci_dev *pci_dev = rt2x00dev_pci(rt2x00dev);
263 struct queue_entry_priv_pci_tx *priv_tx;
269 * Allocate DMA memory for descriptor and buffer.
271 data_addr = pci_alloc_consistent(pci_dev, dma_size(queue), &data_dma);
276 * Initialize all queue entries to contain valid addresses.
278 for (i = 0; i < queue->limit; i++) {
279 priv_tx = queue->entries[i].priv_data;
280 priv_tx->desc = priv_offset(queue, data_addr, i);
281 priv_tx->data = data_addr_offset(queue, data_addr, i);
282 priv_tx->dma = data_dma_offset(queue, data_dma, i);
288 static void rt2x00pci_free_queue_dma(struct rt2x00_dev *rt2x00dev,
289 struct data_queue *queue)
291 struct pci_dev *pci_dev = rt2x00dev_pci(rt2x00dev);
292 struct queue_entry_priv_pci_tx *priv_tx = queue->entries[0].priv_data;
295 pci_free_consistent(pci_dev, dma_size(queue),
296 priv_tx->data, priv_tx->dma);
297 priv_tx->data = NULL;
300 int rt2x00pci_initialize(struct rt2x00_dev *rt2x00dev)
302 struct pci_dev *pci_dev = rt2x00dev_pci(rt2x00dev);
303 struct data_queue *queue;
309 queue_for_each(rt2x00dev, queue) {
310 status = rt2x00pci_alloc_queue_dma(rt2x00dev, queue);
316 * Register interrupt handler.
318 status = request_irq(pci_dev->irq, rt2x00dev->ops->lib->irq_handler,
319 IRQF_SHARED, pci_name(pci_dev), rt2x00dev);
321 ERROR(rt2x00dev, "IRQ %d allocation failed (error %d).\n",
322 pci_dev->irq, status);
329 rt2x00pci_uninitialize(rt2x00dev);
333 EXPORT_SYMBOL_GPL(rt2x00pci_initialize);
335 void rt2x00pci_uninitialize(struct rt2x00_dev *rt2x00dev)
337 struct data_queue *queue;
342 free_irq(rt2x00dev_pci(rt2x00dev)->irq, rt2x00dev);
347 queue_for_each(rt2x00dev, queue)
348 rt2x00pci_free_queue_dma(rt2x00dev, queue);
350 EXPORT_SYMBOL_GPL(rt2x00pci_uninitialize);
353 * PCI driver handlers.
355 static void rt2x00pci_free_reg(struct rt2x00_dev *rt2x00dev)
357 kfree(rt2x00dev->rf);
358 rt2x00dev->rf = NULL;
360 kfree(rt2x00dev->eeprom);
361 rt2x00dev->eeprom = NULL;
363 if (rt2x00dev->csr_addr) {
364 iounmap(rt2x00dev->csr_addr);
365 rt2x00dev->csr_addr = NULL;
369 static int rt2x00pci_alloc_reg(struct rt2x00_dev *rt2x00dev)
371 struct pci_dev *pci_dev = rt2x00dev_pci(rt2x00dev);
373 rt2x00dev->csr_addr = ioremap(pci_resource_start(pci_dev, 0),
374 pci_resource_len(pci_dev, 0));
375 if (!rt2x00dev->csr_addr)
378 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
379 if (!rt2x00dev->eeprom)
382 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
389 ERROR_PROBE("Failed to allocate registers.\n");
391 rt2x00pci_free_reg(rt2x00dev);
396 int rt2x00pci_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
398 struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_data;
399 struct ieee80211_hw *hw;
400 struct rt2x00_dev *rt2x00dev;
403 retval = pci_request_regions(pci_dev, pci_name(pci_dev));
405 ERROR_PROBE("PCI request regions failed.\n");
409 retval = pci_enable_device(pci_dev);
411 ERROR_PROBE("Enable device failed.\n");
412 goto exit_release_regions;
415 pci_set_master(pci_dev);
417 if (pci_set_mwi(pci_dev))
418 ERROR_PROBE("MWI not available.\n");
420 if (pci_set_dma_mask(pci_dev, DMA_64BIT_MASK) &&
421 pci_set_dma_mask(pci_dev, DMA_32BIT_MASK)) {
422 ERROR_PROBE("PCI DMA not supported.\n");
424 goto exit_disable_device;
427 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
429 ERROR_PROBE("Failed to allocate hardware.\n");
431 goto exit_disable_device;
434 pci_set_drvdata(pci_dev, hw);
436 rt2x00dev = hw->priv;
437 rt2x00dev->dev = pci_dev;
438 rt2x00dev->ops = ops;
441 retval = rt2x00pci_alloc_reg(rt2x00dev);
443 goto exit_free_device;
445 retval = rt2x00lib_probe_dev(rt2x00dev);
452 rt2x00pci_free_reg(rt2x00dev);
455 ieee80211_free_hw(hw);
458 if (retval != -EBUSY)
459 pci_disable_device(pci_dev);
461 exit_release_regions:
462 pci_release_regions(pci_dev);
464 pci_set_drvdata(pci_dev, NULL);
468 EXPORT_SYMBOL_GPL(rt2x00pci_probe);
470 void rt2x00pci_remove(struct pci_dev *pci_dev)
472 struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
473 struct rt2x00_dev *rt2x00dev = hw->priv;
476 * Free all allocated data.
478 rt2x00lib_remove_dev(rt2x00dev);
479 rt2x00pci_free_reg(rt2x00dev);
480 ieee80211_free_hw(hw);
483 * Free the PCI device data.
485 pci_set_drvdata(pci_dev, NULL);
486 pci_disable_device(pci_dev);
487 pci_release_regions(pci_dev);
489 EXPORT_SYMBOL_GPL(rt2x00pci_remove);
492 int rt2x00pci_suspend(struct pci_dev *pci_dev, pm_message_t state)
494 struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
495 struct rt2x00_dev *rt2x00dev = hw->priv;
498 retval = rt2x00lib_suspend(rt2x00dev, state);
502 rt2x00pci_free_reg(rt2x00dev);
504 pci_save_state(pci_dev);
505 pci_disable_device(pci_dev);
506 return pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state));
508 EXPORT_SYMBOL_GPL(rt2x00pci_suspend);
510 int rt2x00pci_resume(struct pci_dev *pci_dev)
512 struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
513 struct rt2x00_dev *rt2x00dev = hw->priv;
516 if (pci_set_power_state(pci_dev, PCI_D0) ||
517 pci_enable_device(pci_dev) ||
518 pci_restore_state(pci_dev)) {
519 ERROR(rt2x00dev, "Failed to resume device.\n");
523 retval = rt2x00pci_alloc_reg(rt2x00dev);
527 retval = rt2x00lib_resume(rt2x00dev);
534 rt2x00pci_free_reg(rt2x00dev);
538 EXPORT_SYMBOL_GPL(rt2x00pci_resume);
539 #endif /* CONFIG_PM */
542 * rt2x00pci module information.
544 MODULE_AUTHOR(DRV_PROJECT);
545 MODULE_VERSION(DRV_VERSION);
546 MODULE_DESCRIPTION("rt2x00 pci library");
547 MODULE_LICENSE("GPL");