Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rt2x00pci.c
Go to the documentation of this file.
1 /*
2  Copyright (C) 2004 - 2009 Ivo van Doorn <[email protected]>
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 #include <linux/slab.h>
31 
32 #include "rt2x00.h"
33 #include "rt2x00pci.h"
34 
35 /*
36  * Register access.
37  */
39  const unsigned int offset,
40  const struct rt2x00_field32 field,
41  u32 *reg)
42 {
43  unsigned int i;
44 
45  if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
46  return 0;
47 
48  for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
49  rt2x00pci_register_read(rt2x00dev, offset, reg);
50  if (!rt2x00_get_field32(*reg, field))
51  return 1;
53  }
54 
55  ERROR(rt2x00dev, "Indirect register access failed: "
56  "offset=0x%.08x, value=0x%.08x\n", offset, *reg);
57  *reg = ~0;
58 
59  return 0;
60 }
62 
64 {
65  struct data_queue *queue = rt2x00dev->rx;
66  struct queue_entry *entry;
67  struct queue_entry_priv_pci *entry_priv;
68  struct skb_frame_desc *skbdesc;
69  int max_rx = 16;
70 
71  while (--max_rx) {
72  entry = rt2x00queue_get_entry(queue, Q_INDEX);
73  entry_priv = entry->priv_data;
74 
75  if (rt2x00dev->ops->lib->get_entry_state(entry))
76  break;
77 
78  /*
79  * Fill in desc fields of the skb descriptor
80  */
81  skbdesc = get_skb_frame_desc(entry->skb);
82  skbdesc->desc = entry_priv->desc;
83  skbdesc->desc_len = entry->queue->desc_size;
84 
85  /*
86  * DMA is already done, notify rt2x00lib that
87  * it finished successfully.
88  */
89  rt2x00lib_dmastart(entry);
90  rt2x00lib_dmadone(entry);
91 
92  /*
93  * Send the frame to rt2x00lib for further processing.
94  */
96  }
97 
98  return !max_rx;
99 }
101 
102 void rt2x00pci_flush_queue(struct data_queue *queue, bool drop)
103 {
104  unsigned int i;
105 
106  for (i = 0; !rt2x00queue_empty(queue) && i < 10; i++)
107  msleep(10);
108 }
110 
111 /*
112  * Device initialization handlers.
113  */
114 static int rt2x00pci_alloc_queue_dma(struct rt2x00_dev *rt2x00dev,
115  struct data_queue *queue)
116 {
117  struct queue_entry_priv_pci *entry_priv;
118  void *addr;
119  dma_addr_t dma;
120  unsigned int i;
121 
122  /*
123  * Allocate DMA memory for descriptor and buffer.
124  */
125  addr = dma_alloc_coherent(rt2x00dev->dev,
126  queue->limit * queue->desc_size,
127  &dma, GFP_KERNEL);
128  if (!addr)
129  return -ENOMEM;
130 
131  memset(addr, 0, queue->limit * queue->desc_size);
132 
133  /*
134  * Initialize all queue entries to contain valid addresses.
135  */
136  for (i = 0; i < queue->limit; i++) {
137  entry_priv = queue->entries[i].priv_data;
138  entry_priv->desc = addr + i * queue->desc_size;
139  entry_priv->desc_dma = dma + i * queue->desc_size;
140  }
141 
142  return 0;
143 }
144 
145 static void rt2x00pci_free_queue_dma(struct rt2x00_dev *rt2x00dev,
146  struct data_queue *queue)
147 {
148  struct queue_entry_priv_pci *entry_priv =
149  queue->entries[0].priv_data;
150 
151  if (entry_priv->desc)
152  dma_free_coherent(rt2x00dev->dev,
153  queue->limit * queue->desc_size,
154  entry_priv->desc, entry_priv->desc_dma);
155  entry_priv->desc = NULL;
156 }
157 
158 int rt2x00pci_initialize(struct rt2x00_dev *rt2x00dev)
159 {
160  struct data_queue *queue;
161  int status;
162 
163  /*
164  * Allocate DMA
165  */
166  queue_for_each(rt2x00dev, queue) {
167  status = rt2x00pci_alloc_queue_dma(rt2x00dev, queue);
168  if (status)
169  goto exit;
170  }
171 
172  /*
173  * Register interrupt handler.
174  */
175  status = request_irq(rt2x00dev->irq,
176  rt2x00dev->ops->lib->irq_handler,
177  IRQF_SHARED, rt2x00dev->name, rt2x00dev);
178  if (status) {
179  ERROR(rt2x00dev, "IRQ %d allocation failed (error %d).\n",
180  rt2x00dev->irq, status);
181  goto exit;
182  }
183 
184  return 0;
185 
186 exit:
187  queue_for_each(rt2x00dev, queue)
188  rt2x00pci_free_queue_dma(rt2x00dev, queue);
189 
190  return status;
191 }
193 
194 void rt2x00pci_uninitialize(struct rt2x00_dev *rt2x00dev)
195 {
196  struct data_queue *queue;
197 
198  /*
199  * Free irq line.
200  */
201  free_irq(rt2x00dev->irq, rt2x00dev);
202 
203  /*
204  * Free DMA
205  */
206  queue_for_each(rt2x00dev, queue)
207  rt2x00pci_free_queue_dma(rt2x00dev, queue);
208 }
210 
211 /*
212  * PCI driver handlers.
213  */
214 static void rt2x00pci_free_reg(struct rt2x00_dev *rt2x00dev)
215 {
216  kfree(rt2x00dev->rf);
217  rt2x00dev->rf = NULL;
218 
219  kfree(rt2x00dev->eeprom);
220  rt2x00dev->eeprom = NULL;
221 
222  if (rt2x00dev->csr.base) {
223  iounmap(rt2x00dev->csr.base);
224  rt2x00dev->csr.base = NULL;
225  }
226 }
227 
228 static int rt2x00pci_alloc_reg(struct rt2x00_dev *rt2x00dev)
229 {
230  struct pci_dev *pci_dev = to_pci_dev(rt2x00dev->dev);
231 
232  rt2x00dev->csr.base = pci_ioremap_bar(pci_dev, 0);
233  if (!rt2x00dev->csr.base)
234  goto exit;
235 
236  rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
237  if (!rt2x00dev->eeprom)
238  goto exit;
239 
240  rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
241  if (!rt2x00dev->rf)
242  goto exit;
243 
244  return 0;
245 
246 exit:
247  ERROR_PROBE("Failed to allocate registers.\n");
248 
249  rt2x00pci_free_reg(rt2x00dev);
250 
251  return -ENOMEM;
252 }
253 
254 int rt2x00pci_probe(struct pci_dev *pci_dev, const struct rt2x00_ops *ops)
255 {
256  struct ieee80211_hw *hw;
257  struct rt2x00_dev *rt2x00dev;
258  int retval;
259  u16 chip;
260 
261  retval = pci_enable_device(pci_dev);
262  if (retval) {
263  ERROR_PROBE("Enable device failed.\n");
264  return retval;
265  }
266 
267  retval = pci_request_regions(pci_dev, pci_name(pci_dev));
268  if (retval) {
269  ERROR_PROBE("PCI request regions failed.\n");
270  goto exit_disable_device;
271  }
272 
273  pci_set_master(pci_dev);
274 
275  if (pci_set_mwi(pci_dev))
276  ERROR_PROBE("MWI not available.\n");
277 
278  if (dma_set_mask(&pci_dev->dev, DMA_BIT_MASK(32))) {
279  ERROR_PROBE("PCI DMA not supported.\n");
280  retval = -EIO;
281  goto exit_release_regions;
282  }
283 
284  hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
285  if (!hw) {
286  ERROR_PROBE("Failed to allocate hardware.\n");
287  retval = -ENOMEM;
288  goto exit_release_regions;
289  }
290 
291  pci_set_drvdata(pci_dev, hw);
292 
293  rt2x00dev = hw->priv;
294  rt2x00dev->dev = &pci_dev->dev;
295  rt2x00dev->ops = ops;
296  rt2x00dev->hw = hw;
297  rt2x00dev->irq = pci_dev->irq;
298  rt2x00dev->name = pci_name(pci_dev);
299 
300  if (pci_is_pcie(pci_dev))
301  rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE);
302  else
303  rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI);
304 
305  retval = rt2x00pci_alloc_reg(rt2x00dev);
306  if (retval)
307  goto exit_free_device;
308 
309  /*
310  * Because rt3290 chip use different efuse offset to read efuse data.
311  * So before read efuse it need to indicate it is the
312  * rt3290 or not.
313  */
314  pci_read_config_word(pci_dev, PCI_DEVICE_ID, &chip);
315  rt2x00dev->chip.rt = chip;
316 
317  retval = rt2x00lib_probe_dev(rt2x00dev);
318  if (retval)
319  goto exit_free_reg;
320 
321  return 0;
322 
323 exit_free_reg:
324  rt2x00pci_free_reg(rt2x00dev);
325 
326 exit_free_device:
327  ieee80211_free_hw(hw);
328 
329 exit_release_regions:
330  pci_release_regions(pci_dev);
331 
332 exit_disable_device:
333  pci_disable_device(pci_dev);
334 
335  pci_set_drvdata(pci_dev, NULL);
336 
337  return retval;
338 }
340 
341 void rt2x00pci_remove(struct pci_dev *pci_dev)
342 {
343  struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
344  struct rt2x00_dev *rt2x00dev = hw->priv;
345 
346  /*
347  * Free all allocated data.
348  */
349  rt2x00lib_remove_dev(rt2x00dev);
350  rt2x00pci_free_reg(rt2x00dev);
351  ieee80211_free_hw(hw);
352 
353  /*
354  * Free the PCI device data.
355  */
356  pci_set_drvdata(pci_dev, NULL);
357  pci_disable_device(pci_dev);
358  pci_release_regions(pci_dev);
359 }
361 
362 #ifdef CONFIG_PM
363 int rt2x00pci_suspend(struct pci_dev *pci_dev, pm_message_t state)
364 {
365  struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
366  struct rt2x00_dev *rt2x00dev = hw->priv;
367  int retval;
368 
369  retval = rt2x00lib_suspend(rt2x00dev, state);
370  if (retval)
371  return retval;
372 
373  pci_save_state(pci_dev);
374  pci_disable_device(pci_dev);
375  return pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state));
376 }
378 
379 int rt2x00pci_resume(struct pci_dev *pci_dev)
380 {
381  struct ieee80211_hw *hw = pci_get_drvdata(pci_dev);
382  struct rt2x00_dev *rt2x00dev = hw->priv;
383 
384  if (pci_set_power_state(pci_dev, PCI_D0) ||
385  pci_enable_device(pci_dev)) {
386  ERROR(rt2x00dev, "Failed to resume device.\n");
387  return -EIO;
388  }
389 
390  pci_restore_state(pci_dev);
391  return rt2x00lib_resume(rt2x00dev);
392 }
394 #endif /* CONFIG_PM */
395 
396 /*
397  * rt2x00pci module information.
398  */
401 MODULE_DESCRIPTION("rt2x00 pci library");
402 MODULE_LICENSE("GPL");