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