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");