Loading...
1/*
2 * Blackfin Infra-red Driver
3 *
4 * Copyright 2006-2009 Analog Devices Inc.
5 *
6 * Enter bugs at http://blackfin.uclinux.org/
7 *
8 * Licensed under the GPL-2 or later.
9 *
10 */
11#include "bfin_sir.h"
12
13#ifdef CONFIG_SIR_BFIN_DMA
14#define DMA_SIR_RX_XCNT 10
15#define DMA_SIR_RX_YCNT (PAGE_SIZE / DMA_SIR_RX_XCNT)
16#define DMA_SIR_RX_FLUSH_JIFS (HZ * 4 / 250)
17#endif
18
19#if ANOMALY_05000447
20static int max_rate = 57600;
21#else
22static int max_rate = 115200;
23#endif
24
25static void turnaround_delay(unsigned long last_jif, int mtt)
26{
27 long ticks;
28
29 mtt = mtt < 10000 ? 10000 : mtt;
30 ticks = 1 + mtt / (USEC_PER_SEC / HZ);
31 schedule_timeout_uninterruptible(ticks);
32}
33
34static void __devinit bfin_sir_init_ports(struct bfin_sir_port *sp, struct platform_device *pdev)
35{
36 int i;
37 struct resource *res;
38
39 for (i = 0; i < pdev->num_resources; i++) {
40 res = &pdev->resource[i];
41 switch (res->flags) {
42 case IORESOURCE_MEM:
43 sp->membase = (void __iomem *)res->start;
44 break;
45 case IORESOURCE_IRQ:
46 sp->irq = res->start;
47 break;
48 case IORESOURCE_DMA:
49 sp->rx_dma_channel = res->start;
50 sp->tx_dma_channel = res->end;
51 break;
52 default:
53 break;
54 }
55 }
56
57 sp->clk = get_sclk();
58#ifdef CONFIG_SIR_BFIN_DMA
59 sp->tx_done = 1;
60 init_timer(&(sp->rx_dma_timer));
61#endif
62}
63
64static void bfin_sir_stop_tx(struct bfin_sir_port *port)
65{
66#ifdef CONFIG_SIR_BFIN_DMA
67 disable_dma(port->tx_dma_channel);
68#endif
69
70 while (!(UART_GET_LSR(port) & THRE)) {
71 cpu_relax();
72 continue;
73 }
74
75 UART_CLEAR_IER(port, ETBEI);
76}
77
78static void bfin_sir_enable_tx(struct bfin_sir_port *port)
79{
80 UART_SET_IER(port, ETBEI);
81}
82
83static void bfin_sir_stop_rx(struct bfin_sir_port *port)
84{
85 UART_CLEAR_IER(port, ERBFI);
86}
87
88static void bfin_sir_enable_rx(struct bfin_sir_port *port)
89{
90 UART_SET_IER(port, ERBFI);
91}
92
93static int bfin_sir_set_speed(struct bfin_sir_port *port, int speed)
94{
95 int ret = -EINVAL;
96 unsigned int quot;
97 unsigned short val, lsr, lcr;
98 static int utime;
99 int count = 10;
100
101 lcr = WLS(8);
102
103 switch (speed) {
104 case 9600:
105 case 19200:
106 case 38400:
107 case 57600:
108 case 115200:
109
110 /*
111 * IRDA is not affected by anomaly 05000230, so there is no
112 * need to tweak the divisor like he UART driver (which will
113 * slightly speed up the baud rate on us).
114 */
115 quot = (port->clk + (8 * speed)) / (16 * speed);
116
117 do {
118 udelay(utime);
119 lsr = UART_GET_LSR(port);
120 } while (!(lsr & TEMT) && count--);
121
122 /* The useconds for 1 bits to transmit */
123 utime = 1000000 / speed + 1;
124
125 /* Clear UCEN bit to reset the UART state machine
126 * and control registers
127 */
128 val = UART_GET_GCTL(port);
129 val &= ~UCEN;
130 UART_PUT_GCTL(port, val);
131
132 /* Set DLAB in LCR to Access THR RBR IER */
133 UART_SET_DLAB(port);
134 SSYNC();
135
136 UART_PUT_DLL(port, quot & 0xFF);
137 UART_PUT_DLH(port, (quot >> 8) & 0xFF);
138 SSYNC();
139
140 /* Clear DLAB in LCR */
141 UART_CLEAR_DLAB(port);
142 SSYNC();
143
144 UART_PUT_LCR(port, lcr);
145
146 val = UART_GET_GCTL(port);
147 val |= UCEN;
148 UART_PUT_GCTL(port, val);
149
150 ret = 0;
151 break;
152 default:
153 printk(KERN_WARNING "bfin_sir: Invalid speed %d\n", speed);
154 break;
155 }
156
157 val = UART_GET_GCTL(port);
158 /* If not add the 'RPOLC', we can't catch the receive interrupt.
159 * It's related with the HW layout and the IR transiver.
160 */
161 val |= IREN | RPOLC;
162 UART_PUT_GCTL(port, val);
163 return ret;
164}
165
166static int bfin_sir_is_receiving(struct net_device *dev)
167{
168 struct bfin_sir_self *self = netdev_priv(dev);
169 struct bfin_sir_port *port = self->sir_port;
170
171 if (!(UART_GET_IER(port) & ERBFI))
172 return 0;
173 return self->rx_buff.state != OUTSIDE_FRAME;
174}
175
176#ifdef CONFIG_SIR_BFIN_PIO
177static void bfin_sir_tx_chars(struct net_device *dev)
178{
179 unsigned int chr;
180 struct bfin_sir_self *self = netdev_priv(dev);
181 struct bfin_sir_port *port = self->sir_port;
182
183 if (self->tx_buff.len != 0) {
184 chr = *(self->tx_buff.data);
185 UART_PUT_CHAR(port, chr);
186 self->tx_buff.data++;
187 self->tx_buff.len--;
188 } else {
189 self->stats.tx_packets++;
190 self->stats.tx_bytes += self->tx_buff.data - self->tx_buff.head;
191 if (self->newspeed) {
192 bfin_sir_set_speed(port, self->newspeed);
193 self->speed = self->newspeed;
194 self->newspeed = 0;
195 }
196 bfin_sir_stop_tx(port);
197 bfin_sir_enable_rx(port);
198 /* I'm hungry! */
199 netif_wake_queue(dev);
200 }
201}
202
203static void bfin_sir_rx_chars(struct net_device *dev)
204{
205 struct bfin_sir_self *self = netdev_priv(dev);
206 struct bfin_sir_port *port = self->sir_port;
207 unsigned char ch;
208
209 UART_CLEAR_LSR(port);
210 ch = UART_GET_CHAR(port);
211 async_unwrap_char(dev, &self->stats, &self->rx_buff, ch);
212 dev->last_rx = jiffies;
213}
214
215static irqreturn_t bfin_sir_rx_int(int irq, void *dev_id)
216{
217 struct net_device *dev = dev_id;
218 struct bfin_sir_self *self = netdev_priv(dev);
219 struct bfin_sir_port *port = self->sir_port;
220
221 spin_lock(&self->lock);
222 while ((UART_GET_LSR(port) & DR))
223 bfin_sir_rx_chars(dev);
224 spin_unlock(&self->lock);
225
226 return IRQ_HANDLED;
227}
228
229static irqreturn_t bfin_sir_tx_int(int irq, void *dev_id)
230{
231 struct net_device *dev = dev_id;
232 struct bfin_sir_self *self = netdev_priv(dev);
233 struct bfin_sir_port *port = self->sir_port;
234
235 spin_lock(&self->lock);
236 if (UART_GET_LSR(port) & THRE)
237 bfin_sir_tx_chars(dev);
238 spin_unlock(&self->lock);
239
240 return IRQ_HANDLED;
241}
242#endif /* CONFIG_SIR_BFIN_PIO */
243
244#ifdef CONFIG_SIR_BFIN_DMA
245static void bfin_sir_dma_tx_chars(struct net_device *dev)
246{
247 struct bfin_sir_self *self = netdev_priv(dev);
248 struct bfin_sir_port *port = self->sir_port;
249
250 if (!port->tx_done)
251 return;
252 port->tx_done = 0;
253
254 if (self->tx_buff.len == 0) {
255 self->stats.tx_packets++;
256 if (self->newspeed) {
257 bfin_sir_set_speed(port, self->newspeed);
258 self->speed = self->newspeed;
259 self->newspeed = 0;
260 }
261 bfin_sir_enable_rx(port);
262 port->tx_done = 1;
263 netif_wake_queue(dev);
264 return;
265 }
266
267 blackfin_dcache_flush_range((unsigned long)(self->tx_buff.data),
268 (unsigned long)(self->tx_buff.data+self->tx_buff.len));
269 set_dma_config(port->tx_dma_channel,
270 set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
271 INTR_ON_BUF, DIMENSION_LINEAR, DATA_SIZE_8,
272 DMA_SYNC_RESTART));
273 set_dma_start_addr(port->tx_dma_channel,
274 (unsigned long)(self->tx_buff.data));
275 set_dma_x_count(port->tx_dma_channel, self->tx_buff.len);
276 set_dma_x_modify(port->tx_dma_channel, 1);
277 enable_dma(port->tx_dma_channel);
278}
279
280static irqreturn_t bfin_sir_dma_tx_int(int irq, void *dev_id)
281{
282 struct net_device *dev = dev_id;
283 struct bfin_sir_self *self = netdev_priv(dev);
284 struct bfin_sir_port *port = self->sir_port;
285
286 spin_lock(&self->lock);
287 if (!(get_dma_curr_irqstat(port->tx_dma_channel) & DMA_RUN)) {
288 clear_dma_irqstat(port->tx_dma_channel);
289 bfin_sir_stop_tx(port);
290
291 self->stats.tx_packets++;
292 self->stats.tx_bytes += self->tx_buff.len;
293 self->tx_buff.len = 0;
294 if (self->newspeed) {
295 bfin_sir_set_speed(port, self->newspeed);
296 self->speed = self->newspeed;
297 self->newspeed = 0;
298 }
299 bfin_sir_enable_rx(port);
300 /* I'm hungry! */
301 netif_wake_queue(dev);
302 port->tx_done = 1;
303 }
304 spin_unlock(&self->lock);
305
306 return IRQ_HANDLED;
307}
308
309static void bfin_sir_dma_rx_chars(struct net_device *dev)
310{
311 struct bfin_sir_self *self = netdev_priv(dev);
312 struct bfin_sir_port *port = self->sir_port;
313 int i;
314
315 UART_CLEAR_LSR(port);
316
317 for (i = port->rx_dma_buf.head; i < port->rx_dma_buf.tail; i++)
318 async_unwrap_char(dev, &self->stats, &self->rx_buff, port->rx_dma_buf.buf[i]);
319}
320
321void bfin_sir_rx_dma_timeout(struct net_device *dev)
322{
323 struct bfin_sir_self *self = netdev_priv(dev);
324 struct bfin_sir_port *port = self->sir_port;
325 int x_pos, pos;
326 unsigned long flags;
327
328 spin_lock_irqsave(&self->lock, flags);
329 x_pos = DMA_SIR_RX_XCNT - get_dma_curr_xcount(port->rx_dma_channel);
330 if (x_pos == DMA_SIR_RX_XCNT)
331 x_pos = 0;
332
333 pos = port->rx_dma_nrows * DMA_SIR_RX_XCNT + x_pos;
334
335 if (pos > port->rx_dma_buf.tail) {
336 port->rx_dma_buf.tail = pos;
337 bfin_sir_dma_rx_chars(dev);
338 port->rx_dma_buf.head = port->rx_dma_buf.tail;
339 }
340 spin_unlock_irqrestore(&self->lock, flags);
341}
342
343static irqreturn_t bfin_sir_dma_rx_int(int irq, void *dev_id)
344{
345 struct net_device *dev = dev_id;
346 struct bfin_sir_self *self = netdev_priv(dev);
347 struct bfin_sir_port *port = self->sir_port;
348 unsigned short irqstat;
349
350 spin_lock(&self->lock);
351
352 port->rx_dma_nrows++;
353 port->rx_dma_buf.tail = DMA_SIR_RX_XCNT * port->rx_dma_nrows;
354 bfin_sir_dma_rx_chars(dev);
355 if (port->rx_dma_nrows >= DMA_SIR_RX_YCNT) {
356 port->rx_dma_nrows = 0;
357 port->rx_dma_buf.tail = 0;
358 }
359 port->rx_dma_buf.head = port->rx_dma_buf.tail;
360
361 irqstat = get_dma_curr_irqstat(port->rx_dma_channel);
362 clear_dma_irqstat(port->rx_dma_channel);
363 spin_unlock(&self->lock);
364
365 mod_timer(&port->rx_dma_timer, jiffies + DMA_SIR_RX_FLUSH_JIFS);
366 return IRQ_HANDLED;
367}
368#endif /* CONFIG_SIR_BFIN_DMA */
369
370static int bfin_sir_startup(struct bfin_sir_port *port, struct net_device *dev)
371{
372#ifdef CONFIG_SIR_BFIN_DMA
373 dma_addr_t dma_handle;
374#endif /* CONFIG_SIR_BFIN_DMA */
375
376 if (request_dma(port->rx_dma_channel, "BFIN_UART_RX") < 0) {
377 dev_warn(&dev->dev, "Unable to attach SIR RX DMA channel\n");
378 return -EBUSY;
379 }
380
381 if (request_dma(port->tx_dma_channel, "BFIN_UART_TX") < 0) {
382 dev_warn(&dev->dev, "Unable to attach SIR TX DMA channel\n");
383 free_dma(port->rx_dma_channel);
384 return -EBUSY;
385 }
386
387#ifdef CONFIG_SIR_BFIN_DMA
388
389 set_dma_callback(port->rx_dma_channel, bfin_sir_dma_rx_int, dev);
390 set_dma_callback(port->tx_dma_channel, bfin_sir_dma_tx_int, dev);
391
392 port->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
393 port->rx_dma_buf.head = 0;
394 port->rx_dma_buf.tail = 0;
395 port->rx_dma_nrows = 0;
396
397 set_dma_config(port->rx_dma_channel,
398 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
399 INTR_ON_ROW, DIMENSION_2D,
400 DATA_SIZE_8, DMA_SYNC_RESTART));
401 set_dma_x_count(port->rx_dma_channel, DMA_SIR_RX_XCNT);
402 set_dma_x_modify(port->rx_dma_channel, 1);
403 set_dma_y_count(port->rx_dma_channel, DMA_SIR_RX_YCNT);
404 set_dma_y_modify(port->rx_dma_channel, 1);
405 set_dma_start_addr(port->rx_dma_channel, (unsigned long)port->rx_dma_buf.buf);
406 enable_dma(port->rx_dma_channel);
407
408 port->rx_dma_timer.data = (unsigned long)(dev);
409 port->rx_dma_timer.function = (void *)bfin_sir_rx_dma_timeout;
410
411#else
412
413 if (request_irq(port->irq, bfin_sir_rx_int, IRQF_DISABLED, "BFIN_SIR_RX", dev)) {
414 dev_warn(&dev->dev, "Unable to attach SIR RX interrupt\n");
415 return -EBUSY;
416 }
417
418 if (request_irq(port->irq+1, bfin_sir_tx_int, IRQF_DISABLED, "BFIN_SIR_TX", dev)) {
419 dev_warn(&dev->dev, "Unable to attach SIR TX interrupt\n");
420 free_irq(port->irq, dev);
421 return -EBUSY;
422 }
423#endif
424
425 return 0;
426}
427
428static void bfin_sir_shutdown(struct bfin_sir_port *port, struct net_device *dev)
429{
430 unsigned short val;
431
432 bfin_sir_stop_rx(port);
433
434 val = UART_GET_GCTL(port);
435 val &= ~(UCEN | IREN | RPOLC);
436 UART_PUT_GCTL(port, val);
437
438#ifdef CONFIG_SIR_BFIN_DMA
439 disable_dma(port->tx_dma_channel);
440 disable_dma(port->rx_dma_channel);
441 del_timer(&(port->rx_dma_timer));
442 dma_free_coherent(NULL, PAGE_SIZE, port->rx_dma_buf.buf, 0);
443#else
444 free_irq(port->irq+1, dev);
445 free_irq(port->irq, dev);
446#endif
447 free_dma(port->tx_dma_channel);
448 free_dma(port->rx_dma_channel);
449}
450
451#ifdef CONFIG_PM
452static int bfin_sir_suspend(struct platform_device *pdev, pm_message_t state)
453{
454 struct bfin_sir_port *sir_port;
455 struct net_device *dev;
456 struct bfin_sir_self *self;
457
458 sir_port = platform_get_drvdata(pdev);
459 if (!sir_port)
460 return 0;
461
462 dev = sir_port->dev;
463 self = netdev_priv(dev);
464 if (self->open) {
465 flush_work(&self->work);
466 bfin_sir_shutdown(self->sir_port, dev);
467 netif_device_detach(dev);
468 }
469
470 return 0;
471}
472static int bfin_sir_resume(struct platform_device *pdev)
473{
474 struct bfin_sir_port *sir_port;
475 struct net_device *dev;
476 struct bfin_sir_self *self;
477 struct bfin_sir_port *port;
478
479 sir_port = platform_get_drvdata(pdev);
480 if (!sir_port)
481 return 0;
482
483 dev = sir_port->dev;
484 self = netdev_priv(dev);
485 port = self->sir_port;
486 if (self->open) {
487 if (self->newspeed) {
488 self->speed = self->newspeed;
489 self->newspeed = 0;
490 }
491 bfin_sir_startup(port, dev);
492 bfin_sir_set_speed(port, 9600);
493 bfin_sir_enable_rx(port);
494 netif_device_attach(dev);
495 }
496 return 0;
497}
498#else
499#define bfin_sir_suspend NULL
500#define bfin_sir_resume NULL
501#endif
502
503static void bfin_sir_send_work(struct work_struct *work)
504{
505 struct bfin_sir_self *self = container_of(work, struct bfin_sir_self, work);
506 struct net_device *dev = self->sir_port->dev;
507 struct bfin_sir_port *port = self->sir_port;
508 unsigned short val;
509 int tx_cnt = 10;
510
511 while (bfin_sir_is_receiving(dev) && --tx_cnt)
512 turnaround_delay(dev->last_rx, self->mtt);
513
514 bfin_sir_stop_rx(port);
515
516 /* To avoid losting RX interrupt, we reset IR function before
517 * sending data. We also can set the speed, which will
518 * reset all the UART.
519 */
520 val = UART_GET_GCTL(port);
521 val &= ~(IREN | RPOLC);
522 UART_PUT_GCTL(port, val);
523 SSYNC();
524 val |= IREN | RPOLC;
525 UART_PUT_GCTL(port, val);
526 SSYNC();
527 /* bfin_sir_set_speed(port, self->speed); */
528
529#ifdef CONFIG_SIR_BFIN_DMA
530 bfin_sir_dma_tx_chars(dev);
531#endif
532 bfin_sir_enable_tx(port);
533 dev->trans_start = jiffies;
534}
535
536static int bfin_sir_hard_xmit(struct sk_buff *skb, struct net_device *dev)
537{
538 struct bfin_sir_self *self = netdev_priv(dev);
539 int speed = irda_get_next_speed(skb);
540
541 netif_stop_queue(dev);
542
543 self->mtt = irda_get_mtt(skb);
544
545 if (speed != self->speed && speed != -1)
546 self->newspeed = speed;
547
548 self->tx_buff.data = self->tx_buff.head;
549 if (skb->len == 0)
550 self->tx_buff.len = 0;
551 else
552 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, self->tx_buff.truesize);
553
554 schedule_work(&self->work);
555 dev_kfree_skb(skb);
556
557 return 0;
558}
559
560static int bfin_sir_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
561{
562 struct if_irda_req *rq = (struct if_irda_req *)ifreq;
563 struct bfin_sir_self *self = netdev_priv(dev);
564 struct bfin_sir_port *port = self->sir_port;
565 int ret = 0;
566
567 switch (cmd) {
568 case SIOCSBANDWIDTH:
569 if (capable(CAP_NET_ADMIN)) {
570 if (self->open) {
571 ret = bfin_sir_set_speed(port, rq->ifr_baudrate);
572 bfin_sir_enable_rx(port);
573 } else {
574 dev_warn(&dev->dev, "SIOCSBANDWIDTH: !netif_running\n");
575 ret = 0;
576 }
577 }
578 break;
579
580 case SIOCSMEDIABUSY:
581 ret = -EPERM;
582 if (capable(CAP_NET_ADMIN)) {
583 irda_device_set_media_busy(dev, TRUE);
584 ret = 0;
585 }
586 break;
587
588 case SIOCGRECEIVING:
589 rq->ifr_receiving = bfin_sir_is_receiving(dev);
590 break;
591
592 default:
593 ret = -EOPNOTSUPP;
594 break;
595 }
596
597 return ret;
598}
599
600static struct net_device_stats *bfin_sir_stats(struct net_device *dev)
601{
602 struct bfin_sir_self *self = netdev_priv(dev);
603
604 return &self->stats;
605}
606
607static int bfin_sir_open(struct net_device *dev)
608{
609 struct bfin_sir_self *self = netdev_priv(dev);
610 struct bfin_sir_port *port = self->sir_port;
611 int err = -ENOMEM;
612
613 self->newspeed = 0;
614 self->speed = 9600;
615
616 spin_lock_init(&self->lock);
617
618 err = bfin_sir_startup(port, dev);
619 if (err)
620 goto err_startup;
621
622 bfin_sir_set_speed(port, 9600);
623
624 self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME);
625 if (!self->irlap)
626 goto err_irlap;
627
628 INIT_WORK(&self->work, bfin_sir_send_work);
629
630 /*
631 * Now enable the interrupt then start the queue
632 */
633 self->open = 1;
634 bfin_sir_enable_rx(port);
635
636 netif_start_queue(dev);
637
638 return 0;
639
640err_irlap:
641 self->open = 0;
642 bfin_sir_shutdown(port, dev);
643err_startup:
644 return err;
645}
646
647static int bfin_sir_stop(struct net_device *dev)
648{
649 struct bfin_sir_self *self = netdev_priv(dev);
650
651 flush_work(&self->work);
652 bfin_sir_shutdown(self->sir_port, dev);
653
654 if (self->rxskb) {
655 dev_kfree_skb(self->rxskb);
656 self->rxskb = NULL;
657 }
658
659 /* Stop IrLAP */
660 if (self->irlap) {
661 irlap_close(self->irlap);
662 self->irlap = NULL;
663 }
664
665 netif_stop_queue(dev);
666 self->open = 0;
667
668 return 0;
669}
670
671static int bfin_sir_init_iobuf(iobuff_t *io, int size)
672{
673 io->head = kmalloc(size, GFP_KERNEL);
674 if (!io->head)
675 return -ENOMEM;
676 io->truesize = size;
677 io->in_frame = FALSE;
678 io->state = OUTSIDE_FRAME;
679 io->data = io->head;
680 return 0;
681}
682
683static const struct net_device_ops bfin_sir_ndo = {
684 .ndo_open = bfin_sir_open,
685 .ndo_stop = bfin_sir_stop,
686 .ndo_start_xmit = bfin_sir_hard_xmit,
687 .ndo_do_ioctl = bfin_sir_ioctl,
688 .ndo_get_stats = bfin_sir_stats,
689};
690
691static int __devinit bfin_sir_probe(struct platform_device *pdev)
692{
693 struct net_device *dev;
694 struct bfin_sir_self *self;
695 unsigned int baudrate_mask;
696 struct bfin_sir_port *sir_port;
697 int err;
698
699 if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \
700 per[pdev->id][3] == pdev->id) {
701 err = peripheral_request_list(per[pdev->id], DRIVER_NAME);
702 if (err)
703 return err;
704 } else {
705 dev_err(&pdev->dev, "Invalid pdev id, please check board file\n");
706 return -ENODEV;
707 }
708
709 err = -ENOMEM;
710 sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL);
711 if (!sir_port)
712 goto err_mem_0;
713
714 bfin_sir_init_ports(sir_port, pdev);
715
716 dev = alloc_irdadev(sizeof(*self));
717 if (!dev)
718 goto err_mem_1;
719
720 self = netdev_priv(dev);
721 self->dev = &pdev->dev;
722 self->sir_port = sir_port;
723 sir_port->dev = dev;
724
725 err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU);
726 if (err)
727 goto err_mem_2;
728 err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME);
729 if (err)
730 goto err_mem_3;
731
732 dev->netdev_ops = &bfin_sir_ndo;
733 dev->irq = sir_port->irq;
734
735 irda_init_max_qos_capabilies(&self->qos);
736
737 baudrate_mask = IR_9600;
738
739 switch (max_rate) {
740 case 115200:
741 baudrate_mask |= IR_115200;
742 case 57600:
743 baudrate_mask |= IR_57600;
744 case 38400:
745 baudrate_mask |= IR_38400;
746 case 19200:
747 baudrate_mask |= IR_19200;
748 case 9600:
749 break;
750 default:
751 dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n");
752 }
753
754 self->qos.baud_rate.bits &= baudrate_mask;
755
756 self->qos.min_turn_time.bits = 1; /* 10 ms or more */
757
758 irda_qos_bits_to_value(&self->qos);
759
760 err = register_netdev(dev);
761
762 if (err) {
763 kfree(self->tx_buff.head);
764err_mem_3:
765 kfree(self->rx_buff.head);
766err_mem_2:
767 free_netdev(dev);
768err_mem_1:
769 kfree(sir_port);
770err_mem_0:
771 peripheral_free_list(per[pdev->id]);
772 } else
773 platform_set_drvdata(pdev, sir_port);
774
775 return err;
776}
777
778static int __devexit bfin_sir_remove(struct platform_device *pdev)
779{
780 struct bfin_sir_port *sir_port;
781 struct net_device *dev = NULL;
782 struct bfin_sir_self *self;
783
784 sir_port = platform_get_drvdata(pdev);
785 if (!sir_port)
786 return 0;
787 dev = sir_port->dev;
788 self = netdev_priv(dev);
789 unregister_netdev(dev);
790 kfree(self->tx_buff.head);
791 kfree(self->rx_buff.head);
792 free_netdev(dev);
793 kfree(sir_port);
794 platform_set_drvdata(pdev, NULL);
795
796 return 0;
797}
798
799static struct platform_driver bfin_ir_driver = {
800 .probe = bfin_sir_probe,
801 .remove = __devexit_p(bfin_sir_remove),
802 .suspend = bfin_sir_suspend,
803 .resume = bfin_sir_resume,
804 .driver = {
805 .name = DRIVER_NAME,
806 },
807};
808
809static int __init bfin_sir_init(void)
810{
811 return platform_driver_register(&bfin_ir_driver);
812}
813
814static void __exit bfin_sir_exit(void)
815{
816 platform_driver_unregister(&bfin_ir_driver);
817}
818
819module_init(bfin_sir_init);
820module_exit(bfin_sir_exit);
821
822module_param(max_rate, int, 0);
823MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)");
824
825MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>");
826MODULE_DESCRIPTION("Blackfin IrDA driver");
827MODULE_LICENSE("GPL");
1/*
2 * Blackfin Infra-red Driver
3 *
4 * Copyright 2006-2009 Analog Devices Inc.
5 *
6 * Enter bugs at http://blackfin.uclinux.org/
7 *
8 * Licensed under the GPL-2 or later.
9 *
10 */
11#include "bfin_sir.h"
12
13#ifdef CONFIG_SIR_BFIN_DMA
14#define DMA_SIR_RX_XCNT 10
15#define DMA_SIR_RX_YCNT (PAGE_SIZE / DMA_SIR_RX_XCNT)
16#define DMA_SIR_RX_FLUSH_JIFS (HZ * 4 / 250)
17#endif
18
19#if ANOMALY_05000447
20static int max_rate = 57600;
21#else
22static int max_rate = 115200;
23#endif
24
25static void turnaround_delay(unsigned long last_jif, int mtt)
26{
27 long ticks;
28
29 mtt = mtt < 10000 ? 10000 : mtt;
30 ticks = 1 + mtt / (USEC_PER_SEC / HZ);
31 schedule_timeout_uninterruptible(ticks);
32}
33
34static void bfin_sir_init_ports(struct bfin_sir_port *sp, struct platform_device *pdev)
35{
36 int i;
37 struct resource *res;
38
39 for (i = 0; i < pdev->num_resources; i++) {
40 res = &pdev->resource[i];
41 switch (res->flags) {
42 case IORESOURCE_MEM:
43 sp->membase = (void __iomem *)res->start;
44 break;
45 case IORESOURCE_IRQ:
46 sp->irq = res->start;
47 break;
48 case IORESOURCE_DMA:
49 sp->rx_dma_channel = res->start;
50 sp->tx_dma_channel = res->end;
51 break;
52 default:
53 break;
54 }
55 }
56
57 sp->clk = get_sclk();
58#ifdef CONFIG_SIR_BFIN_DMA
59 sp->tx_done = 1;
60 init_timer(&(sp->rx_dma_timer));
61#endif
62}
63
64static void bfin_sir_stop_tx(struct bfin_sir_port *port)
65{
66#ifdef CONFIG_SIR_BFIN_DMA
67 disable_dma(port->tx_dma_channel);
68#endif
69
70 while (!(UART_GET_LSR(port) & THRE)) {
71 cpu_relax();
72 continue;
73 }
74
75 UART_CLEAR_IER(port, ETBEI);
76}
77
78static void bfin_sir_enable_tx(struct bfin_sir_port *port)
79{
80 UART_SET_IER(port, ETBEI);
81}
82
83static void bfin_sir_stop_rx(struct bfin_sir_port *port)
84{
85 UART_CLEAR_IER(port, ERBFI);
86}
87
88static void bfin_sir_enable_rx(struct bfin_sir_port *port)
89{
90 UART_SET_IER(port, ERBFI);
91}
92
93static int bfin_sir_set_speed(struct bfin_sir_port *port, int speed)
94{
95 int ret = -EINVAL;
96 unsigned int quot;
97 unsigned short val, lsr, lcr;
98 static int utime;
99 int count = 10;
100
101 lcr = WLS(8);
102
103 switch (speed) {
104 case 9600:
105 case 19200:
106 case 38400:
107 case 57600:
108 case 115200:
109
110 /*
111 * IRDA is not affected by anomaly 05000230, so there is no
112 * need to tweak the divisor like he UART driver (which will
113 * slightly speed up the baud rate on us).
114 */
115 quot = (port->clk + (8 * speed)) / (16 * speed);
116
117 do {
118 udelay(utime);
119 lsr = UART_GET_LSR(port);
120 } while (!(lsr & TEMT) && count--);
121
122 /* The useconds for 1 bits to transmit */
123 utime = 1000000 / speed + 1;
124
125 /* Clear UCEN bit to reset the UART state machine
126 * and control registers
127 */
128 val = UART_GET_GCTL(port);
129 val &= ~UCEN;
130 UART_PUT_GCTL(port, val);
131
132 /* Set DLAB in LCR to Access THR RBR IER */
133 UART_SET_DLAB(port);
134 SSYNC();
135
136 UART_PUT_DLL(port, quot & 0xFF);
137 UART_PUT_DLH(port, (quot >> 8) & 0xFF);
138 SSYNC();
139
140 /* Clear DLAB in LCR */
141 UART_CLEAR_DLAB(port);
142 SSYNC();
143
144 UART_PUT_LCR(port, lcr);
145
146 val = UART_GET_GCTL(port);
147 val |= UCEN;
148 UART_PUT_GCTL(port, val);
149
150 ret = 0;
151 break;
152 default:
153 printk(KERN_WARNING "bfin_sir: Invalid speed %d\n", speed);
154 break;
155 }
156
157 val = UART_GET_GCTL(port);
158 /* If not add the 'RPOLC', we can't catch the receive interrupt.
159 * It's related with the HW layout and the IR transiver.
160 */
161 val |= UMOD_IRDA | RPOLC;
162 UART_PUT_GCTL(port, val);
163 return ret;
164}
165
166static int bfin_sir_is_receiving(struct net_device *dev)
167{
168 struct bfin_sir_self *self = netdev_priv(dev);
169 struct bfin_sir_port *port = self->sir_port;
170
171 if (!(UART_GET_IER(port) & ERBFI))
172 return 0;
173 return self->rx_buff.state != OUTSIDE_FRAME;
174}
175
176#ifdef CONFIG_SIR_BFIN_PIO
177static void bfin_sir_tx_chars(struct net_device *dev)
178{
179 unsigned int chr;
180 struct bfin_sir_self *self = netdev_priv(dev);
181 struct bfin_sir_port *port = self->sir_port;
182
183 if (self->tx_buff.len != 0) {
184 chr = *(self->tx_buff.data);
185 UART_PUT_CHAR(port, chr);
186 self->tx_buff.data++;
187 self->tx_buff.len--;
188 } else {
189 self->stats.tx_packets++;
190 self->stats.tx_bytes += self->tx_buff.data - self->tx_buff.head;
191 if (self->newspeed) {
192 bfin_sir_set_speed(port, self->newspeed);
193 self->speed = self->newspeed;
194 self->newspeed = 0;
195 }
196 bfin_sir_stop_tx(port);
197 bfin_sir_enable_rx(port);
198 /* I'm hungry! */
199 netif_wake_queue(dev);
200 }
201}
202
203static void bfin_sir_rx_chars(struct net_device *dev)
204{
205 struct bfin_sir_self *self = netdev_priv(dev);
206 struct bfin_sir_port *port = self->sir_port;
207 unsigned char ch;
208
209 UART_CLEAR_LSR(port);
210 ch = UART_GET_CHAR(port);
211 async_unwrap_char(dev, &self->stats, &self->rx_buff, ch);
212 dev->last_rx = jiffies;
213}
214
215static irqreturn_t bfin_sir_rx_int(int irq, void *dev_id)
216{
217 struct net_device *dev = dev_id;
218 struct bfin_sir_self *self = netdev_priv(dev);
219 struct bfin_sir_port *port = self->sir_port;
220
221 spin_lock(&self->lock);
222 while ((UART_GET_LSR(port) & DR))
223 bfin_sir_rx_chars(dev);
224 spin_unlock(&self->lock);
225
226 return IRQ_HANDLED;
227}
228
229static irqreturn_t bfin_sir_tx_int(int irq, void *dev_id)
230{
231 struct net_device *dev = dev_id;
232 struct bfin_sir_self *self = netdev_priv(dev);
233 struct bfin_sir_port *port = self->sir_port;
234
235 spin_lock(&self->lock);
236 if (UART_GET_LSR(port) & THRE)
237 bfin_sir_tx_chars(dev);
238 spin_unlock(&self->lock);
239
240 return IRQ_HANDLED;
241}
242#endif /* CONFIG_SIR_BFIN_PIO */
243
244#ifdef CONFIG_SIR_BFIN_DMA
245static void bfin_sir_dma_tx_chars(struct net_device *dev)
246{
247 struct bfin_sir_self *self = netdev_priv(dev);
248 struct bfin_sir_port *port = self->sir_port;
249
250 if (!port->tx_done)
251 return;
252 port->tx_done = 0;
253
254 if (self->tx_buff.len == 0) {
255 self->stats.tx_packets++;
256 if (self->newspeed) {
257 bfin_sir_set_speed(port, self->newspeed);
258 self->speed = self->newspeed;
259 self->newspeed = 0;
260 }
261 bfin_sir_enable_rx(port);
262 port->tx_done = 1;
263 netif_wake_queue(dev);
264 return;
265 }
266
267 blackfin_dcache_flush_range((unsigned long)(self->tx_buff.data),
268 (unsigned long)(self->tx_buff.data+self->tx_buff.len));
269 set_dma_config(port->tx_dma_channel,
270 set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
271 INTR_ON_BUF, DIMENSION_LINEAR, DATA_SIZE_8,
272 DMA_SYNC_RESTART));
273 set_dma_start_addr(port->tx_dma_channel,
274 (unsigned long)(self->tx_buff.data));
275 set_dma_x_count(port->tx_dma_channel, self->tx_buff.len);
276 set_dma_x_modify(port->tx_dma_channel, 1);
277 enable_dma(port->tx_dma_channel);
278}
279
280static irqreturn_t bfin_sir_dma_tx_int(int irq, void *dev_id)
281{
282 struct net_device *dev = dev_id;
283 struct bfin_sir_self *self = netdev_priv(dev);
284 struct bfin_sir_port *port = self->sir_port;
285
286 spin_lock(&self->lock);
287 if (!(get_dma_curr_irqstat(port->tx_dma_channel) & DMA_RUN)) {
288 clear_dma_irqstat(port->tx_dma_channel);
289 bfin_sir_stop_tx(port);
290
291 self->stats.tx_packets++;
292 self->stats.tx_bytes += self->tx_buff.len;
293 self->tx_buff.len = 0;
294 if (self->newspeed) {
295 bfin_sir_set_speed(port, self->newspeed);
296 self->speed = self->newspeed;
297 self->newspeed = 0;
298 }
299 bfin_sir_enable_rx(port);
300 /* I'm hungry! */
301 netif_wake_queue(dev);
302 port->tx_done = 1;
303 }
304 spin_unlock(&self->lock);
305
306 return IRQ_HANDLED;
307}
308
309static void bfin_sir_dma_rx_chars(struct net_device *dev)
310{
311 struct bfin_sir_self *self = netdev_priv(dev);
312 struct bfin_sir_port *port = self->sir_port;
313 int i;
314
315 UART_CLEAR_LSR(port);
316
317 for (i = port->rx_dma_buf.head; i < port->rx_dma_buf.tail; i++)
318 async_unwrap_char(dev, &self->stats, &self->rx_buff, port->rx_dma_buf.buf[i]);
319}
320
321void bfin_sir_rx_dma_timeout(struct net_device *dev)
322{
323 struct bfin_sir_self *self = netdev_priv(dev);
324 struct bfin_sir_port *port = self->sir_port;
325 int x_pos, pos;
326 unsigned long flags;
327
328 spin_lock_irqsave(&self->lock, flags);
329 x_pos = DMA_SIR_RX_XCNT - get_dma_curr_xcount(port->rx_dma_channel);
330 if (x_pos == DMA_SIR_RX_XCNT)
331 x_pos = 0;
332
333 pos = port->rx_dma_nrows * DMA_SIR_RX_XCNT + x_pos;
334
335 if (pos > port->rx_dma_buf.tail) {
336 port->rx_dma_buf.tail = pos;
337 bfin_sir_dma_rx_chars(dev);
338 port->rx_dma_buf.head = port->rx_dma_buf.tail;
339 }
340 spin_unlock_irqrestore(&self->lock, flags);
341}
342
343static irqreturn_t bfin_sir_dma_rx_int(int irq, void *dev_id)
344{
345 struct net_device *dev = dev_id;
346 struct bfin_sir_self *self = netdev_priv(dev);
347 struct bfin_sir_port *port = self->sir_port;
348 unsigned short irqstat;
349
350 spin_lock(&self->lock);
351
352 port->rx_dma_nrows++;
353 port->rx_dma_buf.tail = DMA_SIR_RX_XCNT * port->rx_dma_nrows;
354 bfin_sir_dma_rx_chars(dev);
355 if (port->rx_dma_nrows >= DMA_SIR_RX_YCNT) {
356 port->rx_dma_nrows = 0;
357 port->rx_dma_buf.tail = 0;
358 }
359 port->rx_dma_buf.head = port->rx_dma_buf.tail;
360
361 irqstat = get_dma_curr_irqstat(port->rx_dma_channel);
362 clear_dma_irqstat(port->rx_dma_channel);
363 spin_unlock(&self->lock);
364
365 mod_timer(&port->rx_dma_timer, jiffies + DMA_SIR_RX_FLUSH_JIFS);
366 return IRQ_HANDLED;
367}
368#endif /* CONFIG_SIR_BFIN_DMA */
369
370static int bfin_sir_startup(struct bfin_sir_port *port, struct net_device *dev)
371{
372#ifdef CONFIG_SIR_BFIN_DMA
373 dma_addr_t dma_handle;
374#endif /* CONFIG_SIR_BFIN_DMA */
375
376 if (request_dma(port->rx_dma_channel, "BFIN_UART_RX") < 0) {
377 dev_warn(&dev->dev, "Unable to attach SIR RX DMA channel\n");
378 return -EBUSY;
379 }
380
381 if (request_dma(port->tx_dma_channel, "BFIN_UART_TX") < 0) {
382 dev_warn(&dev->dev, "Unable to attach SIR TX DMA channel\n");
383 free_dma(port->rx_dma_channel);
384 return -EBUSY;
385 }
386
387#ifdef CONFIG_SIR_BFIN_DMA
388
389 set_dma_callback(port->rx_dma_channel, bfin_sir_dma_rx_int, dev);
390 set_dma_callback(port->tx_dma_channel, bfin_sir_dma_tx_int, dev);
391
392 port->rx_dma_buf.buf = dma_alloc_coherent(NULL, PAGE_SIZE,
393 &dma_handle, GFP_DMA);
394 port->rx_dma_buf.head = 0;
395 port->rx_dma_buf.tail = 0;
396 port->rx_dma_nrows = 0;
397
398 set_dma_config(port->rx_dma_channel,
399 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
400 INTR_ON_ROW, DIMENSION_2D,
401 DATA_SIZE_8, DMA_SYNC_RESTART));
402 set_dma_x_count(port->rx_dma_channel, DMA_SIR_RX_XCNT);
403 set_dma_x_modify(port->rx_dma_channel, 1);
404 set_dma_y_count(port->rx_dma_channel, DMA_SIR_RX_YCNT);
405 set_dma_y_modify(port->rx_dma_channel, 1);
406 set_dma_start_addr(port->rx_dma_channel, (unsigned long)port->rx_dma_buf.buf);
407 enable_dma(port->rx_dma_channel);
408
409 port->rx_dma_timer.data = (unsigned long)(dev);
410 port->rx_dma_timer.function = (void *)bfin_sir_rx_dma_timeout;
411
412#else
413
414 if (request_irq(port->irq, bfin_sir_rx_int, 0, "BFIN_SIR_RX", dev)) {
415 dev_warn(&dev->dev, "Unable to attach SIR RX interrupt\n");
416 return -EBUSY;
417 }
418
419 if (request_irq(port->irq+1, bfin_sir_tx_int, 0, "BFIN_SIR_TX", dev)) {
420 dev_warn(&dev->dev, "Unable to attach SIR TX interrupt\n");
421 free_irq(port->irq, dev);
422 return -EBUSY;
423 }
424#endif
425
426 return 0;
427}
428
429static void bfin_sir_shutdown(struct bfin_sir_port *port, struct net_device *dev)
430{
431 unsigned short val;
432
433 bfin_sir_stop_rx(port);
434
435 val = UART_GET_GCTL(port);
436 val &= ~(UCEN | UMOD_MASK | RPOLC);
437 UART_PUT_GCTL(port, val);
438
439#ifdef CONFIG_SIR_BFIN_DMA
440 disable_dma(port->tx_dma_channel);
441 disable_dma(port->rx_dma_channel);
442 del_timer(&(port->rx_dma_timer));
443 dma_free_coherent(NULL, PAGE_SIZE, port->rx_dma_buf.buf, 0);
444#else
445 free_irq(port->irq+1, dev);
446 free_irq(port->irq, dev);
447#endif
448 free_dma(port->tx_dma_channel);
449 free_dma(port->rx_dma_channel);
450}
451
452#ifdef CONFIG_PM
453static int bfin_sir_suspend(struct platform_device *pdev, pm_message_t state)
454{
455 struct bfin_sir_port *sir_port;
456 struct net_device *dev;
457 struct bfin_sir_self *self;
458
459 sir_port = platform_get_drvdata(pdev);
460 if (!sir_port)
461 return 0;
462
463 dev = sir_port->dev;
464 self = netdev_priv(dev);
465 if (self->open) {
466 flush_work(&self->work);
467 bfin_sir_shutdown(self->sir_port, dev);
468 netif_device_detach(dev);
469 }
470
471 return 0;
472}
473static int bfin_sir_resume(struct platform_device *pdev)
474{
475 struct bfin_sir_port *sir_port;
476 struct net_device *dev;
477 struct bfin_sir_self *self;
478 struct bfin_sir_port *port;
479
480 sir_port = platform_get_drvdata(pdev);
481 if (!sir_port)
482 return 0;
483
484 dev = sir_port->dev;
485 self = netdev_priv(dev);
486 port = self->sir_port;
487 if (self->open) {
488 if (self->newspeed) {
489 self->speed = self->newspeed;
490 self->newspeed = 0;
491 }
492 bfin_sir_startup(port, dev);
493 bfin_sir_set_speed(port, 9600);
494 bfin_sir_enable_rx(port);
495 netif_device_attach(dev);
496 }
497 return 0;
498}
499#else
500#define bfin_sir_suspend NULL
501#define bfin_sir_resume NULL
502#endif
503
504static void bfin_sir_send_work(struct work_struct *work)
505{
506 struct bfin_sir_self *self = container_of(work, struct bfin_sir_self, work);
507 struct net_device *dev = self->sir_port->dev;
508 struct bfin_sir_port *port = self->sir_port;
509 unsigned short val;
510 int tx_cnt = 10;
511
512 while (bfin_sir_is_receiving(dev) && --tx_cnt)
513 turnaround_delay(dev->last_rx, self->mtt);
514
515 bfin_sir_stop_rx(port);
516
517 /* To avoid losting RX interrupt, we reset IR function before
518 * sending data. We also can set the speed, which will
519 * reset all the UART.
520 */
521 val = UART_GET_GCTL(port);
522 val &= ~(UMOD_MASK | RPOLC);
523 UART_PUT_GCTL(port, val);
524 SSYNC();
525 val |= UMOD_IRDA | RPOLC;
526 UART_PUT_GCTL(port, val);
527 SSYNC();
528 /* bfin_sir_set_speed(port, self->speed); */
529
530#ifdef CONFIG_SIR_BFIN_DMA
531 bfin_sir_dma_tx_chars(dev);
532#endif
533 bfin_sir_enable_tx(port);
534 dev->trans_start = jiffies;
535}
536
537static int bfin_sir_hard_xmit(struct sk_buff *skb, struct net_device *dev)
538{
539 struct bfin_sir_self *self = netdev_priv(dev);
540 int speed = irda_get_next_speed(skb);
541
542 netif_stop_queue(dev);
543
544 self->mtt = irda_get_mtt(skb);
545
546 if (speed != self->speed && speed != -1)
547 self->newspeed = speed;
548
549 self->tx_buff.data = self->tx_buff.head;
550 if (skb->len == 0)
551 self->tx_buff.len = 0;
552 else
553 self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, self->tx_buff.truesize);
554
555 schedule_work(&self->work);
556 dev_kfree_skb(skb);
557
558 return 0;
559}
560
561static int bfin_sir_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
562{
563 struct if_irda_req *rq = (struct if_irda_req *)ifreq;
564 struct bfin_sir_self *self = netdev_priv(dev);
565 struct bfin_sir_port *port = self->sir_port;
566 int ret = 0;
567
568 switch (cmd) {
569 case SIOCSBANDWIDTH:
570 if (capable(CAP_NET_ADMIN)) {
571 if (self->open) {
572 ret = bfin_sir_set_speed(port, rq->ifr_baudrate);
573 bfin_sir_enable_rx(port);
574 } else {
575 dev_warn(&dev->dev, "SIOCSBANDWIDTH: !netif_running\n");
576 ret = 0;
577 }
578 }
579 break;
580
581 case SIOCSMEDIABUSY:
582 ret = -EPERM;
583 if (capable(CAP_NET_ADMIN)) {
584 irda_device_set_media_busy(dev, TRUE);
585 ret = 0;
586 }
587 break;
588
589 case SIOCGRECEIVING:
590 rq->ifr_receiving = bfin_sir_is_receiving(dev);
591 break;
592
593 default:
594 ret = -EOPNOTSUPP;
595 break;
596 }
597
598 return ret;
599}
600
601static struct net_device_stats *bfin_sir_stats(struct net_device *dev)
602{
603 struct bfin_sir_self *self = netdev_priv(dev);
604
605 return &self->stats;
606}
607
608static int bfin_sir_open(struct net_device *dev)
609{
610 struct bfin_sir_self *self = netdev_priv(dev);
611 struct bfin_sir_port *port = self->sir_port;
612 int err;
613
614 self->newspeed = 0;
615 self->speed = 9600;
616
617 spin_lock_init(&self->lock);
618
619 err = bfin_sir_startup(port, dev);
620 if (err)
621 goto err_startup;
622
623 bfin_sir_set_speed(port, 9600);
624
625 self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME);
626 if (!self->irlap) {
627 err = -ENOMEM;
628 goto err_irlap;
629 }
630
631 INIT_WORK(&self->work, bfin_sir_send_work);
632
633 /*
634 * Now enable the interrupt then start the queue
635 */
636 self->open = 1;
637 bfin_sir_enable_rx(port);
638
639 netif_start_queue(dev);
640
641 return 0;
642
643err_irlap:
644 self->open = 0;
645 bfin_sir_shutdown(port, dev);
646err_startup:
647 return err;
648}
649
650static int bfin_sir_stop(struct net_device *dev)
651{
652 struct bfin_sir_self *self = netdev_priv(dev);
653
654 flush_work(&self->work);
655 bfin_sir_shutdown(self->sir_port, dev);
656
657 if (self->rxskb) {
658 dev_kfree_skb(self->rxskb);
659 self->rxskb = NULL;
660 }
661
662 /* Stop IrLAP */
663 if (self->irlap) {
664 irlap_close(self->irlap);
665 self->irlap = NULL;
666 }
667
668 netif_stop_queue(dev);
669 self->open = 0;
670
671 return 0;
672}
673
674static int bfin_sir_init_iobuf(iobuff_t *io, int size)
675{
676 io->head = kmalloc(size, GFP_KERNEL);
677 if (!io->head)
678 return -ENOMEM;
679 io->truesize = size;
680 io->in_frame = FALSE;
681 io->state = OUTSIDE_FRAME;
682 io->data = io->head;
683 return 0;
684}
685
686static const struct net_device_ops bfin_sir_ndo = {
687 .ndo_open = bfin_sir_open,
688 .ndo_stop = bfin_sir_stop,
689 .ndo_start_xmit = bfin_sir_hard_xmit,
690 .ndo_do_ioctl = bfin_sir_ioctl,
691 .ndo_get_stats = bfin_sir_stats,
692};
693
694static int bfin_sir_probe(struct platform_device *pdev)
695{
696 struct net_device *dev;
697 struct bfin_sir_self *self;
698 unsigned int baudrate_mask;
699 struct bfin_sir_port *sir_port;
700 int err;
701
702 if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \
703 per[pdev->id][3] == pdev->id) {
704 err = peripheral_request_list(per[pdev->id], DRIVER_NAME);
705 if (err)
706 return err;
707 } else {
708 dev_err(&pdev->dev, "Invalid pdev id, please check board file\n");
709 return -ENODEV;
710 }
711
712 err = -ENOMEM;
713 sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL);
714 if (!sir_port)
715 goto err_mem_0;
716
717 bfin_sir_init_ports(sir_port, pdev);
718
719 dev = alloc_irdadev(sizeof(*self));
720 if (!dev)
721 goto err_mem_1;
722
723 self = netdev_priv(dev);
724 self->dev = &pdev->dev;
725 self->sir_port = sir_port;
726 sir_port->dev = dev;
727
728 err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU);
729 if (err)
730 goto err_mem_2;
731 err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME);
732 if (err)
733 goto err_mem_3;
734
735 dev->netdev_ops = &bfin_sir_ndo;
736 dev->irq = sir_port->irq;
737
738 irda_init_max_qos_capabilies(&self->qos);
739
740 baudrate_mask = IR_9600;
741
742 switch (max_rate) {
743 case 115200:
744 baudrate_mask |= IR_115200;
745 case 57600:
746 baudrate_mask |= IR_57600;
747 case 38400:
748 baudrate_mask |= IR_38400;
749 case 19200:
750 baudrate_mask |= IR_19200;
751 case 9600:
752 break;
753 default:
754 dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n");
755 }
756
757 self->qos.baud_rate.bits &= baudrate_mask;
758
759 self->qos.min_turn_time.bits = 1; /* 10 ms or more */
760
761 irda_qos_bits_to_value(&self->qos);
762
763 err = register_netdev(dev);
764
765 if (err) {
766 kfree(self->tx_buff.head);
767err_mem_3:
768 kfree(self->rx_buff.head);
769err_mem_2:
770 free_netdev(dev);
771err_mem_1:
772 kfree(sir_port);
773err_mem_0:
774 peripheral_free_list(per[pdev->id]);
775 } else
776 platform_set_drvdata(pdev, sir_port);
777
778 return err;
779}
780
781static int bfin_sir_remove(struct platform_device *pdev)
782{
783 struct bfin_sir_port *sir_port;
784 struct net_device *dev = NULL;
785 struct bfin_sir_self *self;
786
787 sir_port = platform_get_drvdata(pdev);
788 if (!sir_port)
789 return 0;
790 dev = sir_port->dev;
791 self = netdev_priv(dev);
792 unregister_netdev(dev);
793 kfree(self->tx_buff.head);
794 kfree(self->rx_buff.head);
795 free_netdev(dev);
796 kfree(sir_port);
797
798 return 0;
799}
800
801static struct platform_driver bfin_ir_driver = {
802 .probe = bfin_sir_probe,
803 .remove = bfin_sir_remove,
804 .suspend = bfin_sir_suspend,
805 .resume = bfin_sir_resume,
806 .driver = {
807 .name = DRIVER_NAME,
808 },
809};
810
811module_platform_driver(bfin_ir_driver);
812
813module_param(max_rate, int, 0);
814MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)");
815
816MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>");
817MODULE_DESCRIPTION("Blackfin IrDA driver");
818MODULE_LICENSE("GPL");