Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6] / drivers / net / wireless / ath5k / dma.c
1 /*
2  * Copyright (c) 2004-2008 Reyk Floeter <reyk@openbsd.org>
3  * Copyright (c) 2006-2008 Nick Kossifidis <mickflemm@gmail.com>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  *
17  */
18
19 /*************************************\
20 * DMA and interrupt masking functions *
21 \*************************************/
22
23 /*
24  * dma.c - DMA and interrupt masking functions
25  *
26  * Here we setup descriptor pointers (rxdp/txdp) start/stop dma engine and
27  * handle queue setup for 5210 chipset (rest are handled on qcu.c).
28  * Also we setup interrupt mask register (IMR) and read the various iterrupt
29  * status registers (ISR).
30  *
31  * TODO: Handle SISR on 5211+ and introduce a function to return the queue
32  * number that resulted the interrupt.
33  */
34
35 #include "ath5k.h"
36 #include "reg.h"
37 #include "debug.h"
38 #include "base.h"
39
40 /*********\
41 * Receive *
42 \*********/
43
44 /**
45  * ath5k_hw_start_rx_dma - Start DMA receive
46  *
47  * @ah: The &struct ath5k_hw
48  */
49 void ath5k_hw_start_rx_dma(struct ath5k_hw *ah)
50 {
51         ATH5K_TRACE(ah->ah_sc);
52         ath5k_hw_reg_write(ah, AR5K_CR_RXE, AR5K_CR);
53         ath5k_hw_reg_read(ah, AR5K_CR);
54 }
55
56 /**
57  * ath5k_hw_stop_rx_dma - Stop DMA receive
58  *
59  * @ah: The &struct ath5k_hw
60  */
61 int ath5k_hw_stop_rx_dma(struct ath5k_hw *ah)
62 {
63         unsigned int i;
64
65         ATH5K_TRACE(ah->ah_sc);
66         ath5k_hw_reg_write(ah, AR5K_CR_RXD, AR5K_CR);
67
68         /*
69          * It may take some time to disable the DMA receive unit
70          */
71         for (i = 1000; i > 0 &&
72                         (ath5k_hw_reg_read(ah, AR5K_CR) & AR5K_CR_RXE) != 0;
73                         i--)
74                 udelay(10);
75
76         return i ? 0 : -EBUSY;
77 }
78
79 /**
80  * ath5k_hw_get_rxdp - Get RX Descriptor's address
81  *
82  * @ah: The &struct ath5k_hw
83  *
84  * XXX: Is RXDP read and clear ?
85  */
86 u32 ath5k_hw_get_rxdp(struct ath5k_hw *ah)
87 {
88         return ath5k_hw_reg_read(ah, AR5K_RXDP);
89 }
90
91 /**
92  * ath5k_hw_set_rxdp - Set RX Descriptor's address
93  *
94  * @ah: The &struct ath5k_hw
95  * @phys_addr: RX descriptor address
96  *
97  * XXX: Should we check if rx is enabled before setting rxdp ?
98  */
99 void ath5k_hw_set_rxdp(struct ath5k_hw *ah, u32 phys_addr)
100 {
101         ATH5K_TRACE(ah->ah_sc);
102
103         ath5k_hw_reg_write(ah, phys_addr, AR5K_RXDP);
104 }
105
106
107 /**********\
108 * Transmit *
109 \**********/
110
111 /**
112  * ath5k_hw_start_tx_dma - Start DMA transmit for a specific queue
113  *
114  * @ah: The &struct ath5k_hw
115  * @queue: The hw queue number
116  *
117  * Start DMA transmit for a specific queue and since 5210 doesn't have
118  * QCU/DCU, set up queue parameters for 5210 here based on queue type (one
119  * queue for normal data and one queue for beacons). For queue setup
120  * on newer chips check out qcu.c. Returns -EINVAL if queue number is out
121  * of range or if queue is already disabled.
122  *
123  * NOTE: Must be called after setting up tx control descriptor for that
124  * queue (see below).
125  */
126 int ath5k_hw_start_tx_dma(struct ath5k_hw *ah, unsigned int queue)
127 {
128         u32 tx_queue;
129
130         ATH5K_TRACE(ah->ah_sc);
131         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
132
133         /* Return if queue is declared inactive */
134         if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
135                 return -EIO;
136
137         if (ah->ah_version == AR5K_AR5210) {
138                 tx_queue = ath5k_hw_reg_read(ah, AR5K_CR);
139
140                 /*
141                  * Set the queue by type on 5210
142                  */
143                 switch (ah->ah_txq[queue].tqi_type) {
144                 case AR5K_TX_QUEUE_DATA:
145                         tx_queue |= AR5K_CR_TXE0 & ~AR5K_CR_TXD0;
146                         break;
147                 case AR5K_TX_QUEUE_BEACON:
148                         tx_queue |= AR5K_CR_TXE1 & ~AR5K_CR_TXD1;
149                         ath5k_hw_reg_write(ah, AR5K_BCR_TQ1V | AR5K_BCR_BDMAE,
150                                         AR5K_BSR);
151                         break;
152                 case AR5K_TX_QUEUE_CAB:
153                         tx_queue |= AR5K_CR_TXE1 & ~AR5K_CR_TXD1;
154                         ath5k_hw_reg_write(ah, AR5K_BCR_TQ1FV | AR5K_BCR_TQ1V |
155                                 AR5K_BCR_BDMAE, AR5K_BSR);
156                         break;
157                 default:
158                         return -EINVAL;
159                 }
160                 /* Start queue */
161                 ath5k_hw_reg_write(ah, tx_queue, AR5K_CR);
162                 ath5k_hw_reg_read(ah, AR5K_CR);
163         } else {
164                 /* Return if queue is disabled */
165                 if (AR5K_REG_READ_Q(ah, AR5K_QCU_TXD, queue))
166                         return -EIO;
167
168                 /* Start queue */
169                 AR5K_REG_WRITE_Q(ah, AR5K_QCU_TXE, queue);
170         }
171
172         return 0;
173 }
174
175 /**
176  * ath5k_hw_stop_tx_dma - Stop DMA transmit on a specific queue
177  *
178  * @ah: The &struct ath5k_hw
179  * @queue: The hw queue number
180  *
181  * Stop DMA transmit on a specific hw queue and drain queue so we don't
182  * have any pending frames. Returns -EBUSY if we still have pending frames,
183  * -EINVAL if queue number is out of range.
184  *
185  */
186 int ath5k_hw_stop_tx_dma(struct ath5k_hw *ah, unsigned int queue)
187 {
188         unsigned int i = 40;
189         u32 tx_queue, pending;
190
191         ATH5K_TRACE(ah->ah_sc);
192         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
193
194         /* Return if queue is declared inactive */
195         if (ah->ah_txq[queue].tqi_type == AR5K_TX_QUEUE_INACTIVE)
196                 return -EIO;
197
198         if (ah->ah_version == AR5K_AR5210) {
199                 tx_queue = ath5k_hw_reg_read(ah, AR5K_CR);
200
201                 /*
202                  * Set by queue type
203                  */
204                 switch (ah->ah_txq[queue].tqi_type) {
205                 case AR5K_TX_QUEUE_DATA:
206                         tx_queue |= AR5K_CR_TXD0 & ~AR5K_CR_TXE0;
207                         break;
208                 case AR5K_TX_QUEUE_BEACON:
209                 case AR5K_TX_QUEUE_CAB:
210                         /* XXX Fix me... */
211                         tx_queue |= AR5K_CR_TXD1 & ~AR5K_CR_TXD1;
212                         ath5k_hw_reg_write(ah, 0, AR5K_BSR);
213                         break;
214                 default:
215                         return -EINVAL;
216                 }
217
218                 /* Stop queue */
219                 ath5k_hw_reg_write(ah, tx_queue, AR5K_CR);
220                 ath5k_hw_reg_read(ah, AR5K_CR);
221         } else {
222                 /*
223                  * Schedule TX disable and wait until queue is empty
224                  */
225                 AR5K_REG_WRITE_Q(ah, AR5K_QCU_TXD, queue);
226
227                 /*Check for pending frames*/
228                 do {
229                         pending = ath5k_hw_reg_read(ah,
230                                 AR5K_QUEUE_STATUS(queue)) &
231                                 AR5K_QCU_STS_FRMPENDCNT;
232                         udelay(100);
233                 } while (--i && pending);
234
235                 /* For 2413+ order PCU to drop packets using
236                  * QUIET mechanism */
237                 if (ah->ah_mac_version >= (AR5K_SREV_AR2414 >> 4) &&
238                 pending){
239                         /* Set periodicity and duration */
240                         ath5k_hw_reg_write(ah,
241                                 AR5K_REG_SM(100, AR5K_QUIET_CTL2_QT_PER)|
242                                 AR5K_REG_SM(10, AR5K_QUIET_CTL2_QT_DUR),
243                                 AR5K_QUIET_CTL2);
244
245                         /* Enable quiet period for current TSF */
246                         ath5k_hw_reg_write(ah,
247                                 AR5K_QUIET_CTL1_QT_EN |
248                                 AR5K_REG_SM(ath5k_hw_reg_read(ah,
249                                                 AR5K_TSF_L32_5211) >> 10,
250                                                 AR5K_QUIET_CTL1_NEXT_QT_TSF),
251                                 AR5K_QUIET_CTL1);
252
253                         /* Force channel idle high */
254                         AR5K_REG_ENABLE_BITS(ah, AR5K_DIAG_SW_5211,
255                                         AR5K_DIAG_SW_CHANEL_IDLE_HIGH);
256
257                         /* Wait a while and disable mechanism */
258                         udelay(200);
259                         AR5K_REG_DISABLE_BITS(ah, AR5K_QUIET_CTL1,
260                                                 AR5K_QUIET_CTL1_QT_EN);
261
262                         /* Re-check for pending frames */
263                         i = 40;
264                         do {
265                                 pending = ath5k_hw_reg_read(ah,
266                                         AR5K_QUEUE_STATUS(queue)) &
267                                         AR5K_QCU_STS_FRMPENDCNT;
268                                 udelay(100);
269                         } while (--i && pending);
270
271                         AR5K_REG_DISABLE_BITS(ah, AR5K_DIAG_SW_5211,
272                                         AR5K_DIAG_SW_CHANEL_IDLE_HIGH);
273                 }
274
275                 /* Clear register */
276                 ath5k_hw_reg_write(ah, 0, AR5K_QCU_TXD);
277                 if (pending)
278                         return -EBUSY;
279         }
280
281         /* TODO: Check for success on 5210 else return error */
282         return 0;
283 }
284
285 /**
286  * ath5k_hw_get_txdp - Get TX Descriptor's address for a specific queue
287  *
288  * @ah: The &struct ath5k_hw
289  * @queue: The hw queue number
290  *
291  * Get TX descriptor's address for a specific queue. For 5210 we ignore
292  * the queue number and use tx queue type since we only have 2 queues.
293  * We use TXDP0 for normal data queue and TXDP1 for beacon queue.
294  * For newer chips with QCU/DCU we just read the corresponding TXDP register.
295  *
296  * XXX: Is TXDP read and clear ?
297  */
298 u32 ath5k_hw_get_txdp(struct ath5k_hw *ah, unsigned int queue)
299 {
300         u16 tx_reg;
301
302         ATH5K_TRACE(ah->ah_sc);
303         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
304
305         /*
306          * Get the transmit queue descriptor pointer from the selected queue
307          */
308         /*5210 doesn't have QCU*/
309         if (ah->ah_version == AR5K_AR5210) {
310                 switch (ah->ah_txq[queue].tqi_type) {
311                 case AR5K_TX_QUEUE_DATA:
312                         tx_reg = AR5K_NOQCU_TXDP0;
313                         break;
314                 case AR5K_TX_QUEUE_BEACON:
315                 case AR5K_TX_QUEUE_CAB:
316                         tx_reg = AR5K_NOQCU_TXDP1;
317                         break;
318                 default:
319                         return 0xffffffff;
320                 }
321         } else {
322                 tx_reg = AR5K_QUEUE_TXDP(queue);
323         }
324
325         return ath5k_hw_reg_read(ah, tx_reg);
326 }
327
328 /**
329  * ath5k_hw_set_txdp - Set TX Descriptor's address for a specific queue
330  *
331  * @ah: The &struct ath5k_hw
332  * @queue: The hw queue number
333  *
334  * Set TX descriptor's address for a specific queue. For 5210 we ignore
335  * the queue number and we use tx queue type since we only have 2 queues
336  * so as above we use TXDP0 for normal data queue and TXDP1 for beacon queue.
337  * For newer chips with QCU/DCU we just set the corresponding TXDP register.
338  * Returns -EINVAL if queue type is invalid for 5210 and -EIO if queue is still
339  * active.
340  */
341 int ath5k_hw_set_txdp(struct ath5k_hw *ah, unsigned int queue, u32 phys_addr)
342 {
343         u16 tx_reg;
344
345         ATH5K_TRACE(ah->ah_sc);
346         AR5K_ASSERT_ENTRY(queue, ah->ah_capabilities.cap_queues.q_tx_num);
347
348         /*
349          * Set the transmit queue descriptor pointer register by type
350          * on 5210
351          */
352         if (ah->ah_version == AR5K_AR5210) {
353                 switch (ah->ah_txq[queue].tqi_type) {
354                 case AR5K_TX_QUEUE_DATA:
355                         tx_reg = AR5K_NOQCU_TXDP0;
356                         break;
357                 case AR5K_TX_QUEUE_BEACON:
358                 case AR5K_TX_QUEUE_CAB:
359                         tx_reg = AR5K_NOQCU_TXDP1;
360                         break;
361                 default:
362                         return -EINVAL;
363                 }
364         } else {
365                 /*
366                  * Set the transmit queue descriptor pointer for
367                  * the selected queue on QCU for 5211+
368                  * (this won't work if the queue is still active)
369                  */
370                 if (AR5K_REG_READ_Q(ah, AR5K_QCU_TXE, queue))
371                         return -EIO;
372
373                 tx_reg = AR5K_QUEUE_TXDP(queue);
374         }
375
376         /* Set descriptor pointer */
377         ath5k_hw_reg_write(ah, phys_addr, tx_reg);
378
379         return 0;
380 }
381
382 /**
383  * ath5k_hw_update_tx_triglevel - Update tx trigger level
384  *
385  * @ah: The &struct ath5k_hw
386  * @increase: Flag to force increase of trigger level
387  *
388  * This function increases/decreases the tx trigger level for the tx fifo
389  * buffer (aka FIFO threshold) that is used to indicate when PCU flushes
390  * the buffer and transmits it's data. Lowering this results sending small
391  * frames more quickly but can lead to tx underruns, raising it a lot can
392  * result other problems (i think bmiss is related). Right now we start with
393  * the lowest possible (64Bytes) and if we get tx underrun we increase it using
394  * the increase flag. Returns -EIO if we have have reached maximum/minimum.
395  *
396  * XXX: Link this with tx DMA size ?
397  * XXX: Use it to save interrupts ?
398  * TODO: Needs testing, i think it's related to bmiss...
399  */
400 int ath5k_hw_update_tx_triglevel(struct ath5k_hw *ah, bool increase)
401 {
402         u32 trigger_level, imr;
403         int ret = -EIO;
404
405         ATH5K_TRACE(ah->ah_sc);
406
407         /*
408          * Disable interrupts by setting the mask
409          */
410         imr = ath5k_hw_set_imr(ah, ah->ah_imr & ~AR5K_INT_GLOBAL);
411
412         trigger_level = AR5K_REG_MS(ath5k_hw_reg_read(ah, AR5K_TXCFG),
413                         AR5K_TXCFG_TXFULL);
414
415         if (!increase) {
416                 if (--trigger_level < AR5K_TUNE_MIN_TX_FIFO_THRES)
417                         goto done;
418         } else
419                 trigger_level +=
420                         ((AR5K_TUNE_MAX_TX_FIFO_THRES - trigger_level) / 2);
421
422         /*
423          * Update trigger level on success
424          */
425         if (ah->ah_version == AR5K_AR5210)
426                 ath5k_hw_reg_write(ah, trigger_level, AR5K_TRIG_LVL);
427         else
428                 AR5K_REG_WRITE_BITS(ah, AR5K_TXCFG,
429                                 AR5K_TXCFG_TXFULL, trigger_level);
430
431         ret = 0;
432
433 done:
434         /*
435          * Restore interrupt mask
436          */
437         ath5k_hw_set_imr(ah, imr);
438
439         return ret;
440 }
441
442 /*******************\
443 * Interrupt masking *
444 \*******************/
445
446 /**
447  * ath5k_hw_is_intr_pending - Check if we have pending interrupts
448  *
449  * @ah: The &struct ath5k_hw
450  *
451  * Check if we have pending interrupts to process. Returns 1 if we
452  * have pending interrupts and 0 if we haven't.
453  */
454 bool ath5k_hw_is_intr_pending(struct ath5k_hw *ah)
455 {
456         ATH5K_TRACE(ah->ah_sc);
457         return ath5k_hw_reg_read(ah, AR5K_INTPEND) == 1 ? 1 : 0;
458 }
459
460 /**
461  * ath5k_hw_get_isr - Get interrupt status
462  *
463  * @ah: The @struct ath5k_hw
464  * @interrupt_mask: Driver's interrupt mask used to filter out
465  * interrupts in sw.
466  *
467  * This function is used inside our interrupt handler to determine the reason
468  * for the interrupt by reading Primary Interrupt Status Register. Returns an
469  * abstract interrupt status mask which is mostly ISR with some uncommon bits
470  * being mapped on some standard non hw-specific positions
471  * (check out &ath5k_int).
472  *
473  * NOTE: We use read-and-clear register, so after this function is called ISR
474  * is zeroed.
475  *
476  * XXX: Why filter interrupts in sw with interrupt_mask ? No benefit at all
477  * plus it can be misleading (one might thing that we save interrupts this way)
478  */
479 int ath5k_hw_get_isr(struct ath5k_hw *ah, enum ath5k_int *interrupt_mask)
480 {
481         u32 data;
482
483         ATH5K_TRACE(ah->ah_sc);
484
485         /*
486          * Read interrupt status from the Interrupt Status register
487          * on 5210
488          */
489         if (ah->ah_version == AR5K_AR5210) {
490                 data = ath5k_hw_reg_read(ah, AR5K_ISR);
491                 if (unlikely(data == AR5K_INT_NOCARD)) {
492                         *interrupt_mask = data;
493                         return -ENODEV;
494                 }
495         } else {
496                 /*
497                  * Read interrupt status from the Read-And-Clear
498                  * shadow register.
499                  * Note: PISR/SISR Not available on 5210
500                  */
501                 data = ath5k_hw_reg_read(ah, AR5K_RAC_PISR);
502         }
503
504         /*
505          * Get abstract interrupt mask (driver-compatible)
506          */
507         *interrupt_mask = (data & AR5K_INT_COMMON) & ah->ah_imr;
508
509         if (unlikely(data == AR5K_INT_NOCARD))
510                 return -ENODEV;
511
512         if (data & (AR5K_ISR_RXOK | AR5K_ISR_RXERR))
513                 *interrupt_mask |= AR5K_INT_RX;
514
515         if (data & (AR5K_ISR_TXOK | AR5K_ISR_TXERR
516                 | AR5K_ISR_TXDESC | AR5K_ISR_TXEOL))
517                 *interrupt_mask |= AR5K_INT_TX;
518
519         if (ah->ah_version != AR5K_AR5210) {
520                 /*HIU = Host Interface Unit (PCI etc)*/
521                 if (unlikely(data & (AR5K_ISR_HIUERR)))
522                         *interrupt_mask |= AR5K_INT_FATAL;
523
524                 /*Beacon Not Ready*/
525                 if (unlikely(data & (AR5K_ISR_BNR)))
526                         *interrupt_mask |= AR5K_INT_BNR;
527         }
528
529         /*
530          * XXX: BMISS interrupts may occur after association.
531          * I found this on 5210 code but it needs testing. If this is
532          * true we should disable them before assoc and re-enable them
533          * after a successfull assoc + some jiffies.
534          */
535 #if 0
536         interrupt_mask &= ~AR5K_INT_BMISS;
537 #endif
538
539         /*
540          * In case we didn't handle anything,
541          * print the register value.
542          */
543         if (unlikely(*interrupt_mask == 0 && net_ratelimit()))
544                 ATH5K_PRINTF("0x%08x\n", data);
545
546         return 0;
547 }
548
549 /**
550  * ath5k_hw_set_imr - Set interrupt mask
551  *
552  * @ah: The &struct ath5k_hw
553  * @new_mask: The new interrupt mask to be set
554  *
555  * Set the interrupt mask in hw to save interrupts. We do that by mapping
556  * ath5k_int bits to hw-specific bits to remove abstraction and writing
557  * Interrupt Mask Register.
558  */
559 enum ath5k_int ath5k_hw_set_imr(struct ath5k_hw *ah, enum ath5k_int new_mask)
560 {
561         enum ath5k_int old_mask, int_mask;
562
563         /*
564          * Disable card interrupts to prevent any race conditions
565          * (they will be re-enabled afterwards).
566          */
567         ath5k_hw_reg_write(ah, AR5K_IER_DISABLE, AR5K_IER);
568         ath5k_hw_reg_read(ah, AR5K_IER);
569
570         old_mask = ah->ah_imr;
571
572         /*
573          * Add additional, chipset-dependent interrupt mask flags
574          * and write them to the IMR (interrupt mask register).
575          */
576         int_mask = new_mask & AR5K_INT_COMMON;
577
578         if (new_mask & AR5K_INT_RX)
579                 int_mask |= AR5K_IMR_RXOK | AR5K_IMR_RXERR | AR5K_IMR_RXORN |
580                         AR5K_IMR_RXDESC;
581
582         if (new_mask & AR5K_INT_TX)
583                 int_mask |= AR5K_IMR_TXOK | AR5K_IMR_TXERR | AR5K_IMR_TXDESC |
584                         AR5K_IMR_TXURN;
585
586         if (ah->ah_version != AR5K_AR5210) {
587                 if (new_mask & AR5K_INT_FATAL) {
588                         int_mask |= AR5K_IMR_HIUERR;
589                         AR5K_REG_ENABLE_BITS(ah, AR5K_SIMR2, AR5K_SIMR2_MCABT |
590                                         AR5K_SIMR2_SSERR | AR5K_SIMR2_DPERR);
591                 }
592         }
593
594         ath5k_hw_reg_write(ah, int_mask, AR5K_PIMR);
595
596         /* Store new interrupt mask */
597         ah->ah_imr = new_mask;
598
599         /* ..re-enable interrupts */
600         ath5k_hw_reg_write(ah, AR5K_IER_ENABLE, AR5K_IER);
601         ath5k_hw_reg_read(ah, AR5K_IER);
602
603         return old_mask;
604 }
605