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 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 |= UMOD_IRDA | 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 = dma_alloc_coherent(NULL, PAGE_SIZE, 393 &dma_handle, GFP_DMA); 394 port->rx_dma_buf.head = 0; 395 port->rx_dma_buf.tail = 0; 396 port->rx_dma_nrows = 0; 397 398 set_dma_config(port->rx_dma_channel, 399 set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO, 400 INTR_ON_ROW, DIMENSION_2D, 401 DATA_SIZE_8, DMA_SYNC_RESTART)); 402 set_dma_x_count(port->rx_dma_channel, DMA_SIR_RX_XCNT); 403 set_dma_x_modify(port->rx_dma_channel, 1); 404 set_dma_y_count(port->rx_dma_channel, DMA_SIR_RX_YCNT); 405 set_dma_y_modify(port->rx_dma_channel, 1); 406 set_dma_start_addr(port->rx_dma_channel, (unsigned long)port->rx_dma_buf.buf); 407 enable_dma(port->rx_dma_channel); 408 409 port->rx_dma_timer.data = (unsigned long)(dev); 410 port->rx_dma_timer.function = (void *)bfin_sir_rx_dma_timeout; 411 412#else 413 414 if (request_irq(port->irq, bfin_sir_rx_int, 0, "BFIN_SIR_RX", dev)) { 415 dev_warn(&dev->dev, "Unable to attach SIR RX interrupt\n"); 416 return -EBUSY; 417 } 418 419 if (request_irq(port->irq+1, bfin_sir_tx_int, 0, "BFIN_SIR_TX", dev)) { 420 dev_warn(&dev->dev, "Unable to attach SIR TX interrupt\n"); 421 free_irq(port->irq, dev); 422 return -EBUSY; 423 } 424#endif 425 426 return 0; 427} 428 429static void bfin_sir_shutdown(struct bfin_sir_port *port, struct net_device *dev) 430{ 431 unsigned short val; 432 433 bfin_sir_stop_rx(port); 434 435 val = UART_GET_GCTL(port); 436 val &= ~(UCEN | UMOD_MASK | RPOLC); 437 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 453static 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} 473static 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 504static 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 = UART_GET_GCTL(port); 522 val &= ~(UMOD_MASK | RPOLC); 523 UART_PUT_GCTL(port, val); 524 SSYNC(); 525 val |= UMOD_IRDA | RPOLC; 526 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 537static 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 561static 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 601static 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 608static 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; 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 err = -ENOMEM; 628 goto err_irlap; 629 } 630 631 INIT_WORK(&self->work, bfin_sir_send_work); 632 633 /* 634 * Now enable the interrupt then start the queue 635 */ 636 self->open = 1; 637 bfin_sir_enable_rx(port); 638 639 netif_start_queue(dev); 640 641 return 0; 642 643err_irlap: 644 self->open = 0; 645 bfin_sir_shutdown(port, dev); 646err_startup: 647 return err; 648} 649 650static int bfin_sir_stop(struct net_device *dev) 651{ 652 struct bfin_sir_self *self = netdev_priv(dev); 653 654 flush_work(&self->work); 655 bfin_sir_shutdown(self->sir_port, dev); 656 657 if (self->rxskb) { 658 dev_kfree_skb(self->rxskb); 659 self->rxskb = NULL; 660 } 661 662 /* Stop IrLAP */ 663 if (self->irlap) { 664 irlap_close(self->irlap); 665 self->irlap = NULL; 666 } 667 668 netif_stop_queue(dev); 669 self->open = 0; 670 671 return 0; 672} 673 674static int bfin_sir_init_iobuf(iobuff_t *io, int size) 675{ 676 io->head = kmalloc(size, GFP_KERNEL); 677 if (!io->head) 678 return -ENOMEM; 679 io->truesize = size; 680 io->in_frame = FALSE; 681 io->state = OUTSIDE_FRAME; 682 io->data = io->head; 683 return 0; 684} 685 686static const struct net_device_ops bfin_sir_ndo = { 687 .ndo_open = bfin_sir_open, 688 .ndo_stop = bfin_sir_stop, 689 .ndo_start_xmit = bfin_sir_hard_xmit, 690 .ndo_do_ioctl = bfin_sir_ioctl, 691 .ndo_get_stats = bfin_sir_stats, 692}; 693 694static int bfin_sir_probe(struct platform_device *pdev) 695{ 696 struct net_device *dev; 697 struct bfin_sir_self *self; 698 unsigned int baudrate_mask; 699 struct bfin_sir_port *sir_port; 700 int err; 701 702 if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \ 703 per[pdev->id][3] == pdev->id) { 704 err = peripheral_request_list(per[pdev->id], DRIVER_NAME); 705 if (err) 706 return err; 707 } else { 708 dev_err(&pdev->dev, "Invalid pdev id, please check board file\n"); 709 return -ENODEV; 710 } 711 712 err = -ENOMEM; 713 sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL); 714 if (!sir_port) 715 goto err_mem_0; 716 717 bfin_sir_init_ports(sir_port, pdev); 718 719 dev = alloc_irdadev(sizeof(*self)); 720 if (!dev) 721 goto err_mem_1; 722 723 self = netdev_priv(dev); 724 self->dev = &pdev->dev; 725 self->sir_port = sir_port; 726 sir_port->dev = dev; 727 728 err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU); 729 if (err) 730 goto err_mem_2; 731 err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME); 732 if (err) 733 goto err_mem_3; 734 735 dev->netdev_ops = &bfin_sir_ndo; 736 dev->irq = sir_port->irq; 737 738 irda_init_max_qos_capabilies(&self->qos); 739 740 baudrate_mask = IR_9600; 741 742 switch (max_rate) { 743 case 115200: 744 baudrate_mask |= IR_115200; 745 case 57600: 746 baudrate_mask |= IR_57600; 747 case 38400: 748 baudrate_mask |= IR_38400; 749 case 19200: 750 baudrate_mask |= IR_19200; 751 case 9600: 752 break; 753 default: 754 dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n"); 755 } 756 757 self->qos.baud_rate.bits &= baudrate_mask; 758 759 self->qos.min_turn_time.bits = 1; /* 10 ms or more */ 760 761 irda_qos_bits_to_value(&self->qos); 762 763 err = register_netdev(dev); 764 765 if (err) { 766 kfree(self->tx_buff.head); 767err_mem_3: 768 kfree(self->rx_buff.head); 769err_mem_2: 770 free_netdev(dev); 771err_mem_1: 772 kfree(sir_port); 773err_mem_0: 774 peripheral_free_list(per[pdev->id]); 775 } else 776 platform_set_drvdata(pdev, sir_port); 777 778 return err; 779} 780 781static int bfin_sir_remove(struct platform_device *pdev) 782{ 783 struct bfin_sir_port *sir_port; 784 struct net_device *dev = NULL; 785 struct bfin_sir_self *self; 786 787 sir_port = platform_get_drvdata(pdev); 788 if (!sir_port) 789 return 0; 790 dev = sir_port->dev; 791 self = netdev_priv(dev); 792 unregister_netdev(dev); 793 kfree(self->tx_buff.head); 794 kfree(self->rx_buff.head); 795 free_netdev(dev); 796 kfree(sir_port); 797 798 return 0; 799} 800 801static struct platform_driver bfin_ir_driver = { 802 .probe = bfin_sir_probe, 803 .remove = bfin_sir_remove, 804 .suspend = bfin_sir_suspend, 805 .resume = bfin_sir_resume, 806 .driver = { 807 .name = DRIVER_NAME, 808 }, 809}; 810 811module_platform_driver(bfin_ir_driver); 812 813module_param(max_rate, int, 0); 814MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)"); 815 816MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>"); 817MODULE_DESCRIPTION("Blackfin IrDA driver"); 818MODULE_LICENSE("GPL"); 819