drivers/net/irda/rk29_ir.c

   1 /*\r
   2  * This program is free software; you can redistribute it and/or modify\r
   3  * it under the terms of the BSD Licence, GNU General Public License\r
   4  * as published by the Free Software Foundation; either version 2 of the\r
   5  * License, or (at your option) any later version\r
   6  */\r
   7 #include <linux/module.h>\r
   8 #include <linux/delay.h>\r
   9 #include <linux/errno.h>\r
  10 #include <linux/platform_device.h>\r
  11 #include <linux/fs.h>\r
  12 #include <linux/kernel.h>\r
  13 #include <linux/slab.h>\r
  14 #include <linux/mm.h>\r
  15 #include <linux/ioport.h>\r
  16 #include <linux/init.h>\r
  17 #include <linux/sched.h>\r
  18 #include <linux/pci.h>\r
  19 #include <linux/random.h>\r
  20 #include <linux/version.h>\r
  21 #include <linux/mutex.h>\r
  22 #include <linux/videodev2.h>\r
  23 #include <linux/dma-mapping.h>\r
  24 #include <linux/interrupt.h>\r
  25 #include <linux/kthread.h>\r
  26 #include <linux/highmem.h>\r
  27 #include <linux/freezer.h>\r
  28 #include <linux/netdevice.h>\r
  29 #include <linux/etherdevice.h>\r
  30 #include <linux/irq.h>\r
  31 #include <linux/wakelock.h>\r
  32 \r
  33 #include <mach/iomux.h>\r
  34 #include <mach/gpio.h>\r
  35 #include <mach/board.h>\r
  36 #include <mach/rk29_iomap.h>\r
  37 #include <mach/pmu.h>\r
  38 #include <mach/rk29-dma-pl330.h>\r
  39 \r
  40 #include "rk29_ir.h"\r
  41 \r
  42 #if 0\r
  43 #define RK29IR_DBG(x...) printk(x)\r
  44 #else\r
  45 #define RK29IR_DBG(x...)\r
  46 #endif\r
  47 \r
  48 #if 0\r
  49 #define RK29IR_DATA_DBG(x...) printk(x)\r
  50 #else\r
  51 #define RK29IR_DATA_DBG(x...)\r
  52 #endif\r
  53 \r
  54 #define IRDA_NAME               "rk_irda"\r
  55 \r
  56 struct irda_driver {\r
  57         struct irda_info *pin_info;\r
  58         struct device                   *dev;\r
  59 };\r
  60 \r
  61 #define IS_FIR(si)              ((si)->speed >= 4000000)\r
  62 static int max_rate = 115200;\r
  63 #define IRDA_FRAME_SIZE_LIMIT   BU92725GUW_FIFO_SIZE\r
  64 \r
  65 #define RK29_MAX_RXLEN 2047\r
  66 \r
  67 static void rk29_irda_fir_test(struct work_struct *work);\r
  68 static DECLARE_DELAYED_WORK(dwork, rk29_irda_fir_test);\r
  69 \r
  70 \r
  71 /*\r
  72  * Allocate and map the receive buffer, unless it is already allocated.\r
  73  */\r
  74 static int rk29_irda_rx_alloc(struct rk29_irda *si)\r
  75 {\r
  76         if (si->rxskb)\r
  77                 return 0;\r
  78 \r
  79         si->rxskb = alloc_skb(RK29_MAX_RXLEN + 1, GFP_ATOMIC);\r
  80 \r
  81         if (!si->rxskb) {\r
  82                 printk(KERN_ERR "rk29_ir: out of memory for RX SKB\n");\r
  83                 return -ENOMEM;\r
  84         }\r
  85 \r
  86         si->rxskb->len = 0;\r
  87 \r
  88         /*\r
  89          * Align any IP headers that may be contained\r
  90          * within the frame.\r
  91          */\r
  92         skb_reserve(si->rxskb, 1);\r
  93 \r
  94         return 0;\r
  95 }\r
  96 \r
  97 /*\r
  98  * Set the IrDA communications speed.\r
  99  */\r
 100 static int rk29_irda_set_speed(struct rk29_irda *si, int speed)\r
 101 {\r
 102         unsigned long flags;\r
 103         int ret = -EINVAL;\r
 104         \r
 105     printk("[%s][%d], speed=%d\n",__FUNCTION__,__LINE__,speed);\r
 106 \r
 107         switch (speed) {\r
 108         case 9600:      case 19200:     case 38400:\r
 109         case 57600:     case 115200:\r
 110                 \r
 111                 local_irq_save(flags);\r
 112                 \r
 113                 irda_hw_set_speed(speed);\r
 114 \r
 115                 si->speed = speed;\r
 116 \r
 117                 local_irq_restore(flags);\r
 118                 ret = 0;\r
 119                 break;\r
 120 \r
 121         case 4000000:\r
 122                 local_irq_save(flags);\r
 123 \r
 124                 si->speed = speed;\r
 125                 \r
 126                 irda_hw_set_speed(speed);\r
 127                 \r
 128                 rk29_irda_rx_alloc(si);\r
 129 \r
 130                 local_irq_restore(flags);\r
 131                 ret = 0;\r
 132                 break;\r
 133 \r
 134         default:\r
 135                 break;\r
 136         }\r
 137 \r
 138         return ret;\r
 139 }\r
 140 \r
 141 static irqreturn_t rk29_irda_irq(int irq, void *dev_id)\r
 142 {\r
 143     struct net_device *dev = (struct net_device *)dev_id;\r
 144     struct rk29_irda *si = netdev_priv(dev);\r
 145     u8 data[2048]={0,0};\r
 146     int tmp_len=0;\r
 147     int i=0;\r
 148     u32 irq_src = 0;    \r
 149         u32 irda_setptn = 0;\r
 150         \r
 151     irq_src = irda_hw_get_irqsrc();\r
 152         \r
 153     printk("[%s][%d], 0x%x\n",__FUNCTION__,__LINE__, irq_src);\r
 154         \r
 155         //disable_irq(dev->irq);\r
 156    \r
 157         /* EIR 1, 3, 11, 12 */\r
 158         irda_setptn |= irq_src & (REG_INT_EOFRX | REG_INT_TXE | REG_INT_WRE | REG_INT_RDE |\r
 159                                   REG_INT_CRC | REG_INT_OE | REG_INT_FE | REG_INT_AC | \r
 160                                   REG_INT_DECE | REG_INT_RDOE | REG_INT_DEX) ;\r
 161 \r
 162         /* error */\r
 163         if (irq_src & (REG_INT_TO| REG_INT_CRC | REG_INT_OE | REG_INT_FE | \r
 164                 REG_INT_AC | REG_INT_DECE | REG_INT_RDOE | REG_INT_DEX)) {\r
 165         RK29IR_DBG("[%s][%d]: do err\n",__FUNCTION__,__LINE__);\r
 166                 BU92725GUW_clr_fifo();\r
 167                 BU92725GUW_reset();\r
 168     }\r
 169 \r
 170     if (IS_FIR(si))  //FIR\r
 171     {\r
 172         RK29IR_DBG("[%s][%d]: FIR\n",__FUNCTION__,__LINE__);\r
 173         if(irda_hw_get_mode() == BU92725GUW_AUTO_MULTI_REV) {//rx\r
 174                         struct sk_buff *skb = si->rxskb;\r
 175             RK29IR_DBG("[%s][%d]: rx\n",__FUNCTION__,__LINE__);\r
 176             if (irda_setptn & (REG_INT_FE | REG_INT_OE | REG_INT_CRC | REG_INT_DECE)) {\r
 177                 if (irda_setptn & REG_INT_FE) {\r
 178                         printk(KERN_DEBUG "pxa_ir: fir receive frame error\n");\r
 179                     dev->stats.rx_frame_errors++;\r
 180                 } else {\r
 181                     printk(KERN_DEBUG "pxa_ir: fir receive abort\n");\r
 182                     dev->stats.rx_errors++;\r
 183                 }\r
 184             }\r
 185             if ((irda_setptn & (FRM_EVT_RX_EOFRX | FRM_EVT_RX_RDE | REG_INT_EOF))) {\r
 186                                 tmp_len = BU92725GUW_get_data(skb->data+skb->len);\r
 187                                 skb->len += tmp_len;                    \r
 188             }\r
 189                         if (irda_setptn & (REG_INT_EOF | FRM_EVT_RX_EOFRX)) {                           \r
 190                                 RK29IR_DBG("[%s][%d]: report data:\n",__FUNCTION__,__LINE__);\r
 191                                 si->rxskb = NULL;\r
 192                                 RK29IR_DATA_DBG("[%s][%d]: fir report data:\n",__FUNCTION__,__LINE__);\r
 193                                 for (i=0;i<skb->len;i++) {\r
 194                                         RK29IR_DATA_DBG("0x%2x ", skb->data[i]);\r
 195                                 }\r
 196                                 RK29IR_DATA_DBG("\n");\r
 197                                 \r
 198                                 skb_put(skb, skb->len);\r
 199                                 \r
 200                                 /* Feed it to IrLAP  */\r
 201                                 skb->dev = dev;\r
 202                                 skb_reset_mac_header(skb);\r
 203                                 skb->protocol = htons(ETH_P_IRDA);\r
 204                                 dev->stats.rx_packets++;\r
 205                                 dev->stats.rx_bytes += skb->len;\r
 206                                 \r
 207                                 /*\r
 208                                  * Before we pass the buffer up, allocate a new one.\r
 209                                  */\r
 210                                 rk29_irda_rx_alloc(si);\r
 211                                 \r
 212                                 netif_rx(skb);\r
 213                         }                                               \r
 214         }\r
 215                 else if (irda_hw_get_mode() == BU92725GUW_MULTI_SEND) {//tx\r
 216                         struct sk_buff *skb = si->txskb;                        \r
 217                         si->txskb = NULL;\r
 218             RK29IR_DBG("[%s][%d]: tx\n",__FUNCTION__,__LINE__);\r
 219             if (irda_setptn & (FRM_EVT_TX_TXE | FRM_EVT_TX_WRE)) {\r
 220                                 /*\r
 221                                  * Do we need to change speed?  Note that we're lazy\r
 222                                  * here - we don't free the old rxskb.  We don't need\r
 223                                  * to allocate a buffer either.\r
 224                                  */\r
 225                                 if (si->newspeed) {\r
 226                                         rk29_irda_set_speed(si, si->newspeed);\r
 227                                         si->newspeed = 0;\r
 228                                 }\r
 229                                 \r
 230                                 /*\r
 231                                  * Account and free the packet.\r
 232                                  */\r
 233                                 if (skb) {\r
 234                                         dev->stats.tx_packets ++;\r
 235                                         dev->stats.tx_bytes += skb->len;\r
 236                                         dev_kfree_skb_irq(skb);\r
 237                                 }\r
 238                                 \r
 239                                 /*\r
 240                                  * Make sure that the TX queue is available for sending\r
 241                                  * (for retries).  TX has priority over RX at all times.\r
 242                                  */\r
 243                                 netif_wake_queue(dev);\r
 244                                 \r
 245                                 irda_hw_set_moderx();\r
 246             }\r
 247                 }\r
 248     }\r
 249     else //SIR\r
 250     {\r
 251                 RK29IR_DBG("[%d][%s], sir\n", __LINE__, __FUNCTION__);\r
 252         if(irda_hw_get_mode() == BU92725GUW_REV) //rx\r
 253         {\r
 254                         RK29IR_DBG("[%d][%s], receive data:\n", __LINE__, __FUNCTION__);\r
 255             if(irda_setptn & (REG_INT_OE | REG_INT_FE ))\r
 256             {\r
 257                 dev->stats.rx_errors++;\r
 258                 if (irda_setptn & REG_INT_FE)\r
 259                     dev->stats.rx_frame_errors++;\r
 260                 if (irda_setptn & REG_INT_OE)\r
 261                     dev->stats.rx_fifo_errors++;\r
 262             }\r
 263             if((irda_setptn & ( FRM_EVT_RX_EOFRX| REG_INT_EOF /*|FRM_EVT_RX_RDE*/)))\r
 264             {\r
 265                 tmp_len = BU92725GUW_get_data(data);\r
 266                                 RK29IR_DATA_DBG("[%d][%s], sir receive data:\n", __LINE__, __FUNCTION__);\r
 267                 for(i=0;i<=tmp_len;i++)\r
 268                 {\r
 269                     RK29IR_DATA_DBG("0x%2x ",data[i]);\r
 270                     async_unwrap_char(dev, &dev->stats, &si->rx_buff, data[i]);\r
 271                 }\r
 272                                 RK29IR_DATA_DBG("\n");\r
 273              //BU92725GUW_clr_fifo();\r
 274             }\r
 275         }\r
 276         else if(irda_hw_get_mode() == BU92725GUW_SEND) //tx\r
 277         {\r
 278                         RK29IR_DBG("[%d][%s], transmit data\n", __LINE__, __FUNCTION__);\r
 279             if((irda_setptn & FRM_EVT_TX_TXE) && (si->tx_buff.len)) {\r
 280                                 RK29IR_DATA_DBG("[%d][%s], sir transmit data:\n", __LINE__, __FUNCTION__);\r
 281                                 for (i=0;i<si->tx_buff.len;i++) {\r
 282                                         RK29IR_DATA_DBG("0x%2x ", *(si->tx_buff.data)++);\r
 283                                 }\r
 284                                 RK29IR_DATA_DBG("\n");\r
 285 \r
 286                                 BU92725GUW_send_data(si->tx_buff.data, si->tx_buff.len, NULL, 0);\r
 287                 si->tx_buff.len = 0;\r
 288             }\r
 289             else if (si->tx_buff.len == 0) {\r
 290                 dev->stats.tx_packets++;\r
 291                 dev->stats.tx_bytes += si->tx_buff.data - si->tx_buff.head;\r
 292 \r
 293                 /*\r
 294                 * Ok, we've finished transmitting.  Now enable\r
 295                 * the receiver.  Sometimes we get a receive IRQ\r
 296                 * immediately after a transmit...\r
 297                 */\r
 298                 if (si->newspeed) {\r
 299                                         rk29_irda_set_speed(si, si->newspeed);\r
 300                     si->newspeed = 0;\r
 301                 } \r
 302 \r
 303                                 irda_hw_set_moderx();\r
 304                 \r
 305                 /* I'm hungry! */\r
 306                 netif_wake_queue(dev);\r
 307             }\r
 308         }\r
 309     }\r
 310     //enable_irq(dev->irq);\r
 311 \r
 312         return IRQ_HANDLED;\r
 313 }\r
 314 \r
 315 static int rk29_irda_start(struct net_device *dev)\r
 316 {\r
 317         struct rk29_irda *si = netdev_priv(dev);\r
 318         int err = 0;\r
 319         \r
 320         RK29IR_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);\r
 321         \r
 322         si->speed = 9600;\r
 323                 \r
 324         /*\r
 325          *  irda module power up\r
 326          */\r
 327         if (si->pdata->irda_pwr_ctl)\r
 328                 si->pdata->irda_pwr_ctl(1);\r
 329         si->power = 1;\r
 330         \r
 331         err = request_irq(dev->irq, rk29_irda_irq, IRQ_TYPE_LEVEL_LOW, dev->name, dev);//\r
 332         if (err) {\r
 333                 printk("line %d: %s request_irq failed\n", __LINE__, __func__);\r
 334                 goto err_irq;\r
 335         }\r
 336 \r
 337         /*\r
 338          * The interrupt must remain disabled for now.\r
 339          */\r
 340         disable_irq(dev->irq);\r
 341 \r
 342         /*\r
 343          * Setup the smc port for the specified speed.\r
 344          */\r
 345         err = irda_hw_startup(si);\r
 346         if (err) {              \r
 347                 printk("line %d: %s irda_hw_startup err\n", __LINE__, __func__);\r
 348                 goto err_startup;\r
 349         }\r
 350     irda_hw_set_moderx();\r
 351 \r
 352         /*\r
 353          * Open a new IrLAP layer instance.\r
 354          */\r
 355         si->irlap = irlap_open(dev, &si->qos, "rk29");\r
 356         err = -ENOMEM;\r
 357         if (!si->irlap) {\r
 358                 printk("line %d: %s irlap_open err\n", __LINE__, __func__);\r
 359                 goto err_irlap;\r
 360         }\r
 361         \r
 362         /*\r
 363          * Now enable the interrupt and start the queue\r
 364          */\r
 365         si->open = 1;\r
 366         enable_irq(dev->irq);\r
 367         netif_start_queue(dev);\r
 368         \r
 369         printk("rk29_ir: irda driver opened\n");\r
 370 \r
 371         //test\r
 372         //rk29_irda_set_speed(si, 4000000);\r
 373         //schedule_delayed_work(&dwork, msecs_to_jiffies(5000));\r
 374 \r
 375         return 0;\r
 376 \r
 377 err_irlap:\r
 378         si->open = 0;\r
 379         irda_hw_shutdown(si);\r
 380 err_startup:\r
 381         free_irq(dev->irq, dev);\r
 382 err_irq:\r
 383         return err;\r
 384 }\r
 385 \r
 386 static int rk29_irda_stop(struct net_device *dev)\r
 387 {\r
 388         struct rk29_irda *si = netdev_priv(dev);\r
 389         \r
 390         RK29IR_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);\r
 391 \r
 392         disable_irq(dev->irq);\r
 393         irda_hw_shutdown(si);\r
 394 \r
 395         /*\r
 396          * If we have been doing DMA receive, make sure we\r
 397          * tidy that up cleanly.\r
 398          */\r
 399         if (si->rxskb) {\r
 400                 dev_kfree_skb(si->rxskb);\r
 401                 si->rxskb = NULL;\r
 402         }\r
 403 \r
 404         /* Stop IrLAP */\r
 405         if (si->irlap) {\r
 406                 irlap_close(si->irlap);\r
 407                 si->irlap = NULL;\r
 408         }\r
 409 \r
 410         netif_stop_queue(dev);\r
 411         si->open = 0;\r
 412 \r
 413         /*\r
 414          * Free resources\r
 415          */\r
 416         free_irq(dev->irq, dev);\r
 417 \r
 418         //irda module power down\r
 419         if (si->pdata->irda_pwr_ctl)\r
 420                 si->pdata->irda_pwr_ctl(0);\r
 421 \r
 422         si->power = 0;\r
 423 \r
 424         return 0;\r
 425 }\r
 426 \r
 427 static int rk29_irda_hard_xmit(struct sk_buff *skb, struct net_device *dev)\r
 428 {\r
 429     struct rk29_irda *si = netdev_priv(dev);\r
 430     int speed = irda_get_next_speed(skb);\r
 431         int i;\r
 432 \r
 433         RK29IR_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);\r
 434     /*\r
 435      * Does this packet contain a request to change the interface\r
 436      * speed?  If so, remember it until we complete the transmission\r
 437      * of this frame.\r
 438      */\r
 439     if (speed != si->speed && speed != -1)\r
 440         si->newspeed = speed;\r
 441 \r
 442     /*\r
 443      * If this is an empty frame, we can bypass a lot.\r
 444      */\r
 445     if (skb->len == 0) {\r
 446         if (si->newspeed) {\r
 447             si->newspeed = 0;\r
 448                         rk29_irda_set_speed(si, speed);\r
 449         }\r
 450         dev_kfree_skb(skb);\r
 451         return NETDEV_TX_OK;\r
 452     }\r
 453 \r
 454     netif_stop_queue(dev);\r
 455 \r
 456     if (!IS_FIR(si)) {\r
 457         si->tx_buff.data = si->tx_buff.head;\r
 458         si->tx_buff.len  = async_wrap_skb(skb, si->tx_buff.data, si->tx_buff.truesize);\r
 459 \r
 460         /* Disable STUART interrupts and switch to transmit mode. */\r
 461         /* enable STUART and transmit interrupts */\r
 462          irda_hw_tx_enable_irq(BU92725GUW_SIR);\r
 463 \r
 464                 RK29IR_DATA_DBG("[%d][%s], sir transmit data:\n", __LINE__, __FUNCTION__);\r
 465                 for (i=0;i<si->tx_buff.len;i++) {\r
 466                         RK29IR_DATA_DBG("0x%2x ", *(si->tx_buff.data)++);\r
 467                 }\r
 468                 RK29IR_DATA_DBG("\n");\r
 469 \r
 470                 dev_kfree_skb(skb);\r
 471                 dev->trans_start = jiffies;\r
 472                 BU92725GUW_send_data(si->tx_buff.data, si->tx_buff.len, NULL, 0);\r
 473                 si->tx_buff.len = 0;\r
 474 \r
 475     } \r
 476         else {\r
 477         unsigned long mtt = irda_get_mtt(skb);\r
 478                 si->txskb = skb;\r
 479        \r
 480            irda_hw_tx_enable_irq(BU92725GUW_FIR);\r
 481 \r
 482           RK29IR_DATA_DBG("[%d][%s], fir transmit data:\n", __LINE__, __FUNCTION__);\r
 483           for (i=0;i<skb->len;i++) {\r
 484                   RK29IR_DATA_DBG("0x%2x ", skb->data[i]);\r
 485           }\r
 486           RK29IR_DATA_DBG("\n");\r
 487           \r
 488           dev->trans_start = jiffies; \r
 489        BU92725GUW_send_data(skb->data, skb->len, NULL, 0);\r
 490     }\r
 491 \r
 492     return NETDEV_TX_OK;\r
 493 }\r
 494 \r
 495 static int\r
 496 rk29_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)\r
 497 {\r
 498         struct if_irda_req *rq = (struct if_irda_req *)ifreq;\r
 499         struct rk29_irda *si = netdev_priv(dev);\r
 500         int ret = -EOPNOTSUPP;\r
 501 \r
 502         RK29IR_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);\r
 503 \r
 504         switch (cmd) {\r
 505         case SIOCSBANDWIDTH:\r
 506                 if (capable(CAP_NET_ADMIN)) {\r
 507                         /*\r
 508                          * We are unable to set the speed if the\r
 509                          * device is not running.\r
 510                          */\r
 511                         if (si->open) {\r
 512                                 ret = rk29_irda_set_speed(si, rq->ifr_baudrate );\r
 513                         } else {\r
 514                                 printk("rk29_irda_ioctl: SIOCSBANDWIDTH: !netif_running\n");\r
 515                                 ret = 0;\r
 516                         }\r
 517                 }\r
 518                 break;\r
 519 \r
 520         case SIOCSMEDIABUSY:\r
 521                 ret = -EPERM;\r
 522                 if (capable(CAP_NET_ADMIN)) {\r
 523                         irda_device_set_media_busy(dev, TRUE);\r
 524                         ret = 0;\r
 525                 }\r
 526                 break;\r
 527 \r
 528         case SIOCGRECEIVING:\r
 529                 rq->ifr_receiving = IS_FIR(si) ? 0\r
 530                                         : si->rx_buff.state != OUTSIDE_FRAME;\r
 531                 break;\r
 532 \r
 533         default:\r
 534                 break;\r
 535         }\r
 536 \r
 537         return ret;\r
 538 }\r
 539 \r
 540 static const struct net_device_ops rk29_irda_netdev_ops = {\r
 541         .ndo_open               = rk29_irda_start,\r
 542         .ndo_stop               = rk29_irda_stop,\r
 543         .ndo_start_xmit         = rk29_irda_hard_xmit,\r
 544         .ndo_do_ioctl           = rk29_irda_ioctl,\r
 545 };\r
 546 \r
 547 \r
 548 static int rk29_irda_init_iobuf(iobuff_t *io, int size)\r
 549 {\r
 550         io->head = kmalloc(size, GFP_KERNEL | GFP_DMA);\r
 551         if (io->head != NULL) {\r
 552                 io->truesize = size;\r
 553                 io->in_frame = FALSE;\r
 554                 io->state    = OUTSIDE_FRAME;\r
 555                 io->data     = io->head;\r
 556         }\r
 557         return io->head ? 0 : -ENOMEM;\r
 558 }\r
 559 \r
 560 static void rk29_irda_fir_test(struct work_struct *work)\r
 561 {\r
 562         char send_data[4] = {0,0,0,0};\r
 563         irda_hw_tx_enable_irq(BU92725GUW_FIR);\r
 564         \r
 565         BU92725GUW_send_data(send_data, 4, NULL, 0);\r
 566         \r
 567         schedule_delayed_work(&dwork, msecs_to_jiffies(5000));\r
 568         return ;\r
 569 }\r
 570 \r
 571 static int rk29_irda_probe(struct platform_device *pdev)\r
 572 {\r
 573     struct irda_info *mach_info = NULL;\r
 574         struct net_device *dev;\r
 575         struct rk29_irda *si;\r
 576         unsigned int baudrate_mask;\r
 577         int err = -ENOMEM;\r
 578 \r
 579     RK29IR_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);\r
 580 \r
 581     mach_info = pdev->dev.platform_data;\r
 582 \r
 583     if (mach_info)\r
 584                 mach_info->iomux_init();\r
 585 \r
 586     dev = alloc_irdadev(sizeof(struct rk29_irda));\r
 587         if (!dev) {\r
 588                 printk("line %d: rk29_ir malloc failed\n", __LINE__);\r
 589                 goto err_mem_1;\r
 590         }\r
 591     SET_NETDEV_DEV(dev, &pdev->dev);\r
 592         si = netdev_priv(dev);\r
 593         si->dev = &pdev->dev;\r
 594         si->pdata = pdev->dev.platform_data;\r
 595 \r
 596     /*\r
 597          * Initialise the HP-SIR buffers\r
 598          */\r
 599         err = rk29_irda_init_iobuf(&si->rx_buff, 14384);\r
 600         if (err) {\r
 601                 printk("line %d: rk29_ir malloc failed\n", __LINE__);\r
 602                 goto err_mem_2;\r
 603         }\r
 604         err = rk29_irda_init_iobuf(&si->tx_buff, 4000);\r
 605         if (err) {              \r
 606                 printk("line %d: rk29_ir malloc failed\n", __LINE__);\r
 607                 goto err_mem_3;\r
 608         }\r
 609         dev->netdev_ops = &rk29_irda_netdev_ops;\r
 610         dev->irq = gpio_to_irq(mach_info->intr_pin);\r
 611 \r
 612         irda_init_max_qos_capabilies(&si->qos);\r
 613 \r
 614         /*\r
 615          * We support original IRDA up to 115k2. (we don't currently\r
 616          * support 4Mbps).  Min Turn Time set to 1ms or greater.\r
 617          */\r
 618         baudrate_mask = IR_9600;\r
 619 \r
 620         switch (max_rate) {\r
 621         case 4000000:           baudrate_mask |= IR_4000000 << 8;\r
 622         case 115200:            baudrate_mask |= IR_115200;\r
 623         case 57600:                 baudrate_mask |= IR_57600;\r
 624         case 38400:                 baudrate_mask |= IR_38400;\r
 625         case 19200:                 baudrate_mask |= IR_19200;\r
 626         }\r
 627 \r
 628         si->qos.baud_rate.bits &= baudrate_mask;\r
 629         si->qos.min_turn_time.bits = 7;\r
 630 \r
 631         irda_qos_bits_to_value(&si->qos);\r
 632 \r
 633     /*\r
 634          * Initially enable HP-SIR modulation, and ensure that the port\r
 635          * is disabled.\r
 636          */\r
 637     irda_hw_init(si);\r
 638 \r
 639         err = register_netdev(dev);\r
 640         if (err) {      \r
 641                 printk("line %d: rk29_ir register_netdev failed\n", __LINE__);\r
 642                 goto err_register;\r
 643         }\r
 644         platform_set_drvdata(pdev, dev);\r
 645 \r
 646         //test\r
 647         //wake_lock_init(&w_lock, WAKE_LOCK_SUSPEND, "rk29_cir");\r
 648         //wake_lock(&w_lock);\r
 649         \r
 650         return 0;\r
 651         \r
 652 err_register:\r
 653         irda_hw_deinit(si);\r
 654         kfree(si->tx_buff.head);\r
 655 err_mem_3:\r
 656         kfree(si->rx_buff.head);\r
 657 err_mem_2:\r
 658         free_netdev(dev);\r
 659 err_mem_1:\r
 660    return err;\r
 661 \r
 662 }\r
 663 \r
 664 static int rk29_irda_remove(struct platform_device *pdev)\r
 665 {\r
 666         struct net_device *dev = platform_get_drvdata(pdev);\r
 667         RK29IR_DBG("line %d: enter %s\n", __LINE__, __FUNCTION__);\r
 668 \r
 669         if (dev) {\r
 670                 struct rk29_irda *si = netdev_priv(dev);\r
 671                 unregister_netdev(dev);\r
 672                 kfree(si->tx_buff.head);\r
 673                 kfree(si->rx_buff.head);\r
 674                 free_netdev(dev);\r
 675         irda_hw_deinit(si);\r
 676         }\r
 677 \r
 678         return 0;\r
 679 }\r
 680 \r
 681 \r
 682 static struct platform_driver irda_driver = {\r
 683         .driver = {\r
 684                 .name = IRDA_NAME,\r
 685         .owner  = THIS_MODULE,\r
 686         },\r
 687         .probe = rk29_irda_probe,\r
 688         .remove = rk29_irda_remove,\r
 689         //.suspend = rk29_irda_suspend,\r
 690         //.resume = rk29_irda_resume,\r
 691 };\r
 692 \r
 693 static int __init irda_init(void)\r
 694 {\r
 695         if (platform_driver_register(&irda_driver) != 0) {\r
 696         printk("Could not register irda driver\n");\r
 697         return -EINVAL;\r
 698         }\r
 699         return 0;\r
 700 }\r
 701 \r
 702 static void __exit irda_exit(void)\r
 703 {\r
 704         platform_driver_unregister(&irda_driver);\r
 705 }\r
 706 \r
 707 module_init(irda_init);\r
 708 module_exit(irda_exit);\r
 709 MODULE_AUTHOR("  zyw@rock-chips.com");\r
 710 MODULE_DESCRIPTION("Driver for irda device");\r
 711 MODULE_LICENSE("GPL");\r
 712 \r