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>
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>
20 #define sc8800_dbg(dev, format, arg...) \
21 dev_printk(KERN_INFO , dev , format , ## arg)
23 //#define SC8800_PRINT_BUF
25 #define sc8800_dbg(dev, format, arg...)
28 #define READ_TIMEOUT 30000 //no use
29 #define WRITE_TIMEOUT 80 //80ms
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
35 #define BP_PACKET_SIZE 64
36 #define BP_PACKET_HEAD_LEN 16
37 #define BP_PACKET_DATA_LEN 48
46 int (*io_deinit)(void);
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];
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;
67 wait_queue_head_t waitrq;
68 wait_queue_head_t waitwq;
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;
96 static int bp_rts(struct sc8800_data *sc8800)
98 return gpio_get_value(sc8800->slav_rts);
101 static int bp_rdy(struct sc8800_data *sc8800)
103 return gpio_get_value(sc8800->slav_rdy);
106 static void ap_rts(struct sc8800_data *sc8800, int value)
108 gpio_set_value(sc8800->master_rts, value);
111 static void ap_rdy(struct sc8800_data *sc8800, int value)
113 gpio_set_value(sc8800->master_rdy, value);
115 static void sc8800_print_buf(struct sc8800_data *sc8800, char *buf, const char *func, int len)
117 #ifdef SC8800_PRINT_BUF
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]);
132 static void buf_swp(char *buf, int len)
138 for(i = 0; i < len; i += 2)
145 static void spi_in(struct sc8800_data *sc8800, char *tx_buf, unsigned len, int* err)
147 struct spi_message message;
148 struct spi_transfer tran;
150 buf_swp(tx_buf, len);
151 spi_write(sc8800->spi, tx_buf, len);
154 static void spi_out(struct sc8800_data *sc8800, char *rx_buf, unsigned len, int* err)
156 struct spi_message message;
157 struct spi_transfer tran;
158 void *tmp_buf = NULL;
160 tmp_buf = kzalloc(16, GFP_KERNEL);
165 memset(rx_buf, 0, len);
166 tran.tx_buf = tmp_buf;
167 tran.rx_buf = (void *)rx_buf;
170 tran.bits_per_word = 16;
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);
180 static int ap_get_head(struct sc8800_data *sc8800, struct bp_head *packet)
182 int err = 0, count = 5;
183 char buf[BP_PACKET_SIZE];
186 spi_out(sc8800, packet, BP_PACKET_SIZE, &err);
188 if(err < 0 && count > 0)
190 dev_warn(sc8800->dev, "%s spi_out return error, retry count = %d\n",
199 //memcpy((char *)(packet), buf, BP_PACKET_SIZE);
201 sc8800_dbg(sc8800->dev, "%s tag = 0x%4x, type = 0x%4x, length = %x\n",
202 __func__, packet->tag, packet->type, packet->length);
204 if ((packet->tag != 0x7e7f) || (packet->type != 0xaa55))
211 static int sc8800_rx(struct sc8800_data *sc8800)
213 int ret = 0, len, real_len;
214 struct bp_head packet;
218 ret = ap_get_head(sc8800, &packet);
221 dev_err(sc8800->dev, "ERR: %s ap_get_head err = %d\n", __func__, ret);
225 if(len > BP_PACKET_DATA_LEN)
226 real_len = (((len -BP_PACKET_DATA_LEN-1)/BP_PACKET_SIZE)+2)*BP_PACKET_SIZE;
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);
234 buf = kzalloc(real_len, GFP_KERNEL);
236 dev_err(sc8800->dev,"ERR: %s no memmory for rx_buf\n", __func__);
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);
245 dev_err(sc8800->dev, "ERR: %s spi out err = %d\n", __func__, ret);
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__);
254 memcpy(sc8800->rx_buf+sc8800->rx_len, buf, len);
255 sc8800->rx_len += len;
257 spin_unlock(&sc8800->lock);
259 sc8800_dbg(sc8800->dev, "%s rx_len = %d\n", __func__, sc8800->rx_len);
261 ret = sc8800->rx_len;
271 static int sc8800_data_packet(char *dst, char *src, int src_len)
274 struct bp_head packet;
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;
279 dst_len = BP_PACKET_SIZE;
282 packet.type = 0xaa55;
283 packet.length = src_len;
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);
295 static int sc8800_tx(struct sc8800_data *sc8800)
301 sc8800->write_tmo = 0;
302 buf = kzalloc(WR_BUF_SIZE + BP_PACKET_SIZE, GFP_KERNEL);
304 dev_err(sc8800->dev, "ERR: no memery for buf\n");
307 while(!bp_rts(sc8800)){
308 if(sc8800->write_tmo){
309 sc8800_dbg(sc8800->dev, "bp_rts = 0\n");
315 mutex_lock(&sc8800s_lock);
316 #if defined(CONFIG_ARCH_RK30)
322 while(bp_rdy(sc8800)){
323 if(sc8800->write_tmo){
324 #if defined(CONFIG_ARCH_RK30)
329 sc8800_dbg(sc8800->dev, "ERR: %s write timeout ->bp not ready (bp_rdy = 1)\n", __func__);
332 mutex_unlock(&sc8800s_lock);
338 len = sc8800_data_packet(buf, sc8800->tx_buf, sc8800->tx_len);
339 spi_in(sc8800, buf, len, &ret);
342 dev_err(sc8800->dev, "ERR: %s spi in err = %d\n", __func__, ret);
343 #if defined(CONFIG_ARCH_RK30)
353 mutex_unlock(&sc8800s_lock);
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__);
366 static irqreturn_t sc8800_irq(int irq, void *dev_id)
368 struct sc8800_data *sc8800 = (struct sc8800_data *)dev_id;
370 sc8800_dbg(sc8800->dev, "%s\n", __func__);
372 if(sc8800->is_suspend)
373 rk28_send_wakeup_key();
375 wake_lock(&sc8800->rx_wake);
376 queue_work(sc8800->rx_wq, &sc8800->rx_work);
380 static void sc8800_rx_work(struct work_struct *rx_work)
382 struct sc8800_data *sc8800 = container_of(rx_work, struct sc8800_data, rx_work);
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)
390 wake_up(&sc8800->waitrq);
391 mutex_unlock(&sc8800s_lock);
393 static void sc8800_tx_work(struct work_struct *tx_work)
395 struct sc8800_data *sc8800 = container_of(tx_work, struct sc8800_data, tx_work);
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);
403 wake_unlock(&sc8800->tx_wake);
405 static ssize_t sc8800_read(struct file *file,
406 char __user *buf, size_t count, loff_t *offset)
410 struct sc8800_data *sc8800 = (struct sc8800_data *)file->private_data;
412 sc8800_dbg(sc8800->dev, "%s count = %d\n", __func__, count);
414 dev_err(sc8800->dev, "ERR: %s user_buf = NULL\n", __func__);
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)));
421 up_write(&sc8800_rsem);
425 if(sc8800->rw_enable <= 0){
426 dev_err(sc8800->dev, "ERR: %s sc8800 is released\n", __func__);
427 up_write(&sc8800_rsem);
430 if(sc8800->rx_len == 0){
431 dev_warn(sc8800->dev, "WARN: %s nonblock read, rx_len = 0\n", __func__);
434 spin_lock(&sc8800->lock);
435 sc8800_print_buf(sc8800, sc8800->rx_buf, __func__, sc8800->rx_len);
436 if(sc8800->rx_len > count){
438 ret = copy_to_user(buf, sc8800->rx_buf, count);
440 size = sc8800->rx_len;
441 ret = copy_to_user(buf, sc8800->rx_buf, sc8800->rx_len);
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);
450 if(sc8800->rx_len > count)
451 memmove(sc8800->rx_buf, sc8800->rx_buf + count, sc8800->rx_len - count);
453 sc8800->rx_len -= size;
454 spin_unlock(&sc8800->lock);
455 up_write(&sc8800_rsem);
458 static ssize_t sc8800_write(struct file *file,
459 const char __user *buf, size_t count, loff_t *offset)
462 struct sc8800_data *sc8800 = (struct sc8800_data *)file->private_data;
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);
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);
475 dev_err(sc8800->dev, "ERR: %s copy from user ret = %d\n", __func__, ret);
476 up_write(&sc8800_wsem);
480 sc8800->write_finished = 0;
481 sc8800->tx_len = count;
482 queue_work(sc8800->tx_wq, &sc8800->tx_work);
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);
493 sc8800->write_tmo = 1;
494 dev_err(sc8800->dev, "ERR: %swrite timeout\n", __func__);
495 up_write(&sc8800_wsem);
499 up_write(&sc8800_wsem);
504 static int sc8800_open(struct inode *inode, struct file *file)
506 file->private_data = g_sc8800;
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++;
514 static int sc8800_release(struct inode *inode, struct file *file)
516 struct sc8800_data *sc8800 = (struct sc8800_data *)file->private_data;
518 sc8800_dbg(sc8800->dev, "%s\n", __func__);
519 if(sc8800->rw_enable > 0)
521 wake_up(&sc8800->waitrq);
522 wake_up(&sc8800->waitwq);
526 static const struct file_operations sc8800_fops = {
528 .release = sc8800_release,
530 .write = sc8800_write,
532 static struct miscdevice sc8800_device = {
533 .minor = MISC_DYNAMIC_MINOR,
535 .fops = &sc8800_fops,
538 static int __devinit sc8800_probe(struct spi_device *spi)
542 struct sc8800_data *sc8800 = NULL;
543 struct plat_sc8800 *pdata = NULL;
545 pdata = spi->dev.platform_data;
547 dev_err(&spi->dev, "ERR: spi data missing\n");
551 sc8800 = (struct sc8800_data *)kzalloc(sizeof(struct sc8800_data), GFP_KERNEL);
553 dev_err(&spi->dev, "ERR: no memory for sc8800\n");
558 page = __get_free_pages(GFP_KERNEL, 4); //2^4 * 4K = 64K
560 dev_err(&spi->dev, "ERR: no memory for rx_buf\n");
562 goto err_get_free_page1;
564 sc8800->rx_buf = (char *)page;
566 page = __get_free_pages(GFP_KERNEL, 1);//2^1 * 4K = 8K
568 dev_err(&spi->dev, "ERR: no memory for tx_buf\n");
570 goto err_get_free_page2;
572 sc8800->tx_buf = (char *)page;
575 sc8800->dev = &spi->dev;
576 dev_set_drvdata(sc8800->dev, sc8800);
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);
583 dev_err(sc8800->dev, "ERR: fail to setup spi\n");
587 if(pdata && pdata->io_init)
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;
596 ret = gpio_request(sc8800->slav_rts, "salv_rts");
598 dev_err(sc8800->dev, "ERR: gpio request slav_rts[%d]\n", sc8800->slav_rts);
599 goto err_gpio_request_slav_rts;
601 ret = gpio_request(sc8800->slav_rdy, "slav_rdy");
603 dev_err(sc8800->dev, "ERR: gpio request slav_rdy\n");
604 goto err_gpio_request_slav_rdy;
606 ret = gpio_request(sc8800->master_rts, "master_rts");
608 dev_err(sc8800->dev, "ERR: gpio request master_rts\n");
609 goto err_gpio_request_master_rts;
611 ret = gpio_request(sc8800->master_rdy, "master_rdy");
613 dev_err(sc8800->dev, "ERR: gpio request master_rdy\n");
614 goto err_gpio_request_master_rdy;
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);
624 init_waitqueue_head(&sc8800->waitrq);
625 init_waitqueue_head(&sc8800->waitwq);
626 spin_lock_init(&sc8800->lock);
628 ret = misc_register(&sc8800_device);
631 dev_err(sc8800->dev, "ERR: fail to register misc device\n");
632 goto err_misc_register;
634 ret = request_irq(sc8800->irq, sc8800_irq, IRQF_TRIGGER_FALLING, "sc8800", sc8800);
636 dev_err(sc8800->dev, "ERR: fail to request irq %d\n", sc8800->irq);
637 goto err_request_irq;
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");
650 gpio_free(sc8800->master_rdy);
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:
661 free_page((unsigned long)sc8800->tx_buf);
663 free_page((unsigned long)sc8800->rx_buf);
671 static int __devexit sc8800_remove(struct spi_device *spi)
673 struct sc8800_data *sc8800 = dev_get_drvdata(&spi->dev);
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);
691 static int sc8800_suspend(struct spi_device *spi, pm_message_t state)
693 struct sc8800_data *sc8800 = dev_get_drvdata(&spi->dev);
695 sc8800->is_suspend = 1;
699 static int sc8800_resume(struct spi_device *spi)
701 struct sc8800_data *sc8800 = dev_get_drvdata(&spi->dev);
704 sc8800->is_suspend = 0;
709 #define sc8800_suspend NULL
710 #define sc8800_resume NULL
713 static struct spi_driver sc8800_driver = {
716 .bus = &spi_bus_type,
717 .owner = THIS_MODULE,
720 .probe = sc8800_probe,
721 .remove = __devexit_p(sc8800_remove),
722 .suspend = sc8800_suspend,
723 .resume = sc8800_resume,
726 static int __init sc8800_init(void)
728 printk("sc8800_init\n");
729 return spi_register_driver(&sc8800_driver);
731 module_init(sc8800_init);
733 static void __exit sc8800_exit(void)
735 spi_unregister_driver(&sc8800_driver);
737 module_exit(sc8800_exit);
739 MODULE_DESCRIPTION("SC8800 driver");
740 MODULE_LICENSE("GPL");
741 MODULE_ALIAS("spi:SC8800");