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 (!(UART_GET_LSR(port) & THRE)) {
  71                 cpu_relax();
  72                 continue;
  73         }
  74
  75         UART_CLEAR_IER(port, ETBEI);
  76 }
  77
  78 static void bfin_sir_enable_tx(struct bfin_sir_port *port)
  79 {
  80         UART_SET_IER(port, ETBEI);
  81 }
  82
  83 static void bfin_sir_stop_rx(struct bfin_sir_port *port)
  84 {
  85         UART_CLEAR_IER(port, ERBFI);
  86 }
  87
  88 static void bfin_sir_enable_rx(struct bfin_sir_port *port)
  89 {
  90         UART_SET_IER(port, ERBFI);
  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 = 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
 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 (!(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                 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         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
 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 ((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 (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         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
 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
 452 static 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 }
 472 static 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
 503 static 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
 536 static 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
 560 static 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
 600 static 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
 607 static 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
 640 err_irlap:
 641         self->open = 0;
 642         bfin_sir_shutdown(port, dev);
 643 err_startup:
 644         return err;
 645 }
 646
 647 static 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
 671 static 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
 683 static 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
 691 static 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);
 764 err_mem_3:
 765                 kfree(self->rx_buff.head);
 766 err_mem_2:
 767                 free_netdev(dev);
 768 err_mem_1:
 769                 kfree(sir_port);
 770 err_mem_0:
 771                 peripheral_free_list(per[pdev->id]);
 772         } else
 773                 platform_set_drvdata(pdev, sir_port);
 774
 775         return err;
 776 }
 777
 778 static 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
 799 static 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
 809 static int __init bfin_sir_init(void)
 810 {
 811         return platform_driver_register(&bfin_ir_driver);
 812 }
 813
 814 static void __exit bfin_sir_exit(void)
 815 {
 816         platform_driver_unregister(&bfin_ir_driver);
 817 }
 818
 819 module_init(bfin_sir_init);
 820 module_exit(bfin_sir_exit);
 821
 822 module_param(max_rate, int, 0);
 823 MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)");
 824
 825 MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>");
 826 MODULE_DESCRIPTION("Blackfin IrDA driver");
 827 MODULE_LICENSE("GPL");