drivers/misc/sc8800.c

   1 #include <linux/kernel.h>
   2 #include <linux/module.h>
   3 #include <linux/delay.h>
   4 #include <linux/device.h>
   5 #include <linux/spi/spi.h>
   6 #include <linux/spinlock.h>
   7 #include <linux/delay.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/miscdevice.h>
  10 #include <linux/wait.h>
  11 #include <linux/uaccess.h>
  12 #include <linux/fs.h>
  13 #include <linux/rwsem.h>
  14 #include <mach/gpio.h>
  15 #include <mach/iomux.h>
  16 #include <mach/board.h>
  17 #include <linux/wakelock.h>
  18
  19 #if 0
  20 #define sc8800_dbg(dev, format, arg...)         \
  21         dev_printk(KERN_INFO , dev , format , ## arg)
  22
  23 //#define SC8800_PRINT_BUF
  24 #else
  25 #define sc8800_dbg(dev, format, arg...)
  26 #endif
  27
  28 #define READ_TIMEOUT            30000  //no use
  29 #define WRITE_TIMEOUT           80  //80ms
  30
  31 #define RD_BUF_SIZE                     (16*PAGE_SIZE) // 64K
  32 #define WR_BUF_SIZE                     (2*PAGE_SIZE) // __get_free_pages(GFP_KERNEL, 1) ==> pages = 2^1 = 2
  33 #define MAX_RX_LIST                     256
  34
  35 #define BP_PACKET_SIZE          64
  36 #define BP_PACKET_HEAD_LEN  16
  37 #define BP_PACKET_DATA_LEN  48
  38
  39 struct plat_sc8800 {
  40         int slav_rts_pin;
  41         int slav_rdy_pin;
  42         int master_rts_pin;
  43         int master_rdy_pin;
  44         int poll_time;
  45         int (*io_init)(void);
  46         int (*io_deinit)(void);
  47 };
  48 struct bp_head{
  49         u16 tag;        //0x7e7f
  50         u16 type;       //0xaa55
  51         u32 length;     //the length of data after head(8192-128 bytes)
  52         u32 fram_num;   //no used , always 0
  53         u32 reserved;   ////reserved
  54         char data[BP_PACKET_DATA_LEN];
  55 };
  56
  57 struct sc8800_data {
  58         struct device                   *dev;
  59         struct spi_device               *spi;
  60         struct workqueue_struct *rx_wq;
  61         struct workqueue_struct *tx_wq;
  62         struct work_struct              rx_work;
  63         struct work_struct              tx_work;
  64         struct wake_lock        rx_wake;
  65         struct wake_lock  tx_wake;
  66
  67         wait_queue_head_t               waitrq;
  68         wait_queue_head_t               waitwq;
  69         spinlock_t                              lock;
  70
  71         int irq;
  72         int slav_rts;
  73         int slav_rdy;
  74         int master_rts;
  75         int master_rdy;
  76
  77         int write_finished;
  78         int write_tmo;
  79
  80         char *rx_buf;
  81         int     rx_len;
  82
  83         char *tx_buf;
  84         int     tx_len;
  85
  86         int rw_enable;
  87
  88         int is_suspend;
  89 };
  90 static DEFINE_MUTEX(sc8800s_lock);
  91 static DECLARE_RWSEM(sc8800_rsem);
  92 static DECLARE_RWSEM(sc8800_wsem);
  93 struct sc8800_data *g_sc8800 = NULL;
  94
  95
  96 static int bp_rts(struct sc8800_data *sc8800)
  97 {
  98         return gpio_get_value(sc8800->slav_rts);
  99 }
 100
 101 static int bp_rdy(struct sc8800_data *sc8800)
 102 {
 103         return gpio_get_value(sc8800->slav_rdy);
 104 }
 105
 106 static void ap_rts(struct sc8800_data *sc8800, int value)
 107 {
 108         gpio_set_value(sc8800->master_rts, value);
 109 }
 110
 111 static void ap_rdy(struct sc8800_data *sc8800, int value)
 112 {
 113         gpio_set_value(sc8800->master_rdy, value);
 114 }
 115 static void sc8800_print_buf(struct sc8800_data *sc8800, char *buf, const char *func, int len)
 116 {
 117 #ifdef SC8800_PRINT_BUF
 118         int i;
 119         char *tmp = NULL;
 120         tmp = kzalloc(len*7, GFP_KERNEL);
 121         sc8800_dbg(sc8800->dev, "%s buf[%d] = :\n", func, len);
 122         for(i = 0; i < len; i++){
 123                 if(i % 16 == 0 && i != 0)
 124                         sprintf(tmp, "%s\n", tmp);
 125                 sprintf(tmp, "%s[0x%2x] ", tmp, buf[i]);
 126         }
 127         printk("%s\n", tmp);
 128         kfree(tmp);
 129 #endif
 130         return;
 131 }
 132 static void buf_swp(char *buf, int len)
 133 {
 134         int i;
 135         char temp;
 136
 137         len = (len/2)*2;
 138         for(i = 0; i < len; i += 2)
 139         {
 140                 temp = buf[i];
 141                 buf[i] = buf[i+1];
 142                 buf[i+1] = temp;
 143         }
 144 }
 145 static void spi_in(struct sc8800_data *sc8800, char *tx_buf, unsigned len, int* err)
 146 {
 147         struct spi_message message;
 148         struct spi_transfer tran;
 149
 150         buf_swp(tx_buf, len);
 151         spi_write(sc8800->spi, tx_buf, len);
 152 }
 153
 154 static void spi_out(struct sc8800_data *sc8800, char *rx_buf, unsigned len, int* err)
 155 {
 156         struct spi_message message;
 157         struct spi_transfer tran;
 158         void *tmp_buf = NULL;
 159
 160         tmp_buf = kzalloc(16, GFP_KERNEL);
 161         if(!tmp_buf){
 162                 *err = -ENOMEM;
 163                 return;
 164         }
 165         memset(rx_buf, 0, len);
 166         tran.tx_buf = tmp_buf;
 167         tran.rx_buf = (void *)rx_buf;
 168         tran.len = len;
 169         tran.speed_hz = 0;
 170         tran.bits_per_word = 16;
 171
 172         spi_message_init(&message);
 173         spi_message_add_tail(&tran, &message);
 174         *err = spi_sync(sc8800->spi, &message);
 175         buf_swp(rx_buf, len);
 176         kfree(tmp_buf);
 177
 178 }
 179
 180 static int ap_get_head(struct sc8800_data *sc8800, struct bp_head *packet)
 181 {
 182         int err = 0, count = 5;
 183         char buf[BP_PACKET_SIZE];
 184
 185 retry:
 186         spi_out(sc8800, packet, BP_PACKET_SIZE, &err);
 187
 188         if(err < 0 && count > 0)
 189         {
 190                 dev_warn(sc8800->dev, "%s spi_out return error, retry count = %d\n",
 191                                 __func__, count);
 192                 count--;
 193                 mdelay(10);
 194                 goto retry;
 195         }
 196         if(err < 0)
 197                 return err;
 198
 199         //memcpy((char *)(packet), buf, BP_PACKET_SIZE);
 200
 201         sc8800_dbg(sc8800->dev, "%s tag = 0x%4x, type = 0x%4x, length = %x\n",
 202                         __func__, packet->tag, packet->type, packet->length);
 203
 204         if ((packet->tag != 0x7e7f) || (packet->type != 0xaa55))
 205                 return -1;
 206         else
 207                 return 0;
 208 }
 209
 210
 211 static int sc8800_rx(struct sc8800_data *sc8800)
 212 {
 213         int ret = 0, len, real_len;
 214         struct bp_head packet;
 215         char *buf = NULL;
 216
 217         ap_rdy(sc8800,0);
 218         ret = ap_get_head(sc8800, &packet);
 219
 220         if(ret < 0){
 221                 dev_err(sc8800->dev, "ERR: %s ap_get_head err = %d\n", __func__, ret);
 222                 goto out;
 223         }
 224         len = packet.length;
 225         if(len > BP_PACKET_DATA_LEN)
 226                 real_len =      (((len -BP_PACKET_DATA_LEN-1)/BP_PACKET_SIZE)+2)*BP_PACKET_SIZE;
 227         else
 228                 real_len = BP_PACKET_SIZE;
 229         if(len > RD_BUF_SIZE){
 230                 dev_err(sc8800->dev, "ERR: %s len[%d] is large than buffer size[%lu]\n",
 231                                 __func__, real_len, RD_BUF_SIZE);
 232                 goto out;
 233         }
 234         buf = kzalloc(real_len, GFP_KERNEL);
 235         if(!buf){
 236                 dev_err(sc8800->dev,"ERR: %s no memmory for rx_buf\n", __func__);
 237                 goto out;
 238         }
 239
 240         memcpy(buf, packet.data, BP_PACKET_DATA_LEN);
 241         if(len > BP_PACKET_DATA_LEN)
 242                 spi_out(sc8800, buf + BP_PACKET_DATA_LEN, real_len-BP_PACKET_SIZE, &ret);
 243
 244         if(ret < 0){
 245                 dev_err(sc8800->dev, "ERR: %s spi out err = %d\n", __func__, ret);
 246                 goto out;
 247         }
 248
 249         spin_lock(&sc8800->lock);
 250         if(sc8800->rx_len + len > RD_BUF_SIZE){
 251                 dev_warn(sc8800->dev, "WARN: %s read buffer is full\n", __func__);
 252         }else
 253         {
 254                 memcpy(sc8800->rx_buf+sc8800->rx_len, buf, len);
 255                 sc8800->rx_len += len;
 256         }
 257         spin_unlock(&sc8800->lock);
 258
 259         sc8800_dbg(sc8800->dev, "%s rx_len = %d\n", __func__, sc8800->rx_len);
 260
 261         ret = sc8800->rx_len;
 262
 263 out:
 264         ap_rdy(sc8800,1);
 265         if(buf)
 266                 kfree(buf);
 267         buf = NULL;
 268         return ret;
 269
 270 }
 271  static int sc8800_data_packet(char *dst, char *src, int src_len)
 272 {
 273         int dst_len = 0;
 274         struct bp_head packet;
 275
 276         if(src_len > BP_PACKET_DATA_LEN)
 277                 dst_len = (((src_len -BP_PACKET_DATA_LEN-1)/BP_PACKET_SIZE)+2)*BP_PACKET_SIZE;
 278         else
 279                 dst_len = BP_PACKET_SIZE;
 280
 281         packet.tag =0x7e7f;
 282         packet.type = 0xaa55;
 283         packet.length = src_len;
 284         packet.fram_num = 0;
 285         packet.reserved = 0;
 286
 287         memcpy(packet.data, src, BP_PACKET_DATA_LEN);
 288         memcpy(dst, (char *)&packet, BP_PACKET_SIZE);
 289         if(src_len >= BP_PACKET_DATA_LEN)
 290                 memcpy(dst+BP_PACKET_SIZE, src+BP_PACKET_DATA_LEN, src_len - BP_PACKET_DATA_LEN);
 291
 292         return dst_len;
 293  }
 294
 295 static int sc8800_tx(struct sc8800_data *sc8800)
 296 {
 297         int ret = 0, len;
 298
 299         char *buf = NULL;
 300
 301         sc8800->write_tmo = 0;
 302         buf = kzalloc(WR_BUF_SIZE + BP_PACKET_SIZE, GFP_KERNEL);
 303         if(!buf){
 304                 dev_err(sc8800->dev, "ERR: no memery for buf\n");
 305                 return -ENOMEM;
 306         }
 307         while(!bp_rts(sc8800)){
 308                 if(sc8800->write_tmo){
 309                         sc8800_dbg(sc8800->dev, "bp_rts = 0\n");
 310                         kfree(buf);
 311                         return -1;
 312                 }
 313                 schedule();
 314         }
 315         mutex_lock(&sc8800s_lock);
 316         #if defined(CONFIG_ARCH_RK30)
 317         ap_rts(sc8800,1);
 318         #else
 319         ap_rts(sc8800,0);
 320         #endif
 321 #if 1
 322         while(bp_rdy(sc8800)){
 323                 if(sc8800->write_tmo){
 324                         #if defined(CONFIG_ARCH_RK30)
 325                         ap_rts(sc8800,0);
 326                         #else
 327                         ap_rts(sc8800,1);
 328                         #endif
 329                         sc8800_dbg(sc8800->dev, "ERR: %s write timeout ->bp not ready (bp_rdy = 1)\n", __func__);
 330                         msleep(1);
 331                         kfree(buf);
 332                         mutex_unlock(&sc8800s_lock);
 333                         return -1;
 334                 }
 335                 schedule();
 336         }
 337 #endif
 338         len = sc8800_data_packet(buf, sc8800->tx_buf, sc8800->tx_len);
 339         spi_in(sc8800, buf, len, &ret);
 340
 341         if(ret < 0)
 342                 dev_err(sc8800->dev, "ERR: %s spi in err = %d\n", __func__, ret);
 343         #if defined(CONFIG_ARCH_RK30)
 344         ap_rts(sc8800,0);
 345         #else
 346         ap_rts(sc8800,1);
 347         #endif
 348         if(buf){
 349                 kfree(buf);
 350                 buf = NULL;
 351         }
 352
 353         mutex_unlock(&sc8800s_lock);
 354 #if 1
 355         while(!bp_rdy(sc8800)){
 356                 if(sc8800->write_tmo){
 357                         dev_err(sc8800->dev, "ERR: %s write timeout -> bp receiving (bp_rdy = 0)\n", __func__);
 358                         ret = -1;
 359                 }
 360                 schedule();
 361         }
 362 #endif
 363         return ret;
 364 }
 365
 366 static irqreturn_t sc8800_irq(int irq, void *dev_id)
 367 {
 368         struct sc8800_data *sc8800 = (struct sc8800_data *)dev_id;
 369
 370         sc8800_dbg(sc8800->dev, "%s\n", __func__);
 371 #if 0
 372         if(sc8800->is_suspend)
 373                 rk28_send_wakeup_key();
 374 #endif
 375         wake_lock(&sc8800->rx_wake);
 376         queue_work(sc8800->rx_wq, &sc8800->rx_work);
 377         return IRQ_HANDLED;
 378 }
 379
 380 static void sc8800_rx_work(struct work_struct *rx_work)
 381 {
 382         struct sc8800_data *sc8800 = container_of(rx_work, struct sc8800_data, rx_work);
 383
 384         sc8800_dbg(sc8800->dev, "%s\n", __func__);
 385         mutex_lock(&sc8800s_lock);
 386         sc8800->rx_len = sc8800_rx(sc8800);
 387         wake_unlock(&sc8800->rx_wake);
 388         if(sc8800->rx_len <= 0)
 389                 sc8800->rx_len = 0;
 390         wake_up(&sc8800->waitrq);
 391         mutex_unlock(&sc8800s_lock);
 392 }
 393 static void sc8800_tx_work(struct work_struct *tx_work)
 394 {
 395         struct sc8800_data *sc8800 = container_of(tx_work, struct sc8800_data, tx_work);
 396
 397         sc8800_dbg(sc8800->dev, "%s bp_rts = %d\n", __func__, bp_rts(sc8800));
 398         wake_lock(&sc8800->tx_wake);
 399         if(sc8800_tx(sc8800) == 0){
 400                 sc8800->write_finished = 1;
 401                 wake_up(&sc8800->waitwq);
 402         }
 403         wake_unlock(&sc8800->tx_wake);
 404 }
 405 static ssize_t sc8800_read(struct file *file,
 406                         char __user *buf, size_t count, loff_t *offset)
 407 {
 408         int ret = 0;
 409         ssize_t size = 0;
 410         struct sc8800_data *sc8800 = (struct sc8800_data *)file->private_data;
 411
 412         sc8800_dbg(sc8800->dev, "%s count = %d\n", __func__, count);
 413         if(!buf){
 414                 dev_err(sc8800->dev, "ERR: %s user_buf = NULL\n", __func__);
 415                 return -EFAULT;
 416         }
 417         down_write(&sc8800_rsem);
 418         if(!(file->f_flags & O_NONBLOCK)){
 419                 ret = wait_event_interruptible(sc8800->waitrq, (sc8800->rx_len > 0 || (sc8800->rw_enable <= 0)));
 420                 if (ret) {
 421                         up_write(&sc8800_rsem);
 422                         return ret;
 423                 }
 424         }
 425         if(sc8800->rw_enable <= 0){
 426                 dev_err(sc8800->dev, "ERR: %s sc8800 is released\n", __func__);
 427                 up_write(&sc8800_rsem);
 428                 return -EFAULT;
 429         }
 430         if(sc8800->rx_len == 0){
 431                 dev_warn(sc8800->dev, "WARN: %s nonblock read, rx_len = 0\n", __func__);
 432                 return 0;
 433         }
 434         spin_lock(&sc8800->lock);
 435         sc8800_print_buf(sc8800, sc8800->rx_buf, __func__, sc8800->rx_len);
 436         if(sc8800->rx_len > count){
 437                 size = count;
 438                 ret = copy_to_user(buf, sc8800->rx_buf, count);
 439         }else{
 440                 size = sc8800->rx_len;
 441                 ret = copy_to_user(buf, sc8800->rx_buf, sc8800->rx_len);
 442         }
 443
 444         if(ret < 0){
 445                 dev_err(sc8800->dev, "ERR: %s copy to user ret = %d\n", __func__, ret);
 446                 spin_unlock(&sc8800->lock);
 447                 up_write(&sc8800_rsem);
 448                 return -EFAULT;
 449         }
 450         if(sc8800->rx_len > count)
 451                 memmove(sc8800->rx_buf, sc8800->rx_buf + count, sc8800->rx_len - count);
 452
 453         sc8800->rx_len -= size;
 454         spin_unlock(&sc8800->lock);
 455         up_write(&sc8800_rsem);
 456         return size;
 457 }
 458 static ssize_t sc8800_write(struct file *file,
 459                         const char __user *buf, size_t count, loff_t *offset)
 460 {
 461         int ret = 0;
 462         struct sc8800_data *sc8800 = (struct sc8800_data *)file->private_data;
 463
 464         sc8800_dbg(sc8800->dev, "%s count = %d\n", __func__, count);
 465         if(count > WR_BUF_SIZE){
 466                 dev_err(sc8800->dev, "ERR: %s count[%u] > WR_BUF_SIZE[%lu]\n",
 467                                 __func__, count, WR_BUF_SIZE);
 468                 return -EFAULT;
 469         }
 470         down_write(&sc8800_wsem);
 471         sc8800_print_buf(sc8800, sc8800->tx_buf, __func__, count);
 472         memset(sc8800->tx_buf, 0, WR_BUF_SIZE);
 473         ret = copy_from_user(sc8800->tx_buf, buf, count);
 474         if(ret < 0){
 475                 dev_err(sc8800->dev, "ERR: %s copy from user ret = %d\n", __func__, ret);
 476                 up_write(&sc8800_wsem);
 477                 return -EFAULT;
 478         }
 479
 480         sc8800->write_finished = 0;
 481         sc8800->tx_len = count;
 482         queue_work(sc8800->tx_wq, &sc8800->tx_work);
 483
 484         ret = wait_event_timeout(sc8800->waitwq,
 485                                 (sc8800->write_finished || sc8800->rw_enable <= 0),
 486                                 msecs_to_jiffies(WRITE_TIMEOUT));
 487         if(sc8800->rw_enable <= 0){
 488                 dev_err(sc8800->dev, "ERR: %ssc8800 is released\n", __func__);
 489                 up_write(&sc8800_wsem);
 490                 return  -EFAULT;
 491         }
 492         if(ret == 0){
 493                 sc8800->write_tmo = 1;
 494                 dev_err(sc8800->dev, "ERR: %swrite timeout\n", __func__);
 495                 up_write(&sc8800_wsem);
 496                 return -ETIMEDOUT;
 497                 //return count;
 498         }else{
 499                 up_write(&sc8800_wsem);
 500                 return count;
 501         }
 502 }
 503
 504 static int sc8800_open(struct inode *inode, struct file *file)
 505 {
 506         file->private_data = g_sc8800;
 507
 508         sc8800_dbg(g_sc8800->dev, "%s\n", __func__);
 509         g_sc8800->write_finished = 0;
 510         g_sc8800->write_tmo = 0;
 511         g_sc8800->rw_enable++;
 512         return 0;
 513 }
 514 static int sc8800_release(struct inode *inode, struct file *file)
 515 {
 516         struct sc8800_data *sc8800 = (struct sc8800_data *)file->private_data;
 517
 518         sc8800_dbg(sc8800->dev, "%s\n", __func__);
 519         if(sc8800->rw_enable > 0)
 520                 sc8800->rw_enable--;
 521         wake_up(&sc8800->waitrq);
 522         wake_up(&sc8800->waitwq);
 523
 524         return 0;
 525 }
 526 static const struct file_operations sc8800_fops = {
 527         .open = sc8800_open,
 528         .release = sc8800_release,
 529         .read = sc8800_read,
 530         .write = sc8800_write,
 531 };
 532 static struct miscdevice sc8800_device = {
 533         .minor = MISC_DYNAMIC_MINOR,
 534         .name = "sc8800",
 535         .fops = &sc8800_fops,
 536 };
 537
 538 static int __devinit sc8800_probe(struct spi_device *spi)
 539 {
 540         int ret = 0;
 541         unsigned long page;
 542         struct sc8800_data *sc8800 = NULL;
 543         struct plat_sc8800 *pdata = NULL;
 544
 545         pdata = spi->dev.platform_data;
 546         if (!pdata) {
 547                 dev_err(&spi->dev, "ERR: spi data missing\n");
 548                 return -ENODEV;
 549         }
 550
 551         sc8800 = (struct sc8800_data *)kzalloc(sizeof(struct sc8800_data), GFP_KERNEL);
 552         if(!sc8800){
 553                 dev_err(&spi->dev, "ERR: no memory for sc8800\n");
 554                 return -ENOMEM;
 555         }
 556         g_sc8800 = sc8800;
 557
 558         page = __get_free_pages(GFP_KERNEL, 4); //2^4 * 4K = 64K
 559         if(!page){
 560                 dev_err(&spi->dev, "ERR: no memory for rx_buf\n");
 561                 ret = -ENOMEM;
 562                 goto err_get_free_page1;
 563         }
 564         sc8800->rx_buf = (char *)page;
 565
 566         page = __get_free_pages(GFP_KERNEL, 1);//2^1 * 4K = 8K
 567         if(!page){
 568                 dev_err(&spi->dev, "ERR: no memory for tx_buf\n");
 569                 ret = -ENOMEM;
 570                 goto err_get_free_page2;
 571         }
 572         sc8800->tx_buf = (char *)page;
 573
 574         sc8800->spi = spi;
 575         sc8800->dev = &spi->dev;
 576         dev_set_drvdata(sc8800->dev, sc8800);
 577
 578         spi->bits_per_word = 16;
 579         spi->mode = SPI_MODE_2;
 580         spi->max_speed_hz = 1000*1000*8;
 581         ret = spi_setup(spi);
 582         if (ret < 0){
 583                 dev_err(sc8800->dev, "ERR: fail to setup spi\n");
 584                 goto err_spi_setup;
 585         }
 586
 587         if(pdata && pdata->io_init)
 588                 pdata->io_init();
 589
 590         sc8800->irq = gpio_to_irq(pdata->slav_rts_pin);
 591         sc8800->slav_rts = pdata->slav_rts_pin;
 592         sc8800->slav_rdy = pdata->slav_rdy_pin;
 593         sc8800->master_rts = pdata->master_rts_pin;
 594         sc8800->master_rdy = pdata->master_rdy_pin;
 595
 596         ret = gpio_request(sc8800->slav_rts, "salv_rts");
 597         if(ret < 0){
 598                 dev_err(sc8800->dev, "ERR: gpio request slav_rts[%d]\n", sc8800->slav_rts);
 599                 goto err_gpio_request_slav_rts;
 600         }
 601         ret = gpio_request(sc8800->slav_rdy, "slav_rdy");
 602         if(ret < 0){
 603                 dev_err(sc8800->dev, "ERR: gpio request slav_rdy\n");
 604                 goto err_gpio_request_slav_rdy;
 605         }
 606         ret = gpio_request(sc8800->master_rts, "master_rts");
 607         if(ret < 0){
 608                 dev_err(sc8800->dev, "ERR: gpio request master_rts\n");
 609                 goto err_gpio_request_master_rts;
 610         }
 611         ret = gpio_request(sc8800->master_rdy, "master_rdy");
 612         if(ret < 0){
 613                 dev_err(sc8800->dev, "ERR: gpio request master_rdy\n");
 614                 goto err_gpio_request_master_rdy;
 615         }
 616         gpio_direction_input(sc8800->slav_rts);
 617         gpio_pull_updown(sc8800->slav_rts, GPIOPullUp);
 618         gpio_direction_input(sc8800->slav_rdy);
 619         gpio_pull_updown(sc8800->slav_rdy, GPIOPullUp);
 620         gpio_direction_output(sc8800->master_rts, GPIO_HIGH);
 621         gpio_direction_output(sc8800->master_rdy, GPIO_HIGH);
 622
 623
 624         init_waitqueue_head(&sc8800->waitrq);
 625         init_waitqueue_head(&sc8800->waitwq);
 626         spin_lock_init(&sc8800->lock);
 627
 628         ret = misc_register(&sc8800_device);
 629         if(ret < 0){
 630
 631                 dev_err(sc8800->dev, "ERR: fail to register misc device\n");
 632                 goto err_misc_register;
 633         }
 634         ret = request_irq(sc8800->irq, sc8800_irq, IRQF_TRIGGER_FALLING, "sc8800", sc8800);
 635         if(ret < 0){
 636                 dev_err(sc8800->dev, "ERR: fail to request irq %d\n", sc8800->irq);
 637                 goto err_request_irq;
 638         }
 639         wake_lock_init(&sc8800->rx_wake, WAKE_LOCK_SUSPEND, "sc8800_rx_wake");
 640         wake_lock_init(&sc8800->tx_wake, WAKE_LOCK_SUSPEND, "sc8800_tx_wake");
 641         enable_irq_wake(sc8800->irq);
 642         sc8800->rx_wq = create_workqueue("sc8800_rxwq");
 643         sc8800->tx_wq = create_workqueue("sc8800_txwq");
 644         INIT_WORK(&sc8800->rx_work, sc8800_rx_work);
 645         INIT_WORK(&sc8800->tx_work, sc8800_tx_work);
 646         dev_info(sc8800->dev, "sc8800 probe ok\n");
 647         return 0;
 648
 649 err_request_irq:
 650         gpio_free(sc8800->master_rdy);
 651 err_misc_register:
 652         misc_deregister(&sc8800_device);
 653 err_gpio_request_master_rdy:
 654         gpio_free(sc8800->master_rts);
 655 err_gpio_request_master_rts:
 656         gpio_free(sc8800->slav_rdy);
 657 err_gpio_request_slav_rdy:
 658         gpio_free(sc8800->slav_rts);
 659 err_gpio_request_slav_rts:
 660 err_spi_setup:
 661         free_page((unsigned long)sc8800->tx_buf);
 662 err_get_free_page2:
 663         free_page((unsigned long)sc8800->rx_buf);
 664 err_get_free_page1:
 665         kfree(sc8800);
 666         sc8800 = NULL;
 667         g_sc8800 = NULL;
 668         return ret;
 669 }
 670
 671 static int __devexit sc8800_remove(struct spi_device *spi)
 672 {
 673         struct sc8800_data *sc8800 = dev_get_drvdata(&spi->dev);
 674
 675         destroy_workqueue(sc8800->rx_wq);
 676         destroy_workqueue(sc8800->tx_wq);
 677         free_irq(sc8800->irq, sc8800);
 678         gpio_free(sc8800->master_rdy);
 679         gpio_free(sc8800->master_rts);
 680         gpio_free(sc8800->slav_rdy);
 681         gpio_free(sc8800->slav_rts);
 682         free_page((unsigned long)sc8800->tx_buf);
 683         free_page((unsigned long)sc8800->rx_buf);
 684         kfree(sc8800);
 685         sc8800 = NULL;
 686         return 0;
 687 }
 688
 689 #ifdef CONFIG_PM
 690
 691 static int sc8800_suspend(struct spi_device *spi, pm_message_t state)
 692 {
 693         struct sc8800_data *sc8800 = dev_get_drvdata(&spi->dev);
 694
 695         sc8800->is_suspend = 1;
 696         return 0;
 697 }
 698
 699 static int sc8800_resume(struct spi_device *spi)
 700 {
 701         struct sc8800_data *sc8800 = dev_get_drvdata(&spi->dev);
 702
 703
 704         sc8800->is_suspend = 0;
 705         return 0;
 706 }
 707
 708 #else
 709 #define sc8800_suspend NULL
 710 #define sc8800_resume  NULL
 711 #endif
 712
 713 static struct spi_driver sc8800_driver = {
 714         .driver = {
 715                 .name           = "sc8800",
 716                 .bus            = &spi_bus_type,
 717                 .owner          = THIS_MODULE,
 718         },
 719
 720         .probe          = sc8800_probe,
 721         .remove         = __devexit_p(sc8800_remove),
 722         .suspend        = sc8800_suspend,
 723         .resume         = sc8800_resume,
 724 };
 725
 726 static int __init sc8800_init(void)
 727 {
 728         printk("sc8800_init\n");
 729         return spi_register_driver(&sc8800_driver);
 730 }
 731 module_init(sc8800_init);
 732
 733 static void __exit sc8800_exit(void)
 734 {
 735         spi_unregister_driver(&sc8800_driver);
 736 }
 737 module_exit(sc8800_exit);
 738
 739 MODULE_DESCRIPTION("SC8800 driver");
 740 MODULE_LICENSE("GPL");
 741 MODULE_ALIAS("spi:SC8800");