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