2 Copyright (C) 2004 - 2007 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.
27 * Set enviroment defines for rt2x00.h
29 #define DRV_NAME "rt2x00pci"
31 #include <linux/dma-mapping.h>
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/pci.h>
37 #include "rt2x00pci.h"
42 int rt2x00pci_beacon_update(struct ieee80211_hw
*hw
, struct sk_buff
*skb
,
43 struct ieee80211_tx_control
*control
)
45 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
46 struct data_ring
*ring
=
47 rt2x00lib_get_ring(rt2x00dev
, IEEE80211_TX_QUEUE_BEACON
);
48 struct data_entry
*entry
= rt2x00_get_data_entry(ring
);
51 * Just in case mac80211 doesn't set this correctly,
52 * but we need this queue set for the descriptor
55 control
->queue
= IEEE80211_TX_QUEUE_BEACON
;
58 * Update the beacon entry.
60 memcpy(entry
->data_addr
, skb
->data
, skb
->len
);
61 rt2x00lib_write_tx_desc(rt2x00dev
, entry
->priv
,
62 (struct ieee80211_hdr
*)skb
->data
,
66 * Enable beacon generation.
68 rt2x00dev
->ops
->lib
->kick_tx_queue(rt2x00dev
, control
->queue
);
72 EXPORT_SYMBOL_GPL(rt2x00pci_beacon_update
);
77 int rt2x00pci_write_tx_data(struct rt2x00_dev
*rt2x00dev
,
78 struct data_ring
*ring
, struct sk_buff
*skb
,
79 struct ieee80211_tx_control
*control
)
81 struct ieee80211_hdr
*ieee80211hdr
= (struct ieee80211_hdr
*)skb
->data
;
82 struct data_entry
*entry
= rt2x00_get_data_entry(ring
);
83 struct data_desc
*txd
= entry
->priv
;
86 if (rt2x00_ring_full(ring
)) {
87 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
91 rt2x00_desc_read(txd
, 0, &word
);
93 if (rt2x00_get_field32(word
, TXD_ENTRY_OWNER_NIC
) ||
94 rt2x00_get_field32(word
, TXD_ENTRY_VALID
)) {
96 "Arrived at non-free entry in the non-full queue %d.\n"
97 "Please file bug report to %s.\n",
98 control
->queue
, DRV_PROJECT
);
99 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
104 memcpy(&entry
->tx_status
.control
, control
, sizeof(*control
));
105 memcpy(entry
->data_addr
, skb
->data
, skb
->len
);
106 rt2x00lib_write_tx_desc(rt2x00dev
, txd
, ieee80211hdr
,
109 rt2x00_ring_index_inc(ring
);
111 if (rt2x00_ring_full(ring
))
112 ieee80211_stop_queue(rt2x00dev
->hw
, control
->queue
);
116 EXPORT_SYMBOL_GPL(rt2x00pci_write_tx_data
);
121 void rt2x00pci_rxdone(struct rt2x00_dev
*rt2x00dev
)
123 struct data_ring
*ring
= rt2x00dev
->rx
;
124 struct data_entry
*entry
;
125 struct data_desc
*rxd
;
135 entry
= rt2x00_get_data_entry(ring
);
137 rt2x00_desc_read(rxd
, 0, &desc
);
139 if (rt2x00_get_field32(desc
, RXD_ENTRY_OWNER_NIC
))
142 retval
= rt2x00dev
->ops
->lib
->fill_rxdone(entry
, &signal
,
143 &rssi
, &ofdm
, &size
);
148 * Allocate the sk_buffer, initialize it and copy
151 skb
= dev_alloc_skb(size
+ NET_IP_ALIGN
);
155 skb_reserve(skb
, NET_IP_ALIGN
);
157 memcpy(skb
->data
, entry
->data_addr
, size
);
160 * Send the frame to rt2x00lib for further processing.
162 rt2x00lib_rxdone(entry
, skb
, signal
, rssi
, ofdm
);
165 if (test_bit(DEVICE_ENABLED_RADIO
, &ring
->rt2x00dev
->flags
)) {
166 rt2x00_set_field32(&desc
, RXD_ENTRY_OWNER_NIC
, 1);
167 rt2x00_desc_write(rxd
, 0, desc
);
170 rt2x00_ring_index_inc(ring
);
173 EXPORT_SYMBOL_GPL(rt2x00pci_rxdone
);
176 * Device initialization handlers.
178 #define priv_offset(__ring, __i) \
180 ring->data_addr + (i * ring->desc_size); \
183 #define data_addr_offset(__ring, __i) \
185 (__ring)->data_addr + \
186 ((__ring)->stats.limit * (__ring)->desc_size) + \
187 ((__i) * (__ring)->data_size); \
190 #define data_dma_offset(__ring, __i) \
192 (__ring)->data_dma + \
193 ((__ring)->stats.limit * (__ring)->desc_size) + \
194 ((__i) * (__ring)->data_size); \
197 static int rt2x00pci_alloc_dma(struct rt2x00_dev
*rt2x00dev
,
198 struct data_ring
*ring
)
203 * Allocate DMA memory for descriptor and buffer.
205 ring
->data_addr
= pci_alloc_consistent(rt2x00dev_pci(rt2x00dev
),
206 rt2x00_get_ring_size(ring
),
208 if (!ring
->data_addr
)
212 * Initialize all ring entries to contain valid
215 for (i
= 0; i
< ring
->stats
.limit
; i
++) {
216 ring
->entry
[i
].priv
= priv_offset(ring
, i
);
217 ring
->entry
[i
].data_addr
= data_addr_offset(ring
, i
);
218 ring
->entry
[i
].data_dma
= data_dma_offset(ring
, i
);
224 static void rt2x00pci_free_dma(struct rt2x00_dev
*rt2x00dev
,
225 struct data_ring
*ring
)
228 pci_free_consistent(rt2x00dev_pci(rt2x00dev
),
229 rt2x00_get_ring_size(ring
),
230 ring
->data_addr
, ring
->data_dma
);
231 ring
->data_addr
= NULL
;
234 int rt2x00pci_initialize(struct rt2x00_dev
*rt2x00dev
)
236 struct pci_dev
*pci_dev
= rt2x00dev_pci(rt2x00dev
);
237 struct data_ring
*ring
;
243 ring_for_each(rt2x00dev
, ring
) {
244 status
= rt2x00pci_alloc_dma(rt2x00dev
, ring
);
250 * Register interrupt handler.
252 status
= request_irq(pci_dev
->irq
, rt2x00dev
->ops
->lib
->irq_handler
,
253 IRQF_SHARED
, pci_name(pci_dev
), rt2x00dev
);
255 ERROR(rt2x00dev
, "IRQ %d allocation failed (error %d).\n",
256 pci_dev
->irq
, status
);
263 rt2x00pci_uninitialize(rt2x00dev
);
267 EXPORT_SYMBOL_GPL(rt2x00pci_initialize
);
269 void rt2x00pci_uninitialize(struct rt2x00_dev
*rt2x00dev
)
271 struct data_ring
*ring
;
276 free_irq(rt2x00dev_pci(rt2x00dev
)->irq
, rt2x00dev
);
281 ring_for_each(rt2x00dev
, ring
)
282 rt2x00pci_free_dma(rt2x00dev
, ring
);
284 EXPORT_SYMBOL_GPL(rt2x00pci_uninitialize
);
287 * PCI driver handlers.
289 static void rt2x00pci_free_reg(struct rt2x00_dev
*rt2x00dev
)
291 kfree(rt2x00dev
->rf
);
292 rt2x00dev
->rf
= NULL
;
294 kfree(rt2x00dev
->eeprom
);
295 rt2x00dev
->eeprom
= NULL
;
297 if (rt2x00dev
->csr_addr
) {
298 iounmap(rt2x00dev
->csr_addr
);
299 rt2x00dev
->csr_addr
= NULL
;
303 static int rt2x00pci_alloc_reg(struct rt2x00_dev
*rt2x00dev
)
305 struct pci_dev
*pci_dev
= rt2x00dev_pci(rt2x00dev
);
307 rt2x00dev
->csr_addr
= ioremap(pci_resource_start(pci_dev
, 0),
308 pci_resource_len(pci_dev
, 0));
309 if (!rt2x00dev
->csr_addr
)
312 rt2x00dev
->eeprom
= kzalloc(rt2x00dev
->ops
->eeprom_size
, GFP_KERNEL
);
313 if (!rt2x00dev
->eeprom
)
316 rt2x00dev
->rf
= kzalloc(rt2x00dev
->ops
->rf_size
, GFP_KERNEL
);
323 ERROR_PROBE("Failed to allocate registers.\n");
325 rt2x00pci_free_reg(rt2x00dev
);
330 int rt2x00pci_probe(struct pci_dev
*pci_dev
, const struct pci_device_id
*id
)
332 struct rt2x00_ops
*ops
= (struct rt2x00_ops
*)id
->driver_data
;
333 struct ieee80211_hw
*hw
;
334 struct rt2x00_dev
*rt2x00dev
;
337 retval
= pci_request_regions(pci_dev
, pci_name(pci_dev
));
339 ERROR_PROBE("PCI request regions failed.\n");
343 retval
= pci_enable_device(pci_dev
);
345 ERROR_PROBE("Enable device failed.\n");
346 goto exit_release_regions
;
349 pci_set_master(pci_dev
);
351 if (pci_set_mwi(pci_dev
))
352 ERROR_PROBE("MWI not available.\n");
354 if (pci_set_dma_mask(pci_dev
, DMA_64BIT_MASK
) &&
355 pci_set_dma_mask(pci_dev
, DMA_32BIT_MASK
)) {
356 ERROR_PROBE("PCI DMA not supported.\n");
358 goto exit_disable_device
;
361 hw
= ieee80211_alloc_hw(sizeof(struct rt2x00_dev
), ops
->hw
);
363 ERROR_PROBE("Failed to allocate hardware.\n");
365 goto exit_disable_device
;
368 pci_set_drvdata(pci_dev
, hw
);
370 rt2x00dev
= hw
->priv
;
371 rt2x00dev
->dev
= pci_dev
;
372 rt2x00dev
->ops
= ops
;
375 retval
= rt2x00pci_alloc_reg(rt2x00dev
);
377 goto exit_free_device
;
379 retval
= rt2x00lib_probe_dev(rt2x00dev
);
386 rt2x00pci_free_reg(rt2x00dev
);
389 ieee80211_free_hw(hw
);
392 if (retval
!= -EBUSY
)
393 pci_disable_device(pci_dev
);
395 exit_release_regions
:
396 pci_release_regions(pci_dev
);
398 pci_set_drvdata(pci_dev
, NULL
);
402 EXPORT_SYMBOL_GPL(rt2x00pci_probe
);
404 void rt2x00pci_remove(struct pci_dev
*pci_dev
)
406 struct ieee80211_hw
*hw
= pci_get_drvdata(pci_dev
);
407 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
410 * Free all allocated data.
412 rt2x00lib_remove_dev(rt2x00dev
);
413 rt2x00pci_free_reg(rt2x00dev
);
414 ieee80211_free_hw(hw
);
417 * Free the PCI device data.
419 pci_set_drvdata(pci_dev
, NULL
);
420 pci_disable_device(pci_dev
);
421 pci_release_regions(pci_dev
);
423 EXPORT_SYMBOL_GPL(rt2x00pci_remove
);
426 int rt2x00pci_suspend(struct pci_dev
*pci_dev
, pm_message_t state
)
428 struct ieee80211_hw
*hw
= pci_get_drvdata(pci_dev
);
429 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
432 retval
= rt2x00lib_suspend(rt2x00dev
, state
);
436 rt2x00pci_free_reg(rt2x00dev
);
438 pci_save_state(pci_dev
);
439 pci_disable_device(pci_dev
);
440 return pci_set_power_state(pci_dev
, pci_choose_state(pci_dev
, state
));
442 EXPORT_SYMBOL_GPL(rt2x00pci_suspend
);
444 int rt2x00pci_resume(struct pci_dev
*pci_dev
)
446 struct ieee80211_hw
*hw
= pci_get_drvdata(pci_dev
);
447 struct rt2x00_dev
*rt2x00dev
= hw
->priv
;
450 if (pci_set_power_state(pci_dev
, PCI_D0
) ||
451 pci_enable_device(pci_dev
) ||
452 pci_restore_state(pci_dev
)) {
453 ERROR(rt2x00dev
, "Failed to resume device.\n");
457 retval
= rt2x00pci_alloc_reg(rt2x00dev
);
461 retval
= rt2x00lib_resume(rt2x00dev
);
468 rt2x00pci_free_reg(rt2x00dev
);
472 EXPORT_SYMBOL_GPL(rt2x00pci_resume
);
473 #endif /* CONFIG_PM */
476 * rt2x00pci module information.
478 MODULE_AUTHOR(DRV_PROJECT
);
479 MODULE_VERSION(DRV_VERSION
);
480 MODULE_DESCRIPTION("rt2x00 library");
481 MODULE_LICENSE("GPL");