drivers: irda: fix sign bug
[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                 /*
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 = SIR_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 = SIR_UART_GET_GCTL(port);
129                 val &= ~UCEN;
130                 SIR_UART_PUT_GCTL(port, val);
131
132                 /* Set DLAB in LCR to Access THR RBR IER */
133                 SIR_UART_SET_DLAB(port);
134                 SSYNC();
135
136                 SIR_UART_PUT_DLL(port, quot & 0xFF);
137                 SIR_UART_PUT_DLH(port, (quot >> 8) & 0xFF);
138                 SSYNC();
139
140                 /* Clear DLAB in LCR */
141                 SIR_UART_CLEAR_DLAB(port);
142                 SSYNC();
143
144                 SIR_UART_PUT_LCR(port, lcr);
145
146                 val = SIR_UART_GET_GCTL(port);
147                 val |= UCEN;
148                 SIR_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 = SIR_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         SIR_UART_PUT_GCTL(port, val);
163         return ret;
164 }
165
166 static 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 (!(SIR_UART_GET_IER(port) & ERBFI))
172                 return 0;
173         return self->rx_buff.state != OUTSIDE_FRAME;
174 }
175
176 #ifdef CONFIG_SIR_BFIN_PIO
177 static 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                 SIR_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
203 static 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         SIR_UART_CLEAR_LSR(port);
210         ch = SIR_UART_GET_CHAR(port);
211         async_unwrap_char(dev, &self->stats, &self->rx_buff, ch);
212         dev->last_rx = jiffies;
213 }
214
215 static 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 ((SIR_UART_GET_LSR(port) & DR))
223                 bfin_sir_rx_chars(dev);
224         spin_unlock(&self->lock);
225
226         return IRQ_HANDLED;
227 }
228
229 static 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 (SIR_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
245 static 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
280 static 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
309 static 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         SIR_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
321 void 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
343 static 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
370 static 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
428 static 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         SIR_UART_DISABLE_INTS(port);
434
435         val = SIR_UART_GET_GCTL(port);
436         val &= ~(UCEN | IREN | RPOLC);
437         SIR_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
453 static 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 }
473 static 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
504 static 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 = SIR_UART_GET_GCTL(port);
522         val &= ~(IREN | RPOLC);
523         SIR_UART_PUT_GCTL(port, val);
524         SSYNC();
525         val |= IREN | RPOLC;
526         SIR_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
537 static 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
561 static 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
601 static 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
608 static 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 = -ENOMEM;
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                 goto err_irlap;
628
629         INIT_WORK(&self->work, bfin_sir_send_work);
630
631         /*
632          * Now enable the interrupt then start the queue
633          */
634         self->open = 1;
635         bfin_sir_enable_rx(port);
636
637         netif_start_queue(dev);
638
639         return 0;
640
641 err_irlap:
642         self->open = 0;
643         bfin_sir_shutdown(port, dev);
644 err_startup:
645         return err;
646 }
647
648 static int bfin_sir_stop(struct net_device *dev)
649 {
650         struct bfin_sir_self *self = netdev_priv(dev);
651
652         flush_work(&self->work);
653         bfin_sir_shutdown(self->sir_port, dev);
654
655         if (self->rxskb) {
656                 dev_kfree_skb(self->rxskb);
657                 self->rxskb = NULL;
658         }
659
660         /* Stop IrLAP */
661         if (self->irlap) {
662                 irlap_close(self->irlap);
663                 self->irlap = NULL;
664         }
665
666         netif_stop_queue(dev);
667         self->open = 0;
668
669         return 0;
670 }
671
672 static int bfin_sir_init_iobuf(iobuff_t *io, int size)
673 {
674         io->head = kmalloc(size, GFP_KERNEL);
675         if (!io->head)
676                 return -ENOMEM;
677         io->truesize = size;
678         io->in_frame = FALSE;
679         io->state    = OUTSIDE_FRAME;
680         io->data     = io->head;
681         return 0;
682 }
683
684 static const struct net_device_ops bfin_sir_ndo = {
685         .ndo_open               = bfin_sir_open,
686         .ndo_stop               = bfin_sir_stop,
687         .ndo_start_xmit         = bfin_sir_hard_xmit,
688         .ndo_do_ioctl           = bfin_sir_ioctl,
689         .ndo_get_stats          = bfin_sir_stats,
690 };
691
692 static int __devinit bfin_sir_probe(struct platform_device *pdev)
693 {
694         struct net_device *dev;
695         struct bfin_sir_self *self;
696         unsigned int baudrate_mask;
697         struct bfin_sir_port *sir_port;
698         int err;
699
700         if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \
701                                 per[pdev->id][3] == pdev->id) {
702                 err = peripheral_request_list(per[pdev->id], DRIVER_NAME);
703                 if (err)
704                         return err;
705         } else {
706                 dev_err(&pdev->dev, "Invalid pdev id, please check board file\n");
707                 return -ENODEV;
708         }
709
710         err = -ENOMEM;
711         sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL);
712         if (!sir_port)
713                 goto err_mem_0;
714
715         bfin_sir_init_ports(sir_port, pdev);
716
717         dev = alloc_irdadev(sizeof(*self));
718         if (!dev)
719                 goto err_mem_1;
720
721         self = netdev_priv(dev);
722         self->dev = &pdev->dev;
723         self->sir_port = sir_port;
724         sir_port->dev = dev;
725
726         err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU);
727         if (err)
728                 goto err_mem_2;
729         err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME);
730         if (err)
731                 goto err_mem_3;
732
733         dev->netdev_ops = &bfin_sir_ndo;
734         dev->irq = sir_port->irq;
735
736         irda_init_max_qos_capabilies(&self->qos);
737
738         baudrate_mask = IR_9600;
739
740         switch (max_rate) {
741         case 115200:
742                 baudrate_mask |= IR_115200;
743         case 57600:
744                 baudrate_mask |= IR_57600;
745         case 38400:
746                 baudrate_mask |= IR_38400;
747         case 19200:
748                 baudrate_mask |= IR_19200;
749         case 9600:
750                 break;
751         default:
752                 dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n");
753         }
754
755         self->qos.baud_rate.bits &= baudrate_mask;
756
757         self->qos.min_turn_time.bits = 1; /* 10 ms or more */
758
759         irda_qos_bits_to_value(&self->qos);
760
761         err = register_netdev(dev);
762
763         if (err) {
764                 kfree(self->tx_buff.head);
765 err_mem_3:
766                 kfree(self->rx_buff.head);
767 err_mem_2:
768                 free_netdev(dev);
769 err_mem_1:
770                 kfree(sir_port);
771 err_mem_0:
772                 peripheral_free_list(per[pdev->id]);
773         } else
774                 platform_set_drvdata(pdev, sir_port);
775
776         return err;
777 }
778
779 static int __devexit bfin_sir_remove(struct platform_device *pdev)
780 {
781         struct bfin_sir_port *sir_port;
782         struct net_device *dev = NULL;
783         struct bfin_sir_self *self;
784
785         sir_port = platform_get_drvdata(pdev);
786         if (!sir_port)
787                 return 0;
788         dev = sir_port->dev;
789         self = netdev_priv(dev);
790         unregister_netdev(dev);
791         kfree(self->tx_buff.head);
792         kfree(self->rx_buff.head);
793         free_netdev(dev);
794         kfree(sir_port);
795         platform_set_drvdata(pdev, NULL);
796
797         return 0;
798 }
799
800 static struct platform_driver bfin_ir_driver = {
801         .probe   = bfin_sir_probe,
802         .remove  = __devexit_p(bfin_sir_remove),
803         .suspend = bfin_sir_suspend,
804         .resume  = bfin_sir_resume,
805         .driver  = {
806                 .name = DRIVER_NAME,
807         },
808 };
809
810 static int __init bfin_sir_init(void)
811 {
812         return platform_driver_register(&bfin_ir_driver);
813 }
814
815 static void __exit bfin_sir_exit(void)
816 {
817         platform_driver_unregister(&bfin_ir_driver);
818 }
819
820 module_init(bfin_sir_init);
821 module_exit(bfin_sir_exit);
822
823 module_param(max_rate, int, 0);
824 MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)");
825
826 MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>");
827 MODULE_DESCRIPTION("Blackfin IrDA driver");
828 MODULE_LICENSE("GPL");