drivers/misc/mtk23d.c

   1 #include <linux/module.h>
   2 #include <linux/kernel.h>
   3 #include <linux/i2c.h>
   4 #include <linux/irq.h>
   5 #include <linux/gpio.h>
   6 #include <linux/input.h>
   7 #include <linux/platform_device.h>
   8 #include <linux/fs.h>
   9 #include <linux/uaccess.h>
  10 #include <linux/miscdevice.h>
  11 #include <linux/circ_buf.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/miscdevice.h>
  14 #include <mach/iomux.h>
  15 #include <mach/gpio.h>
  16 //#include <mach/spi_fpga.h>
  17 #include <linux/delay.h>
  18 #include <linux/poll.h>
  19 #include <linux/wait.h>
  20 //#include <linux/android_power.h>
  21 //#include <asm/arch/gpio_extend.h>
  22 #include <linux/workqueue.h>
  23 #include <linux/mtk23d.h>
  24 #include <linux/wakelock.h>
  25
  26 MODULE_LICENSE("GPL");
  27
  28 #define DEBUG
  29 #ifdef DEBUG
  30 #define MODEMDBG(x...) printk(x)
  31 #else
  32 #define MODEMDBG(fmt,argss...)
  33 #endif
  34
  35 #define MTK23D_RESET 0x01
  36 #define MTK23D_POWERON  0x02
  37 #define MTK23D_POWER_HIGH 0x03
  38 #define MTK23D_IMEI_READ  0x04
  39 //#define BP_POW_EN     TCA6424_P02
  40 //#define BP_STATUS    RK2818_PIN_PH7    //input  high bp sleep
  41 //#define AP_STATUS    RK2818_PIN_PA4    //output high ap sleep
  42
  43 //#define BP_RESET      TCA6424_P11     //Ryan
  44
  45 //#define AP_BP_WAKEUP  RK2818_PIN_PF5   //output AP wake up BP used rising edge
  46 //#define BP_AP_WAKEUP  RK2818_PIN_PE0  //input BP wake up AP
  47
  48 static bool wakelock_inited;
  49 static struct wake_lock mtk23d_wakelock;
  50
  51 #define SLEEP 1
  52 #define READY 0
  53
  54 //struct modem_dev *mt6223d_data = NULL;
  55 struct rk2818_23d_data *gpdata = NULL;
  56
  57 static int  get_bp_statue(struct platform_device *pdev)
  58 {
  59         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
  60
  61         if(gpio_get_value(pdata->bp_statue))
  62                 return SLEEP;
  63         else
  64                 return READY;
  65 }
  66 static void ap_sleep(struct platform_device *pdev)
  67 {
  68         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
  69
  70         MODEMDBG("ap sleep!\n");
  71         gpio_set_value(pdata->ap_statue,GPIO_HIGH);
  72 }
  73 static void ap_wakeup(struct platform_device *pdev)
  74 {
  75         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
  76
  77         MODEMDBG("ap wakeup!\n");
  78         gpio_set_value(pdata->ap_statue,GPIO_LOW);
  79 }
  80 /* */
  81 static void ap_wakeup_bp(struct platform_device *pdev, int wake)//low to wakeup bp
  82 {
  83         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
  84         struct modem_dev *mt6223d_data = platform_get_drvdata(pdev);
  85         MODEMDBG("ap_wakeup_bp\n");
  86
  87         gpio_set_value(pdata->ap_bp_wakeup, wake);  // phc
  88         //gpio_set_value(RK2818_PIN_PF5, wake);
  89 }
  90
  91 static void bpwakeup_work_func_work(struct work_struct *work)
  92 {
  93         struct modem_dev *bdata = container_of(work, struct modem_dev, work);
  94
  95         MODEMDBG("%s\n", __FUNCTION__);
  96
  97 }
  98 /*  */
  99 static irqreturn_t  bpwakeup_work_func(int irq, void *data)
 100 {
 101         struct modem_dev *mt6223d_data = (struct modem_dev *)data;
 102
 103         MODEMDBG("bpwakeup_work_func\n");
 104         schedule_work(&mt6223d_data->work);
 105         return IRQ_HANDLED;
 106 }
 107 static irqreturn_t  bp_apwakeup_work_func(int irq, void *data)
 108 {
 109         //struct modem_dev *dev = &mtk23d_misc;
 110
 111         MODEMDBG("bp_apwakeup_work_func\n");
 112         //wake_up_interruptible(&dev->wakeup);
 113         return IRQ_HANDLED;
 114 }
 115 int modem_poweron_off(int on_off)
 116 {
 117         struct rk2818_23d_data *pdata = gpdata;
 118
 119   if(on_off)
 120   {
 121                 printk("modem_poweron\n");
 122                 gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_LOW:GPIO_HIGH);
 123                 mdelay(300);
 124                 gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_HIGH:GPIO_LOW);
 125                 msleep(4000);
 126                 gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_HIGH:GPIO_LOW);
 127   }
 128   else
 129   {
 130                 printk("modem_poweroff\n");
 131                 gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_LOW:GPIO_HIGH);
 132                 mdelay(100);
 133                 gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_HIGH:GPIO_LOW);
 134   }
 135 }
 136 static int power_on =1;
 137 static int mtk23d_open(struct inode *inode, struct file *file)
 138 {
 139         struct rk2818_23d_data *pdata = gpdata;
 140         //struct rk2818_23d_data *pdata = gpdata = pdev->dev.platform_data;
 141         struct platform_data *pdev = container_of(pdata, struct device, platform_data);
 142
 143         MODEMDBG("modem_open\n");
 144
 145         int ret = 0;
 146         if(power_on)
 147         {
 148                 power_on = 0;
 149                 modem_poweron_off(1);
 150                 #if 1 // phc
 151                 rk29_mux_api_set(GPIO1B7_UART0SOUT_NAME, GPIO1L_UART0_SOUT);
 152                 rk29_mux_api_set(GPIO1B6_UART0SIN_NAME, GPIO1L_UART0_SIN);
 153                 rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_UART0_RTS_N);
 154                 rk29_mux_api_set(GPIO1C0_UART0CTSN_SDMMC1DETECTN_NAME, GPIO1H_UART0_CTS_N);
 155                 #endif
 156         }
 157         device_init_wakeup(&pdev, 1);
 158
 159         return 0;
 160 }
 161
 162 static int mtk23d_release(struct inode *inode, struct file *file)
 163 {
 164         MODEMDBG("mtk23d_release\n");
 165
 166         //gpio_free(pdata->bp_power);
 167         return 0;
 168 }
 169
 170 //extern char imei_value[16]; // phc, no find 'imei_value' in rk29 project
 171 char imei_value[16] = {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5};
 172
 173 static int mtk23d_ioctl(struct inode *inode,struct file *file, unsigned int cmd, unsigned long arg)
 174 {
 175         struct rk2818_23d_data *pdata = gpdata;
 176         int i;
 177         void __user *argp = (void __user *)arg;
 178         printk("mtk23d_ioctl\n");
 179         switch(cmd)
 180         {
 181                 case MTK23D_RESET:
 182                         gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_LOW:GPIO_HIGH);
 183                         mdelay(100);
 184                         gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_LOW:GPIO_HIGH);
 185                         mdelay(300);
 186                         gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_HIGH:GPIO_LOW);
 187                         msleep(4000);
 188                         gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_HIGH:GPIO_LOW);
 189                         break;
 190                 case MTK23D_IMEI_READ:
 191                         if(copy_to_user(argp, &(imei_value[0]), 16))
 192                         {
 193                                 printk("ERROR: copy_to_user---%s\n", __FUNCTION__);
 194                                 return -EFAULT;
 195                         }
 196                         break;
 197                 default:
 198                         break;
 199         }
 200         return 0;
 201 }
 202
 203 static struct file_operations mtk23d_fops = {
 204         .owner = THIS_MODULE,
 205         .open = mtk23d_open,
 206         .release = mtk23d_release,
 207         .ioctl = mtk23d_ioctl
 208 };
 209
 210 static struct miscdevice mtk23d_misc = {
 211         .minor = MISC_DYNAMIC_MINOR,
 212         .name = MODEM_NAME,
 213         .fops = &mtk23d_fops
 214 };
 215
 216 static int mtk23d_probe(struct platform_device *pdev)
 217 {
 218         struct rk2818_23d_data *pdata = gpdata = pdev->dev.platform_data;
 219         struct modem_dev *mt6223d_data = NULL;
 220         int result, irq = 0;
 221
 222         MODEMDBG("mtk23d_probe\n");
 223
 224 #if 1
 225         rk29_mux_api_set(GPIO1B7_UART0SOUT_NAME, GPIO1L_GPIO1B7);
 226         gpio_request(RK29_PIN1_PB7, NULL);
 227         gpio_direction_output(RK29_PIN1_PB7,GPIO_LOW);
 228         gpio_pull_updown(RK29_PIN1_PB7, PullDisable);  // ÏÂÀ½ûÖ¹
 229
 230         rk29_mux_api_set(GPIO1B6_UART0SIN_NAME, GPIO1L_GPIO1B6);
 231         gpio_request(RK29_PIN1_PB6, NULL);
 232         gpio_direction_output(RK29_PIN1_PB6,GPIO_LOW);
 233         gpio_pull_updown(RK29_PIN1_PB6, PullDisable);  // ÏÂÀ½ûÖ¹
 234
 235         rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_GPIO1C1);
 236         gpio_request(RK29_PIN1_PC1, NULL);
 237         gpio_direction_output(RK29_PIN1_PC1,GPIO_LOW);
 238
 239         rk29_mux_api_set(GPIO1C0_UART0CTSN_SDMMC1DETECTN_NAME, GPIO1H_GPIO1C0);
 240         gpio_request(RK29_PIN1_PC0, NULL);
 241         gpio_direction_input(RK29_PIN1_PC0);
 242 #endif
 243
 244         pdata->io_init();
 245
 246         mt6223d_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL);
 247         if(NULL == mt6223d_data)
 248         {
 249                 printk("failed to request mt6223d_data\n");
 250                 goto err6;
 251         }
 252         platform_set_drvdata(pdev, mt6223d_data);
 253
 254         result = gpio_request(pdata->bp_statue, "mtk23d");
 255         if (result) {
 256                 printk("failed to request BP_STATUS gpio\n");
 257                 goto err5;
 258         }
 259
 260         result = gpio_request(pdata->ap_statue, "mtk23d");
 261         if (result) {
 262                 printk("failed to request AP_STATUS gpio\n");
 263                 goto err4;
 264         }
 265
 266         result = gpio_request(pdata->ap_bp_wakeup, "mtk23d");
 267         if (result) {
 268                 printk("failed to request AP_BP_WAKEUP gpio\n");
 269                 goto err3;
 270         }
 271         result = gpio_request(pdata->bp_reset, "mtk23d");
 272         if (result) {
 273                 printk("failed to request BP_RESET gpio\n");
 274                 goto err2;
 275         }
 276         result = gpio_request(pdata->bp_power, "mtk23d");
 277         if (result) {
 278                 printk("failed to request BP_POW_EN gpio\n");
 279                 goto err1;
 280         }
 281
 282 #if 1 // phc
 283         gpio_set_value(pdata->bp_power, pdata->bp_power_active_low? GPIO_HIGH:GPIO_LOW);
 284         gpio_direction_output(pdata->ap_statue, GPIO_LOW);
 285         gpio_direction_output(pdata->ap_bp_wakeup, GPIO_LOW);
 286         mdelay(100);
 287         gpio_direction_output(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_LOW:GPIO_HIGH);
 288         mdelay(100);
 289         gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_HIGH:GPIO_LOW);
 290         gpio_set_value(pdata->ap_bp_wakeup, GPIO_HIGH);
 291
 292         gpio_direction_input(pdata->bp_statue);
 293 #endif
 294
 295 #if 0
 296         gpio_direction_input(pdata->bp_statue);
 297
 298         //rk2818_mux_api_set(CXGPIO_HSADC_SEL_NAME, 0);
 299         gpio_direction_output(pdata->ap_statue, GPIO_LOW);
 300
 301         //rk2818_mux_api_set(GPIOF5_APWM3_DPWM3_NAME,0);
 302         gpio_direction_output(pdata->ap_bp_wakeup, GPIO_LOW);
 303         mdelay(100);
 304         //rk2818_mux_api_set(GPIOE_SPI1_FLASH_SEL_NAME, IOMUXA_GPIO1_A3B7);
 305         gpio_direction_output(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_LOW:GPIO_HIGH);
 306         mdelay(100);
 307         gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_HIGH:GPIO_LOW);
 308         gpio_set_value(pdata->ap_bp_wakeup, GPIO_HIGH);
 309 #endif
 310
 311         INIT_WORK(&mt6223d_data->work, bpwakeup_work_func_work);
 312         power_on = 1;
 313         result = misc_register(&mtk23d_misc);
 314         if(result)
 315         {
 316                 MODEMDBG("misc_register err\n");
 317         }
 318         MODEMDBG("mtk23d_probe ok\n");
 319
 320         if (!wakelock_inited) {
 321                 wake_lock_init(&mtk23d_wakelock, WAKE_LOCK_SUSPEND, "23d_resume");
 322                 wakelock_inited = true;
 323         }
 324
 325         return result;
 326 err0:
 327         cancel_work_sync(&mt6223d_data->work);
 328         gpio_free(pdata->bp_ap_wakeup);
 329 err1:
 330         gpio_free(pdata->bp_power);
 331 err2:
 332         gpio_free(pdata->bp_reset);
 333 err3:
 334         gpio_free(pdata->ap_bp_wakeup);
 335 err4:
 336         gpio_free(pdata->ap_statue);
 337 err5:
 338         gpio_free(pdata->bp_statue);
 339 err6:
 340         kfree(mt6223d_data);
 341 ret:
 342         return result;
 343 }
 344
 345 static irqreturn_t BBwakeup_isr(int irq, void *dev_id)
 346 {
 347         struct rk2818_23d_data *pdata = dev_id;
 348
 349         MODEMDBG("%s \n", __FUNCTION__);
 350         //if(irq != gpio_to_irq(RK29_PIN1_PC0))
 351         //{
 352         //              printk("irq != gpio_to_irq(RK29_PIN1_PC0) \n");
 353         //              return IRQ_NONE;
 354         //}
 355
 356 //      disable_irq_wake(irq);
 357
 358         wake_lock_timeout(&mtk23d_wakelock, 2 * HZ);
 359
 360         return IRQ_HANDLED;
 361 }
 362
 363 int mtk23d_suspend(struct platform_device *pdev)
 364 {
 365         int irq, error;
 366         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
 367
 368         MODEMDBG("%s \n", __FUNCTION__);
 369         //enable_irq_wake(irq);
 370         ap_sleep(pdev);
 371         ap_wakeup_bp(pdev, 0);
 372
 373         irq = gpio_to_irq(pdata->bp_statue);
 374         if (irq < 0) {
 375                 printk("can't get pdata->bp_statue irq \n");
 376         }
 377         else
 378         {
 379                 error = request_irq(irq, BBwakeup_isr,
 380                                     IRQF_TRIGGER_FALLING,
 381                                     NULL,
 382                                     pdata);
 383                 if (error) {
 384                         printk("request_irq error!!! \n");
 385                 }
 386                 enable_irq_wake(irq);
 387         }
 388
 389         return 0;
 390 }
 391
 392 int mtk23d_resume(struct platform_device *pdev)
 393 {
 394         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
 395         int irq = 0;
 396
 397         MODEMDBG("%s \n", __FUNCTION__);
 398         //disable_irq_wake(irq);
 399         ap_wakeup(pdev);
 400         ap_wakeup_bp(pdev, 1);
 401
 402         irq = gpio_to_irq(pdata->bp_statue);
 403         if(irq)
 404         {
 405                 printk("disable pdata->bp_statue irq_wake!! \n");
 406                 disable_irq_wake(irq);
 407         }
 408
 409         return 0;
 410 }
 411
 412 void mtk23d_shutdown(struct platform_device *pdev, pm_message_t state)
 413 {
 414         struct rk2818_23d_data *pdata = pdev->dev.platform_data;
 415         struct modem_dev *mt6223d_data = platform_get_drvdata(pdev);
 416
 417         MODEMDBG("%s \n", __FUNCTION__);
 418
 419         modem_poweron_off(0);  // power down
 420
 421         cancel_work_sync(&mt6223d_data->work);
 422         gpio_free(pdata->bp_ap_wakeup);
 423         gpio_free(pdata->bp_power);
 424         gpio_free(pdata->bp_reset);
 425         gpio_free(pdata->ap_bp_wakeup);
 426         gpio_free(pdata->ap_statue);
 427         gpio_free(pdata->bp_statue);
 428         kfree(mt6223d_data);
 429 }
 430
 431 static struct platform_driver mtk23d_driver = {
 432         .probe  = mtk23d_probe,
 433         .shutdown       = mtk23d_shutdown,
 434         .suspend        = mtk23d_suspend,
 435         .resume         = mtk23d_resume,
 436         .driver = {
 437                 .name   = "mtk23d",
 438                 .owner  = THIS_MODULE,
 439         },
 440 };
 441
 442 static int __init mtk23d_init(void)
 443 {
 444         MODEMDBG("mtk23d_init ret=%d\n");
 445         return platform_driver_register(&mtk23d_driver);
 446 }
 447
 448 static void __exit mtk23d_exit(void)
 449 {
 450         MODEMDBG("mtk23d_exit\n");
 451         platform_driver_unregister(&mtk23d_driver);
 452 }
 453
 454 module_init(mtk23d_init);
 455 //late_initcall_sync(mtk23d_init);
 456 module_exit(mtk23d_exit);