1
2
3
4
5
6
7
8
9
10
11
12
13#include "b43legacy.h"
14#include "pio.h"
15#include "main.h"
16#include "xmit.h"
17
18#include <linux/delay.h>
19#include <linux/slab.h>
20
21
22static void tx_start(struct b43legacy_pioqueue *queue)
23{
24 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
25 B43legacy_PIO_TXCTL_INIT);
26}
27
28static void tx_octet(struct b43legacy_pioqueue *queue,
29 u8 octet)
30{
31 if (queue->need_workarounds) {
32 b43legacy_pio_write(queue, B43legacy_PIO_TXDATA, octet);
33 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
34 B43legacy_PIO_TXCTL_WRITELO);
35 } else {
36 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
37 B43legacy_PIO_TXCTL_WRITELO);
38 b43legacy_pio_write(queue, B43legacy_PIO_TXDATA, octet);
39 }
40}
41
42static u16 tx_get_next_word(const u8 *txhdr,
43 const u8 *packet,
44 size_t txhdr_size,
45 unsigned int *pos)
46{
47 const u8 *source;
48 unsigned int i = *pos;
49 u16 ret;
50
51 if (i < txhdr_size)
52 source = txhdr;
53 else {
54 source = packet;
55 i -= txhdr_size;
56 }
57 ret = le16_to_cpu(*((__le16 *)(source + i)));
58 *pos += 2;
59
60 return ret;
61}
62
63static void tx_data(struct b43legacy_pioqueue *queue,
64 u8 *txhdr,
65 const u8 *packet,
66 unsigned int octets)
67{
68 u16 data;
69 unsigned int i = 0;
70
71 if (queue->need_workarounds) {
72 data = tx_get_next_word(txhdr, packet,
73 sizeof(struct b43legacy_txhdr_fw3), &i);
74 b43legacy_pio_write(queue, B43legacy_PIO_TXDATA, data);
75 }
76 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
77 B43legacy_PIO_TXCTL_WRITELO |
78 B43legacy_PIO_TXCTL_WRITEHI);
79 while (i < octets - 1) {
80 data = tx_get_next_word(txhdr, packet,
81 sizeof(struct b43legacy_txhdr_fw3), &i);
82 b43legacy_pio_write(queue, B43legacy_PIO_TXDATA, data);
83 }
84 if (octets % 2)
85 tx_octet(queue, packet[octets -
86 sizeof(struct b43legacy_txhdr_fw3) - 1]);
87}
88
89static void tx_complete(struct b43legacy_pioqueue *queue,
90 struct sk_buff *skb)
91{
92 if (queue->need_workarounds) {
93 b43legacy_pio_write(queue, B43legacy_PIO_TXDATA,
94 skb->data[skb->len - 1]);
95 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
96 B43legacy_PIO_TXCTL_WRITELO |
97 B43legacy_PIO_TXCTL_COMPLETE);
98 } else
99 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
100 B43legacy_PIO_TXCTL_COMPLETE);
101}
102
103static u16 generate_cookie(struct b43legacy_pioqueue *queue,
104 struct b43legacy_pio_txpacket *packet)
105{
106 u16 cookie = 0x0000;
107 int packetindex;
108
109
110
111
112
113 switch (queue->mmio_base) {
114 case B43legacy_MMIO_PIO1_BASE:
115 break;
116 case B43legacy_MMIO_PIO2_BASE:
117 cookie = 0x1000;
118 break;
119 case B43legacy_MMIO_PIO3_BASE:
120 cookie = 0x2000;
121 break;
122 case B43legacy_MMIO_PIO4_BASE:
123 cookie = 0x3000;
124 break;
125 default:
126 B43legacy_WARN_ON(1);
127 }
128 packetindex = pio_txpacket_getindex(packet);
129 B43legacy_WARN_ON(!(((u16)packetindex & 0xF000) == 0x0000));
130 cookie |= (u16)packetindex;
131
132 return cookie;
133}
134
135static
136struct b43legacy_pioqueue *parse_cookie(struct b43legacy_wldev *dev,
137 u16 cookie,
138 struct b43legacy_pio_txpacket **packet)
139{
140 struct b43legacy_pio *pio = &dev->pio;
141 struct b43legacy_pioqueue *queue = NULL;
142 int packetindex;
143
144 switch (cookie & 0xF000) {
145 case 0x0000:
146 queue = pio->queue0;
147 break;
148 case 0x1000:
149 queue = pio->queue1;
150 break;
151 case 0x2000:
152 queue = pio->queue2;
153 break;
154 case 0x3000:
155 queue = pio->queue3;
156 break;
157 default:
158 B43legacy_WARN_ON(1);
159 }
160 packetindex = (cookie & 0x0FFF);
161 B43legacy_WARN_ON(!(packetindex >= 0 && packetindex
162 < B43legacy_PIO_MAXTXPACKETS));
163 *packet = &(queue->tx_packets_cache[packetindex]);
164
165 return queue;
166}
167
168union txhdr_union {
169 struct b43legacy_txhdr_fw3 txhdr_fw3;
170};
171
172static int pio_tx_write_fragment(struct b43legacy_pioqueue *queue,
173 struct sk_buff *skb,
174 struct b43legacy_pio_txpacket *packet,
175 size_t txhdr_size)
176{
177 union txhdr_union txhdr_data;
178 u8 *txhdr = NULL;
179 unsigned int octets;
180 int err;
181
182 txhdr = (u8 *)(&txhdr_data.txhdr_fw3);
183
184 B43legacy_WARN_ON(skb_shinfo(skb)->nr_frags != 0);
185 err = b43legacy_generate_txhdr(queue->dev,
186 txhdr, skb->data, skb->len,
187 IEEE80211_SKB_CB(skb),
188 generate_cookie(queue, packet));
189 if (err)
190 return err;
191
192 tx_start(queue);
193 octets = skb->len + txhdr_size;
194 if (queue->need_workarounds)
195 octets--;
196 tx_data(queue, txhdr, (u8 *)skb->data, octets);
197 tx_complete(queue, skb);
198
199 return 0;
200}
201
202static void free_txpacket(struct b43legacy_pio_txpacket *packet,
203 int irq_context)
204{
205 struct b43legacy_pioqueue *queue = packet->queue;
206
207 if (packet->skb) {
208 if (irq_context)
209 dev_kfree_skb_irq(packet->skb);
210 else
211 dev_kfree_skb(packet->skb);
212 }
213 list_move(&packet->list, &queue->txfree);
214 queue->nr_txfree++;
215}
216
217static int pio_tx_packet(struct b43legacy_pio_txpacket *packet)
218{
219 struct b43legacy_pioqueue *queue = packet->queue;
220 struct sk_buff *skb = packet->skb;
221 u16 octets;
222 int err;
223
224 octets = (u16)skb->len + sizeof(struct b43legacy_txhdr_fw3);
225 if (queue->tx_devq_size < octets) {
226 b43legacywarn(queue->dev->wl, "PIO queue too small. "
227 "Dropping packet.\n");
228
229 free_txpacket(packet, 1);
230 return 0;
231 }
232 B43legacy_WARN_ON(queue->tx_devq_packets >
233 B43legacy_PIO_MAXTXDEVQPACKETS);
234 B43legacy_WARN_ON(queue->tx_devq_used > queue->tx_devq_size);
235
236
237
238
239 if (queue->tx_devq_packets == B43legacy_PIO_MAXTXDEVQPACKETS)
240 return -EBUSY;
241 if (queue->tx_devq_used + octets > queue->tx_devq_size)
242 return -EBUSY;
243
244 err = pio_tx_write_fragment(queue, skb, packet,
245 sizeof(struct b43legacy_txhdr_fw3));
246 if (unlikely(err == -ENOKEY)) {
247
248
249 free_txpacket(packet, 1);
250 return 0;
251 }
252
253
254
255
256 queue->tx_devq_packets++;
257 queue->tx_devq_used += octets;
258
259
260
261
262 list_move_tail(&packet->list, &queue->txrunning);
263
264 return 0;
265}
266
267static void tx_tasklet(struct tasklet_struct *t)
268{
269 struct b43legacy_pioqueue *queue = from_tasklet(queue, t, txtask);
270 struct b43legacy_wldev *dev = queue->dev;
271 unsigned long flags;
272 struct b43legacy_pio_txpacket *packet, *tmp_packet;
273 int err;
274 u16 txctl;
275
276 spin_lock_irqsave(&dev->wl->irq_lock, flags);
277 if (queue->tx_frozen)
278 goto out_unlock;
279 txctl = b43legacy_pio_read(queue, B43legacy_PIO_TXCTL);
280 if (txctl & B43legacy_PIO_TXCTL_SUSPEND)
281 goto out_unlock;
282
283 list_for_each_entry_safe(packet, tmp_packet, &queue->txqueue, list) {
284
285
286
287
288
289
290
291 err = pio_tx_packet(packet);
292 if (err)
293 break;
294 }
295out_unlock:
296 spin_unlock_irqrestore(&dev->wl->irq_lock, flags);
297}
298
299static void setup_txqueues(struct b43legacy_pioqueue *queue)
300{
301 struct b43legacy_pio_txpacket *packet;
302 int i;
303
304 queue->nr_txfree = B43legacy_PIO_MAXTXPACKETS;
305 for (i = 0; i < B43legacy_PIO_MAXTXPACKETS; i++) {
306 packet = &(queue->tx_packets_cache[i]);
307
308 packet->queue = queue;
309 INIT_LIST_HEAD(&packet->list);
310
311 list_add(&packet->list, &queue->txfree);
312 }
313}
314
315static
316struct b43legacy_pioqueue *b43legacy_setup_pioqueue(struct b43legacy_wldev *dev,
317 u16 pio_mmio_base)
318{
319 struct b43legacy_pioqueue *queue;
320 u32 value;
321 u16 qsize;
322
323 queue = kzalloc(sizeof(*queue), GFP_KERNEL);
324 if (!queue)
325 goto out;
326
327 queue->dev = dev;
328 queue->mmio_base = pio_mmio_base;
329 queue->need_workarounds = (dev->dev->id.revision < 3);
330
331 INIT_LIST_HEAD(&queue->txfree);
332 INIT_LIST_HEAD(&queue->txqueue);
333 INIT_LIST_HEAD(&queue->txrunning);
334 tasklet_setup(&queue->txtask, tx_tasklet);
335
336 value = b43legacy_read32(dev, B43legacy_MMIO_MACCTL);
337 value &= ~B43legacy_MACCTL_BE;
338 b43legacy_write32(dev, B43legacy_MMIO_MACCTL, value);
339
340 qsize = b43legacy_read16(dev, queue->mmio_base
341 + B43legacy_PIO_TXQBUFSIZE);
342 if (qsize == 0) {
343 b43legacyerr(dev->wl, "This card does not support PIO "
344 "operation mode. Please use DMA mode "
345 "(module parameter pio=0).\n");
346 goto err_freequeue;
347 }
348 if (qsize <= B43legacy_PIO_TXQADJUST) {
349 b43legacyerr(dev->wl, "PIO tx device-queue too small (%u)\n",
350 qsize);
351 goto err_freequeue;
352 }
353 qsize -= B43legacy_PIO_TXQADJUST;
354 queue->tx_devq_size = qsize;
355
356 setup_txqueues(queue);
357
358out:
359 return queue;
360
361err_freequeue:
362 kfree(queue);
363 queue = NULL;
364 goto out;
365}
366
367static void cancel_transfers(struct b43legacy_pioqueue *queue)
368{
369 struct b43legacy_pio_txpacket *packet, *tmp_packet;
370
371 tasklet_kill(&queue->txtask);
372
373 list_for_each_entry_safe(packet, tmp_packet, &queue->txrunning, list)
374 free_txpacket(packet, 0);
375 list_for_each_entry_safe(packet, tmp_packet, &queue->txqueue, list)
376 free_txpacket(packet, 0);
377}
378
379static void b43legacy_destroy_pioqueue(struct b43legacy_pioqueue *queue)
380{
381 if (!queue)
382 return;
383
384 cancel_transfers(queue);
385 kfree(queue);
386}
387
388void b43legacy_pio_free(struct b43legacy_wldev *dev)
389{
390 struct b43legacy_pio *pio;
391
392 if (!b43legacy_using_pio(dev))
393 return;
394 pio = &dev->pio;
395
396 b43legacy_destroy_pioqueue(pio->queue3);
397 pio->queue3 = NULL;
398 b43legacy_destroy_pioqueue(pio->queue2);
399 pio->queue2 = NULL;
400 b43legacy_destroy_pioqueue(pio->queue1);
401 pio->queue1 = NULL;
402 b43legacy_destroy_pioqueue(pio->queue0);
403 pio->queue0 = NULL;
404}
405
406int b43legacy_pio_init(struct b43legacy_wldev *dev)
407{
408 struct b43legacy_pio *pio = &dev->pio;
409 struct b43legacy_pioqueue *queue;
410 int err = -ENOMEM;
411
412 queue = b43legacy_setup_pioqueue(dev, B43legacy_MMIO_PIO1_BASE);
413 if (!queue)
414 goto out;
415 pio->queue0 = queue;
416
417 queue = b43legacy_setup_pioqueue(dev, B43legacy_MMIO_PIO2_BASE);
418 if (!queue)
419 goto err_destroy0;
420 pio->queue1 = queue;
421
422 queue = b43legacy_setup_pioqueue(dev, B43legacy_MMIO_PIO3_BASE);
423 if (!queue)
424 goto err_destroy1;
425 pio->queue2 = queue;
426
427 queue = b43legacy_setup_pioqueue(dev, B43legacy_MMIO_PIO4_BASE);
428 if (!queue)
429 goto err_destroy2;
430 pio->queue3 = queue;
431
432 if (dev->dev->id.revision < 3)
433 dev->irq_mask |= B43legacy_IRQ_PIO_WORKAROUND;
434
435 b43legacydbg(dev->wl, "PIO initialized\n");
436 err = 0;
437out:
438 return err;
439
440err_destroy2:
441 b43legacy_destroy_pioqueue(pio->queue2);
442 pio->queue2 = NULL;
443err_destroy1:
444 b43legacy_destroy_pioqueue(pio->queue1);
445 pio->queue1 = NULL;
446err_destroy0:
447 b43legacy_destroy_pioqueue(pio->queue0);
448 pio->queue0 = NULL;
449 goto out;
450}
451
452int b43legacy_pio_tx(struct b43legacy_wldev *dev,
453 struct sk_buff *skb)
454{
455 struct b43legacy_pioqueue *queue = dev->pio.queue1;
456 struct b43legacy_pio_txpacket *packet;
457
458 B43legacy_WARN_ON(queue->tx_suspended);
459 B43legacy_WARN_ON(list_empty(&queue->txfree));
460
461 packet = list_entry(queue->txfree.next, struct b43legacy_pio_txpacket,
462 list);
463 packet->skb = skb;
464
465 list_move_tail(&packet->list, &queue->txqueue);
466 queue->nr_txfree--;
467 B43legacy_WARN_ON(queue->nr_txfree >= B43legacy_PIO_MAXTXPACKETS);
468
469 tasklet_schedule(&queue->txtask);
470
471 return 0;
472}
473
474void b43legacy_pio_handle_txstatus(struct b43legacy_wldev *dev,
475 const struct b43legacy_txstatus *status)
476{
477 struct b43legacy_pioqueue *queue;
478 struct b43legacy_pio_txpacket *packet;
479 struct ieee80211_tx_info *info;
480 int retry_limit;
481
482 queue = parse_cookie(dev, status->cookie, &packet);
483 B43legacy_WARN_ON(!queue);
484
485 if (!packet->skb)
486 return;
487
488 queue->tx_devq_packets--;
489 queue->tx_devq_used -= (packet->skb->len +
490 sizeof(struct b43legacy_txhdr_fw3));
491
492 info = IEEE80211_SKB_CB(packet->skb);
493
494
495
496
497 retry_limit = info->status.rates[0].count;
498 ieee80211_tx_info_clear_status(info);
499
500 if (status->acked)
501 info->flags |= IEEE80211_TX_STAT_ACK;
502
503 if (status->rts_count > dev->wl->hw->conf.short_frame_max_tx_count) {
504
505
506
507
508
509
510
511 info->status.rates[0].count = 0;
512 info->status.rates[1].count = status->frame_count;
513 } else {
514 if (status->frame_count > retry_limit) {
515 info->status.rates[0].count = retry_limit;
516 info->status.rates[1].count = status->frame_count -
517 retry_limit;
518
519 } else {
520 info->status.rates[0].count = status->frame_count;
521 info->status.rates[1].idx = -1;
522 }
523 }
524 ieee80211_tx_status_irqsafe(dev->wl->hw, packet->skb);
525 packet->skb = NULL;
526
527 free_txpacket(packet, 1);
528
529
530
531 if (!list_empty(&queue->txqueue))
532 tasklet_schedule(&queue->txtask);
533}
534
535static void pio_rx_error(struct b43legacy_pioqueue *queue,
536 int clear_buffers,
537 const char *error)
538{
539 int i;
540
541 b43legacyerr(queue->dev->wl, "PIO RX error: %s\n", error);
542 b43legacy_pio_write(queue, B43legacy_PIO_RXCTL,
543 B43legacy_PIO_RXCTL_READY);
544 if (clear_buffers) {
545 B43legacy_WARN_ON(queue->mmio_base != B43legacy_MMIO_PIO1_BASE);
546 for (i = 0; i < 15; i++) {
547
548 b43legacy_pio_read(queue, B43legacy_PIO_RXDATA);
549 }
550 }
551}
552
553void b43legacy_pio_rx(struct b43legacy_pioqueue *queue)
554{
555 __le16 preamble[21] = { 0 };
556 struct b43legacy_rxhdr_fw3 *rxhdr;
557 u16 tmp;
558 u16 len;
559 u16 macstat;
560 int i;
561 int preamble_readwords;
562 struct sk_buff *skb;
563
564 tmp = b43legacy_pio_read(queue, B43legacy_PIO_RXCTL);
565 if (!(tmp & B43legacy_PIO_RXCTL_DATAAVAILABLE))
566 return;
567 b43legacy_pio_write(queue, B43legacy_PIO_RXCTL,
568 B43legacy_PIO_RXCTL_DATAAVAILABLE);
569
570 for (i = 0; i < 10; i++) {
571 tmp = b43legacy_pio_read(queue, B43legacy_PIO_RXCTL);
572 if (tmp & B43legacy_PIO_RXCTL_READY)
573 goto data_ready;
574 udelay(10);
575 }
576 b43legacydbg(queue->dev->wl, "PIO RX timed out\n");
577 return;
578data_ready:
579
580 len = b43legacy_pio_read(queue, B43legacy_PIO_RXDATA);
581 if (unlikely(len > 0x700)) {
582 pio_rx_error(queue, 0, "len > 0x700");
583 return;
584 }
585 if (unlikely(len == 0 && queue->mmio_base !=
586 B43legacy_MMIO_PIO4_BASE)) {
587 pio_rx_error(queue, 0, "len == 0");
588 return;
589 }
590 preamble[0] = cpu_to_le16(len);
591 if (queue->mmio_base == B43legacy_MMIO_PIO4_BASE)
592 preamble_readwords = 14 / sizeof(u16);
593 else
594 preamble_readwords = 18 / sizeof(u16);
595 for (i = 0; i < preamble_readwords; i++) {
596 tmp = b43legacy_pio_read(queue, B43legacy_PIO_RXDATA);
597 preamble[i + 1] = cpu_to_le16(tmp);
598 }
599 rxhdr = (struct b43legacy_rxhdr_fw3 *)preamble;
600 macstat = le16_to_cpu(rxhdr->mac_status);
601 if (macstat & B43legacy_RX_MAC_FCSERR) {
602 pio_rx_error(queue,
603 (queue->mmio_base == B43legacy_MMIO_PIO1_BASE),
604 "Frame FCS error");
605 return;
606 }
607 if (queue->mmio_base == B43legacy_MMIO_PIO4_BASE) {
608
609 struct b43legacy_hwtxstatus *hw;
610
611 hw = (struct b43legacy_hwtxstatus *)(preamble + 1);
612 b43legacy_handle_hwtxstatus(queue->dev, hw);
613
614 return;
615 }
616
617 skb = dev_alloc_skb(len);
618 if (unlikely(!skb)) {
619 pio_rx_error(queue, 1, "OOM");
620 return;
621 }
622 skb_put(skb, len);
623 for (i = 0; i < len - 1; i += 2) {
624 tmp = b43legacy_pio_read(queue, B43legacy_PIO_RXDATA);
625 *((__le16 *)(skb->data + i)) = cpu_to_le16(tmp);
626 }
627 if (len % 2) {
628 tmp = b43legacy_pio_read(queue, B43legacy_PIO_RXDATA);
629 skb->data[len - 1] = (tmp & 0x00FF);
630 }
631 b43legacy_rx(queue->dev, skb, rxhdr);
632}
633
634void b43legacy_pio_tx_suspend(struct b43legacy_pioqueue *queue)
635{
636 b43legacy_power_saving_ctl_bits(queue->dev, -1, 1);
637 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
638 b43legacy_pio_read(queue, B43legacy_PIO_TXCTL)
639 | B43legacy_PIO_TXCTL_SUSPEND);
640}
641
642void b43legacy_pio_tx_resume(struct b43legacy_pioqueue *queue)
643{
644 b43legacy_pio_write(queue, B43legacy_PIO_TXCTL,
645 b43legacy_pio_read(queue, B43legacy_PIO_TXCTL)
646 & ~B43legacy_PIO_TXCTL_SUSPEND);
647 b43legacy_power_saving_ctl_bits(queue->dev, -1, -1);
648 tasklet_schedule(&queue->txtask);
649}
650
651void b43legacy_pio_freeze_txqueues(struct b43legacy_wldev *dev)
652{
653 struct b43legacy_pio *pio;
654
655 B43legacy_WARN_ON(!b43legacy_using_pio(dev));
656 pio = &dev->pio;
657 pio->queue0->tx_frozen = 1;
658 pio->queue1->tx_frozen = 1;
659 pio->queue2->tx_frozen = 1;
660 pio->queue3->tx_frozen = 1;
661}
662
663void b43legacy_pio_thaw_txqueues(struct b43legacy_wldev *dev)
664{
665 struct b43legacy_pio *pio;
666
667 B43legacy_WARN_ON(!b43legacy_using_pio(dev));
668 pio = &dev->pio;
669 pio->queue0->tx_frozen = 0;
670 pio->queue1->tx_frozen = 0;
671 pio->queue2->tx_frozen = 0;
672 pio->queue3->tx_frozen = 0;
673 if (!list_empty(&pio->queue0->txqueue))
674 tasklet_schedule(&pio->queue0->txtask);
675 if (!list_empty(&pio->queue1->txqueue))
676 tasklet_schedule(&pio->queue1->txtask);
677 if (!list_empty(&pio->queue2->txqueue))
678 tasklet_schedule(&pio->queue2->txtask);
679 if (!list_empty(&pio->queue3->txqueue))
680 tasklet_schedule(&pio->queue3->txtask);
681}
682
