From 401e7f1d2f6e9cb83c09a1b871e6d4ecc12f8abe Mon Sep 17 00:00:00 2001 From: xxh Date: Fri, 29 Mar 2013 18:26:44 +0800 Subject: [PATCH] 3G modem driver for 4.2.2 1.the driver is copy form 4.1 2.mu509,mt6229,mw100,sew868 3.other modem use rk29_modem_config --- arch/arm/mach-rk30/board-rk30-sdk.c | 159 +++++++++++- drivers/misc/3g_module/Kconfig | 30 +++ drivers/misc/3g_module/Makefile | 4 + drivers/misc/3g_module/mt6229.c | 359 ++++++++++++++++++++++++++ drivers/misc/3g_module/mu509.c | 377 ++++++++++++++++++++++++++++ drivers/misc/3g_module/mw100.c | 235 +++++++++++++++++ drivers/misc/3g_module/sew868.c | 228 +++++++++++++++++ drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + 9 files changed, 1393 insertions(+), 1 deletion(-) create mode 100755 drivers/misc/3g_module/Kconfig create mode 100755 drivers/misc/3g_module/Makefile create mode 100755 drivers/misc/3g_module/mt6229.c create mode 100755 drivers/misc/3g_module/mu509.c create mode 100755 drivers/misc/3g_module/mw100.c create mode 100755 drivers/misc/3g_module/sew868.c diff --git a/arch/arm/mach-rk30/board-rk30-sdk.c b/arch/arm/mach-rk30/board-rk30-sdk.c index 1dfc2560cde7..128175a06bb3 100755 --- a/arch/arm/mach-rk30/board-rk30-sdk.c +++ b/arch/arm/mach-rk30/board-rk30-sdk.c @@ -57,10 +57,18 @@ #if defined(CONFIG_SPIM_RK29) #include "../../../drivers/spi/rk29_spim.h" #endif - +#if defined(CONFIG_MU509) +#include +#endif +#if defined(CONFIG_MW100) +#include +#endif #if defined (CONFIG_BP_AUTO) #include #endif +#if defined(CONFIG_SEW868) +#include +#endif #if defined(CONFIG_ANDROID_TIMED_GPIO) #include "../../../drivers/staging/android/timed_gpio.h" #endif @@ -470,7 +478,144 @@ static struct platform_device rk30_device_modem = { } }; #endif +#if defined(CONFIG_MU509) +static int mu509_io_init(void) +{ + + rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6); + rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2); + rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME, GPIO2B_GPIO2B7); + rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME, GPIO2C_GPIO2C0); + return 0; +} + +static int mu509_io_deinit(void) +{ + + return 0; +} + +struct rk29_mu509_data rk29_mu509_info = { + .io_init = mu509_io_init, + .io_deinit = mu509_io_deinit, + .modem_power_en = RK30_PIN6_PB2,//RK30_PIN4_PD1, + .bp_power = RK30_PIN2_PB6,//RK30_PIN4_PD1, + .bp_reset = RK30_PIN4_PD2, + .ap_wakeup_bp = RK30_PIN2_PB7, + .bp_wakeup_ap = RK30_PIN6_PA0, +}; +struct platform_device rk29_device_mu509 = { + .name = "mu509", + .id = -1, + .dev = { + .platform_data = &rk29_mu509_info, + } + }; +#endif +#if defined(CONFIG_MW100) +static int mw100_io_init(void) +{ + rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6); + rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2); + rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME, GPIO2B_GPIO2B7); + rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME, GPIO2C_GPIO2C0); + return 0; +} + +static int mw100_io_deinit(void) +{ + + return 0; +} + +struct rk29_mw100_data rk29_mw100_info = { + .io_init = mw100_io_init, + .io_deinit = mw100_io_deinit, + .modem_power_en = RK30_PIN6_PB2, + .bp_power = RK30_PIN2_PB6, + .bp_reset = RK30_PIN4_PD2, + .ap_wakeup_bp = RK30_PIN2_PB7, + .bp_wakeup_ap = RK30_PIN6_PA0, +}; +struct platform_device rk29_device_mw100 = { + .name = "mw100", + .id = -1, + .dev = { + .platform_data = &rk29_mw100_info, + } + }; +#endif +#if defined(CONFIG_MT6229) +static int mt6229_io_init(void) +{ + rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6); + rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2); + rk30_mux_api_set(GPIO2B7_LCDC1DATA15_SMCADDR19_HSADCDATA7_NAME, GPIO2B_GPIO2B7); + rk30_mux_api_set(GPIO2C0_LCDCDATA16_GPSCLK_HSADCCLKOUT_NAME, GPIO2C_GPIO2C0); + rk30_mux_api_set(GPIO2C1_LCDC1DATA17_SMCBLSN0_HSADCDATA6_NAME, GPIO2C_GPIO2C1); + rk30_mux_api_set(GPIO2C1_LCDC1DATA17_SMCBLSN0_HSADCDATA6_NAME, GPIO2C_GPIO2C1); + return 0; + return 0; +} + +static int mt6229_io_deinit(void) +{ + + return 0; +} + +struct rk29_mt6229_data rk29_mt6229_info = { + .io_init = mt6229_io_init, + .io_deinit = mt6229_io_deinit, + .modem_power_en = RK30_PIN6_PB2, + .bp_power = RK30_PIN2_PB6, + .modem_usb_en = RK30_PIN2_PC0, + .modem_uart_en = RK30_PIN2_PC1, + .bp_wakeup_ap = RK30_PIN6_PA1, + .ap_ready = RK30_PIN2_PB7, + +}; +struct platform_device rk29_device_mt6229 = { + .name = "mt6229", + .id = -1, + .dev = { + .platform_data = &rk29_mt6229_info, + } + }; +#endif +#if defined(CONFIG_SEW868) +static int sew868_io_init(void) +{ + rk30_mux_api_set(GPIO2B6_LCDC1DATA14_SMCADDR18_TSSYNC_NAME, GPIO2B_GPIO2B6); + rk30_mux_api_set(GPIO4D2_SMCDATA10_TRACEDATA10_NAME, GPIO4D_GPIO4D2); + rk30_mux_api_set(GPIO4D4_SMCDATA12_TRACEDATA12_NAME, GPIO4D_GPIO4D4); + return 0; +} +static int sew868_io_deinit(void) +{ + return 0; +} +struct rk30_sew868_data rk30_sew868_info = { + .io_init = sew868_io_init, + .io_deinit = sew868_io_deinit, + .bp_power = RK30_PIN6_PB2, + .bp_power_active_low = 1, + .bp_sys = RK30_PIN2_PB6, + .bp_reset = RK30_PIN4_PD2, + .bp_reset_active_low = 1, + .bp_wakeup_ap = RK30_PIN4_PD4, + .ap_wakeup_bp = NULL, +}; + +struct platform_device rk30_device_sew868 = { + .name = "sew868", + .id = -1, + .dev = { + .platform_data = &rk30_sew868_info, + } + }; +#endif /*MMA8452 gsensor*/ #if defined (CONFIG_GS_MMA8452) @@ -1440,6 +1585,18 @@ static struct platform_device *devices[] __initdata = { #ifdef CONFIG_RK29_SUPPORT_MODEM &rk30_device_modem, #endif +#if defined(CONFIG_MU509) + &rk29_device_mu509, + #endif +#if defined(CONFIG_MW100) + &rk29_device_mw100, +#endif +#if defined(CONFIG_MT6229) +&rk29_device_mt6229, +#endif +#if defined(CONFIG_SEW868) +&rk30_device_sew868, +#endif #if defined (CONFIG_RK_HEADSET_DET) || defined (CONFIG_RK_HEADSET_IRQ_HOOK_ADC_DET) &rk_device_headset, #endif diff --git a/drivers/misc/3g_module/Kconfig b/drivers/misc/3g_module/Kconfig new file mode 100755 index 000000000000..058f7f31a9c7 --- /dev/null +++ b/drivers/misc/3g_module/Kconfig @@ -0,0 +1,30 @@ +# +# 3G device configuration +# + +menuconfig 3G_MODULE + tristate "3G module for mid" + ---help--- + Say Y here if you have a support modem + +choice + depends on 3G_MODULE + prompt "Select 3G Module" + + config MU509 + bool "MU509" + + config MT6229 + bool "MT6229" + + config MW100 + bool "MW100" + + config SEW868 + bool "SEW868" + + + + +endchoice + diff --git a/drivers/misc/3g_module/Makefile b/drivers/misc/3g_module/Makefile new file mode 100755 index 000000000000..f0a3bcc74cc3 --- /dev/null +++ b/drivers/misc/3g_module/Makefile @@ -0,0 +1,4 @@ +obj-$(CONFIG_MU509) += mu509.o +obj-$(CONFIG_MW100) += mw100.o +obj-$(CONFIG_MT6229) += mt6229.o +obj-$(CONFIG_SEW868) += sew868.o diff --git a/drivers/misc/3g_module/mt6229.c b/drivers/misc/3g_module/mt6229.c new file mode 100755 index 000000000000..37b848f22db0 --- /dev/null +++ b/drivers/misc/3g_module/mt6229.c @@ -0,0 +1,359 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_LICENSE("GPL"); + +#define DEBUG +#ifdef DEBUG +#define MODEMDBG(x...) printk(x) +#else +#define MODEMDBG(fmt,argss...) +#endif +#define SLEEP 1 +#define READY 0 +static struct wake_lock modem_wakelock; +//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_FALLING +#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING +#define MT6229_RESET 0x01 +struct rk29_mt6229_data *gpdata = NULL; +struct class *modem_class = NULL; +static int do_wakeup_irq = 0; +static int modem_status; +static void ap_wakeup_bp(struct platform_device *pdev, int wake) +{ + struct rk29_mt6229_data *pdata = pdev->dev.platform_data; + + gpio_set_value(pdata->modem_usb_en,wake); + if(wake == 1) + wake = 0; + else + wake = 1; + gpio_set_value(pdata->modem_uart_en,wake); + +} +extern void rk28_send_wakeup_key(void); + +static void do_wakeup(struct work_struct *work) +{ + gpio_set_value(gpdata->ap_ready,GPIO_HIGH); + gpio_set_value(gpdata->modem_usb_en,GPIO_HIGH); +} + +static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup); +static irqreturn_t detect_irq_handler(int irq, void *dev_id) +{ + if(do_wakeup_irq) + { + do_wakeup_irq = 0; + wake_lock_timeout(&modem_wakelock, 10 * HZ); + //schedule_delayed_work(&wakeup_work, 2*HZ); + } + return IRQ_HANDLED; +} +int modem_poweron_off(int on_off) +{ + struct rk29_mt6229_data *pdata = gpdata; + if(on_off) + { + gpio_set_value(pdata->bp_power, GPIO_LOW); + gpio_set_value(pdata->modem_usb_en, GPIO_HIGH); + gpio_set_value(pdata->modem_uart_en, GPIO_LOW); + gpio_set_value(pdata->ap_ready, GPIO_HIGH); + } + else + { + gpio_set_value(pdata->bp_power, GPIO_HIGH); + gpio_set_value(pdata->modem_usb_en, GPIO_LOW); + gpio_set_value(pdata->modem_uart_en, GPIO_HIGH); + gpio_set_value(pdata->ap_ready, GPIO_LOW); + } + return 0; +} +static int mt6229_open(struct inode *inode, struct file *file) +{ + struct rk29_mt6229_data *pdata = gpdata; + device_init_wakeup(pdata->dev, 1); + return 0; +} +static ssize_t mt6229_write(struct file *file, const char __user *buf,size_t len, loff_t *off) +{ + static char cmd[2]; + int ret = 0; + if (len > 2) + { + return -EINVAL; + } + ret = copy_from_user(&cmd, buf, len); + if (ret != 0) { + return -EFAULT; + } + printk(" received cmd = %c\n",cmd[0]); + if (cmd[0] == '0') + { + gpio_set_value(gpdata->ap_ready, GPIO_LOW); + } + if (cmd[0] == '1') + { + gpio_set_value(gpdata->ap_ready, GPIO_HIGH); + } + if (cmd[0] == '2') + { + gpio_set_value(gpdata->modem_uart_en, GPIO_LOW); + } + if (cmd[0] == '3') + { + gpio_set_value(gpdata->modem_uart_en, GPIO_HIGH); + } + if (cmd[0] == '4') + { + gpio_set_value(gpdata->modem_usb_en, GPIO_HIGH); + }if (cmd[0] == '5') + { + gpio_set_value(gpdata->modem_usb_en, GPIO_LOW); + } + return len; +} +static int mt6229_release(struct inode *inode, struct file *file) +{ + return 0; +} + +static long mt6229_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct rk29_mt6229_data *pdata = gpdata; + switch(cmd) + { + case MT6229_RESET: + modem_poweron_off(0); + msleep(10); + modem_poweron_off(1); + break; + default: + break; + } + return 0; +} + +static struct file_operations mt6229_fops = { + .owner = THIS_MODULE, + .open = mt6229_open, + .write = mt6229_write, + .release = mt6229_release, + .unlocked_ioctl = mt6229_ioctl +}; + +static struct miscdevice mt6229_misc = { + .minor = MISC_DYNAMIC_MINOR, + .name = MODEM_NAME, + .fops = &mt6229_fops +}; +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) +static ssize_t modem_status_read(struct class *cls, struct class_attribute *attr, char *_buf) +#else +static ssize_t modem_status_read(struct class *cls, char *_buf) +#endif +{ + + return sprintf(_buf, "%d\n", modem_status); + +} +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) +static ssize_t modem_status_write(struct class *cls, struct class_attribute *attr, const char *_buf, size_t _count) +#else +static ssize_t modem_status_write(struct class *cls, const char *_buf, size_t _count) +#endif +{ + int new_state = simple_strtoul(_buf, NULL, 16); + if(new_state == modem_status) return _count; + if (new_state == 1){ + printk("%s, c(%d), modem resume \n", __FUNCTION__, new_state); + gpio_set_value(gpdata->modem_usb_en, GPIO_HIGH); + gpio_set_value(gpdata->modem_uart_en,GPIO_LOW); + }else if(new_state == 0){ + printk("%s, c(%d), modem suspend \n", __FUNCTION__, new_state); + gpio_set_value(gpdata->modem_usb_en, GPIO_LOW); + gpio_set_value(gpdata->modem_uart_en,GPIO_HIGH); + }else{ + printk("%s, invalid parameter \n", __FUNCTION__); + } + modem_status = new_state; + return _count; +} +static CLASS_ATTR(modem_status, 0777, modem_status_read, modem_status_write); +static int mt6229_probe(struct platform_device *pdev) +{ + struct rk29_mt6229_data *pdata = gpdata = pdev->dev.platform_data; + struct modem_dev *mt6229_data = NULL; + int result, irq = 0; + pdata->dev = &pdev->dev; + if(pdata->io_init) + pdata->io_init(); + mt6229_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL); + if(mt6229_data == NULL) + { + printk("failed to request mt6229_data\n"); + goto err0; + } + platform_set_drvdata(pdev, mt6229_data); + result = gpio_request(pdata->modem_power_en,"modem_power_en"); + if(result){ + printk("failed to request modem_power_en gpio\n"); + goto err1; + } + gpio_set_value(pdata->modem_power_en, GPIO_HIGH); + msleep(1000); + result = gpio_request(pdata->bp_power,"modem_power"); + if(result){ + printk("failed to request modem_power gpio\n"); + goto err2; + } + result = gpio_request(pdata->modem_usb_en, "modem_usb_en"); + if (result) { + printk("failed to request modem_usb_en gpio\n"); + goto err3; + } + result = gpio_request(pdata->modem_uart_en,"modem_uart_en"); + if(result){ + printk("failed to request modem_uart_en gpio\n"); + goto err4; + } + result = gpio_request(pdata->bp_wakeup_ap, "bp_wakeup_ap"); + if (result) { + printk("failed to request bp_wakeup_ap gpio\n"); + goto err5; + } + gpio_direction_input(pdata->bp_wakeup_ap); + irq = gpio_to_irq(pdata->bp_wakeup_ap); + if(irq < 0) + { + gpio_free(pdata->bp_wakeup_ap); + printk("failed to request bp_wakeup_ap\n"); + } + result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL); + if (result < 0) { + printk("%s: request_irq(%d) failed\n", __func__, irq); + gpio_free(pdata->bp_wakeup_ap); + goto err5; + } + enable_irq_wake(irq); + wake_lock_init(&modem_wakelock, WAKE_LOCK_SUSPEND, "bp_wakeup_ap"); + result = gpio_request(pdata->ap_ready, "ap_ready"); + if (result < 0) { + printk("failed to request ap_ready gpio\n"); + goto err6; + } + + modem_poweron_off(1); + modem_status = 1; + + result = misc_register(&mt6229_misc); + if(result) + { + printk("misc_register err\n"); + } + return result; +err0: + kfree(mt6229_data); +err1: + gpio_free(pdata->modem_power_en); +err2: + gpio_free(pdata->bp_power); +err3: + gpio_free(pdata->modem_usb_en); +err4: + gpio_free(pdata->modem_uart_en); +err5: + gpio_free(pdata->bp_wakeup_ap); +err6: + gpio_free(pdata->ap_ready); + return 0; +} + +int mt6229_suspend(struct platform_device *pdev, pm_message_t state) +{ + do_wakeup_irq = 1; + ap_wakeup_bp(pdev, 0); + gpio_set_value(gpdata->ap_ready,0); + return 0; +} + +int mt6229_resume(struct platform_device *pdev) +{ + gpio_set_value(gpdata->modem_uart_en,GPIO_LOW); + schedule_delayed_work(&wakeup_work, 2*HZ); + return 0; +} + +void mt6229_shutdown(struct platform_device *pdev) +{ + struct rk29_mt6229_data *pdata = pdev->dev.platform_data; + struct modem_dev *mt6229_data = platform_get_drvdata(pdev); + + modem_poweron_off(0); + gpio_set_value(pdata->modem_power_en, GPIO_LOW); + + if(pdata->io_deinit) + pdata->io_deinit(); + cancel_work_sync(&mt6229_data->work); + gpio_free(pdata->modem_power_en); + gpio_free(pdata->bp_power); + gpio_free(pdata->modem_usb_en); + gpio_free(pdata->modem_uart_en); + gpio_free(pdata->bp_wakeup_ap); + kfree(mt6229_data); +} + +static struct platform_driver mt6229_driver = { + .probe = mt6229_probe, + .shutdown = mt6229_shutdown, + .suspend = mt6229_suspend, + .resume = mt6229_resume, + .driver = { + .name = "mt6229", + .owner = THIS_MODULE, + }, +}; + +static int __init mt6229_init(void) +{ + int ret ; + modem_class = class_create(THIS_MODULE, "rk291x_modem"); + ret = class_create_file(modem_class, &class_attr_modem_status); + if (ret) + { + printk("Fail to class rk291x_modem.\n"); + } + return platform_driver_register(&mt6229_driver); +} + +static void __exit mt6229_exit(void) +{ + platform_driver_unregister(&mt6229_driver); + class_remove_file(modem_class, &class_attr_modem_status); +} + +module_init(mt6229_init); + +module_exit(mt6229_exit); diff --git a/drivers/misc/3g_module/mu509.c b/drivers/misc/3g_module/mu509.c new file mode 100755 index 000000000000..29d341a401e0 --- /dev/null +++ b/drivers/misc/3g_module/mu509.c @@ -0,0 +1,377 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_LICENSE("GPL"); + +#define DEBUG +#ifdef DEBUG +#define MODEMDBG(x...) printk(x) +#else +#define MODEMDBG(fmt,argss...) +#endif +#define SLEEP 1 +#define READY 0 +static struct wake_lock modem_wakelock; +#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_FALLING +//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING +#define MU509_RESET 0x01 +struct rk29_mu509_data *gpdata = NULL; +struct class *modem_class = NULL; +static int do_wakeup_irq = 0; +static int modem_status; +int suspend_int =0; +static void ap_wakeup_bp(struct platform_device *pdev, int wake) +{ + struct rk29_mu509_data *pdata = pdev->dev.platform_data; + + gpio_set_value(pdata->ap_wakeup_bp, wake); + +} +extern void rk28_send_wakeup_key(void); + +static void do_wakeup(struct work_struct *work) +{ + if(suspend_int) + { + gpio_set_value(gpdata->ap_wakeup_bp, 0); + suspend_int = 0; + } + +} + +static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup); +static irqreturn_t detect_irq_handler(int irq, void *dev_id) +{ + if(do_wakeup_irq) + { + do_wakeup_irq = 0; + // MODEMDBG("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__); + wake_lock_timeout(&modem_wakelock, 10 * HZ); + schedule_delayed_work(&wakeup_work, 2*HZ); + } + return IRQ_HANDLED; +} +int modem_poweron_off(int on_off) +{ + struct rk29_mu509_data *pdata = gpdata; + if(on_off) + { + gpio_set_value(pdata->bp_reset, GPIO_HIGH); + msleep(100); + gpio_set_value(pdata->bp_reset, GPIO_LOW); + gpio_set_value(pdata->bp_power, GPIO_LOW); + msleep(1000); + gpio_set_value(pdata->bp_power, GPIO_HIGH); + msleep(700); + gpio_set_value(pdata->bp_power, GPIO_LOW); + gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW); + } + else + { + gpio_set_value(pdata->bp_power, GPIO_LOW); + gpio_set_value(pdata->bp_power, GPIO_HIGH); + msleep(2500); + gpio_set_value(pdata->bp_power, GPIO_LOW); + } + return 0; +} +static int mu509_open(struct inode *inode, struct file *file) +{ + struct rk29_mu509_data *pdata = gpdata; + device_init_wakeup(pdata->dev, 1); + return 0; +} + +static int mu509_release(struct inode *inode, struct file *file) +{ + return 0; +} + +static long mu509_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct rk29_mu509_data *pdata = gpdata; + switch(cmd) + { + case MU509_RESET: + gpio_set_value(pdata->bp_reset, GPIO_HIGH); + msleep(100); + gpio_set_value(pdata->bp_reset, GPIO_LOW); + msleep(100); + gpio_set_value(pdata->bp_power, GPIO_LOW); + msleep(1000); + gpio_set_value(pdata->bp_power, GPIO_HIGH); + msleep(700); + gpio_set_value(pdata->bp_power, GPIO_LOW); + gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW); + break; + default: + break; + } + return 0; +} + +static struct file_operations mu509_fops = { + .owner = THIS_MODULE, + .open = mu509_open, + .release = mu509_release, + .unlocked_ioctl = mu509_ioctl +}; + +static struct miscdevice mu509_misc = { + .minor = MISC_DYNAMIC_MINOR, + .name = MODEM_NAME, + .fops = &mu509_fops +}; +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) +static ssize_t modem_status_read(struct class *cls, struct class_attribute *attr, char *_buf) +#else +static ssize_t modem_status_read(struct class *cls, char *_buf) +#endif +{ + + return sprintf(_buf, "%d\n", modem_status); + +} +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)) +static ssize_t modem_status_write(struct class *cls, struct class_attribute *attr, const char *_buf, size_t _count) +#else +static ssize_t modem_status_write(struct class *cls, const char *_buf, size_t _count) +#endif +{ + int new_state = simple_strtoul(_buf, NULL, 16); + if(new_state == modem_status) return _count; + if (new_state == 1){ + printk("%s, c(%d), open modem \n", __FUNCTION__, new_state); + modem_poweron_off(1); + }else if(new_state == 0){ + printk("%s, c(%d), close modem \n", __FUNCTION__, new_state); + modem_poweron_off(0); + }else{ + printk("%s, invalid parameter \n", __FUNCTION__); + } + modem_status = new_state; + return _count; +} +static CLASS_ATTR(modem_status, 0777, modem_status_read, modem_status_write); +static void rk29_early_suspend(struct early_suspend *h) +{ + +} +static void rk29_early_resume(struct early_suspend *h) +{ + if(suspend_int) + { + gpio_set_value(gpdata->ap_wakeup_bp, 0); + suspend_int = 0; + } +} + +static struct early_suspend mu509_early_suspend = { + .suspend = rk29_early_suspend, + .resume = rk29_early_resume, + .level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1, + }; +static int mu509_probe(struct platform_device *pdev) +{ + struct rk29_mu509_data *pdata = gpdata = pdev->dev.platform_data; + struct modem_dev *mu509_data = NULL; + int result, irq = 0; + + pdata->dev = &pdev->dev; + if(pdata->io_init) + pdata->io_init(); + + printk("******** mu509_probe_mu509_probe usb autosuspend *********\n"); + // xxh begin + #if 1 + rk30_mux_api_set(GPIO1A1_UART0SOUT_NAME, GPIO1A_GPIO1A4); + result = gpio_request(RK30_PIN1_PA4, "uart1_sout"); + if (result < 0) { + + printk("%s: gpio_request( uart1_sout ) failed\n", __func__); + + } + else { + printk("******* uart0_sout low ( %s ) 88 ********\n", __FUNCTION__); + gpio_set_value(RK30_PIN1_PA4, GPIO_LOW); // Make sure the uart1_rx of MU509 is low for usb autosuspend + + } + + #endif +// xxh end + + mu509_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL); + if(mu509_data == NULL) + { + printk("failed to request mu509_data\n"); + goto err0; + } + platform_set_drvdata(pdev, mu509_data); + result = gpio_request(pdata->modem_power_en,"modem_power_en"); + if(result){ + printk("failed to request modem_power_en gpio\n"); + goto err1; + } + gpio_set_value(pdata->modem_power_en, GPIO_HIGH); + result = gpio_request(pdata->bp_power,"modem_power"); + if(result){ + printk("failed to request modem_power gpio\n"); + goto err2; + } + + + register_early_suspend(&mu509_early_suspend); + + result = gpio_request(pdata->ap_wakeup_bp, "mu509"); + if (result) { + printk("failed to request AP_BP_WAKEUP gpio\n"); + goto err3; + } + irq = gpio_to_irq(pdata->bp_wakeup_ap); + enable_irq_wake(irq); + if(irq < 0) + { + gpio_free(pdata->bp_wakeup_ap); + printk("failed to request bp_wakeup_ap\n"); + } + result = gpio_request(pdata->bp_wakeup_ap, "bp_wakeup_ap"); + if (result < 0) { + printk("%s: gpio_request(%d) failed\n", __func__, pdata->bp_wakeup_ap); + } + wake_lock_init(&modem_wakelock, WAKE_LOCK_SUSPEND, "bp_wakeup_ap"); + gpio_direction_input(pdata->bp_wakeup_ap); + gpio_pull_updown(pdata->bp_wakeup_ap, 1); + result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL); + if (result < 0) { + printk("%s: request_irq(%d) failed\n", __func__, irq); + gpio_free(pdata->bp_wakeup_ap); + goto err4; + } + enable_irq_wake(gpio_to_irq(pdata->bp_wakeup_ap)); + + msleep(1000); + modem_poweron_off(1); + modem_status = 1; + + result = misc_register(&mu509_misc); + if(result) + { + printk("misc_register err\n"); + } + return result; +err0: + kfree(mu509_data); +err1: + gpio_free(pdata->modem_power_en); +err2: + gpio_free(pdata->bp_power); +err3: + gpio_free(pdata->ap_wakeup_bp); +err4: + cancel_work_sync(&mu509_data->work); + gpio_free(pdata->bp_wakeup_ap); + return 0; +} + +int mu509_suspend(struct platform_device *pdev, pm_message_t state) +{ + suspend_int = 1; + do_wakeup_irq = 1; + ap_wakeup_bp(pdev, 1); +#if defined(CONFIG_ARCH_RK29) + rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_GPIO1C1); +#endif +#if defined(CONFIG_ARCH_RK30) + rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0TXD_NAME, GPIO1A_GPIO1A7); +#endif + return 0; +} + +int mu509_resume(struct platform_device *pdev) +{ +#if defined(CONFIG_ARCH_RK29) + rk29_mux_api_set(GPIO1C1_UART0RTSN_SDMMC1WRITEPRT_NAME, GPIO1H_UART0_RTS_N); +#endif +#if defined(CONFIG_ARCH_RK30) + rk30_mux_api_set(GPIO1A7_UART1RTSN_SPI0TXD_NAME, GPIO1A_UART1_RTS_N); +#endif + if(gpio_get_value(gpdata->bp_wakeup_ap)) + { + schedule_delayed_work(&wakeup_work, 2*HZ); + } + return 0; +} + +void mu509_shutdown(struct platform_device *pdev) +{ + struct rk29_mu509_data *pdata = pdev->dev.platform_data; + struct modem_dev *mu509_data = platform_get_drvdata(pdev); + + modem_poweron_off(0); + gpio_set_value(pdata->modem_power_en, GPIO_LOW); + + if(pdata->io_deinit) + pdata->io_deinit(); + cancel_work_sync(&mu509_data->work); + gpio_free(pdata->modem_power_en); + gpio_free(pdata->bp_power); + gpio_free(pdata->bp_reset); + gpio_free(pdata->ap_wakeup_bp); + gpio_free(pdata->bp_wakeup_ap); + kfree(mu509_data); +} + +static struct platform_driver mu509_driver = { + .probe = mu509_probe, + .shutdown = mu509_shutdown, + .suspend = mu509_suspend, + .resume = mu509_resume, + .driver = { + .name = "mu509", + .owner = THIS_MODULE, + }, +}; + +static int __init mu509_init(void) +{ + int ret ; + modem_class = class_create(THIS_MODULE, "rk291x_modem"); + ret = class_create_file(modem_class, &class_attr_modem_status); + if (ret) + { + printk("Fail to class rk291x_modem.\n"); + } + return platform_driver_register(&mu509_driver); +} + +static void __exit mu509_exit(void) +{ + platform_driver_unregister(&mu509_driver); + class_remove_file(modem_class, &class_attr_modem_status); +} + +module_init(mu509_init); + +module_exit(mu509_exit); diff --git a/drivers/misc/3g_module/mw100.c b/drivers/misc/3g_module/mw100.c new file mode 100755 index 000000000000..ca75f039c24d --- /dev/null +++ b/drivers/misc/3g_module/mw100.c @@ -0,0 +1,235 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +MODULE_LICENSE("GPL"); + +#ifdef DEBUG +#define MODEMDBG(x...) printk(x) +#else +#define MODEMDBG(fmt,argss...) +#endif + +#define MW100IO 0XA1 +#define MW_IOCTL_RESET _IO(MW100IO,0X01) + +#define SLEEP 1 +#define READY 0 +#define MW100_RESET 0x01 +#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING +//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING +struct rk29_mw100_data *gpdata = NULL; +static int bp_wakeup_ap_irq = 0; + +static struct wake_lock bp_wakelock; +static bool bpstatus_irq_enable = false; + +static void do_wakeup(struct work_struct *work) +{ + enable_irq(bp_wakeup_ap_irq); +} + +static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup); +static irqreturn_t detect_irq_handler(int irq, void *dev_id) +{ + wake_lock_timeout(&bp_wakelock, 10 * HZ); + + return IRQ_HANDLED; +} + +static int mw100_open(struct inode *inode, struct file *file) +{ + return 0; +} + +static int mw100_release(struct inode *inode, struct file *file) +{ + return 0; +} + +static long mw100_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct rk29_mw100_data *pdata = gpdata; + switch(cmd) + { + case MW_IOCTL_RESET: + gpio_direction_output(pdata->bp_reset,GPIO_LOW); + mdelay(120); + gpio_set_value(pdata->bp_reset, GPIO_HIGH); + + break; + default: + break; + } + return 0; +} + +static struct file_operations mw100_fops = { + .owner = THIS_MODULE, + .open = mw100_open, + .release = mw100_release, + .unlocked_ioctl = mw100_ioctl +}; + +static struct miscdevice mw100_misc = { + .minor = MISC_DYNAMIC_MINOR, + .name = "mw100", + .fops = &mw100_fops +}; + +static int mw100_probe(struct platform_device *pdev) +{ + struct rk29_mw100_data *pdata = gpdata = pdev->dev.platform_data; + struct modem_dev *mw100_data = NULL; + int result, irq = 0; + + gpio_request(pdata->bp_power,"bp_power"); + gpio_request(pdata->bp_reset,"bp_reset"); + gpio_request(pdata->bp_wakeup_ap,"bp_wakeup_ap"); + gpio_request(pdata->ap_wakeup_bp,"ap_wakeup_bp"); + gpio_set_value(pdata->modem_power_en, GPIO_HIGH); + msleep(1000); + gpio_direction_output(pdata->bp_reset,GPIO_LOW); + mdelay(120); + gpio_set_value(pdata->bp_reset, GPIO_HIGH); + + gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH); + gpio_direction_output(pdata->ap_wakeup_bp,GPIO_HIGH); + + gpio_set_value(pdata->bp_power, GPIO_HIGH); + gpio_direction_output(pdata->bp_power,GPIO_HIGH); + mdelay(120); + gpio_set_value(pdata->bp_power, GPIO_LOW); + gpio_direction_output(pdata->bp_power,GPIO_LOW); + + mw100_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL); + if(mw100_data == NULL){ + printk("failed to request mw100_data\n"); + goto err2; + } + platform_set_drvdata(pdev, mw100_data); + + gpio_direction_input(pdata->bp_wakeup_ap); + irq = gpio_to_irq(pdata->bp_wakeup_ap); + if(irq < 0){ + gpio_free(pdata->bp_wakeup_ap); + printk("failed to request bp_wakeup_ap\n"); + } + + bp_wakeup_ap_irq = irq; + + result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL); + if (result < 0) { + printk("%s: request_irq(%d) failed\n", __func__, irq); + gpio_free(pdata->bp_wakeup_ap); + goto err0; + } + + enable_irq_wake(bp_wakeup_ap_irq); + + wake_lock_init(&bp_wakelock, WAKE_LOCK_SUSPEND, "bp_resume"); + + result = misc_register(&mw100_misc); + if(result){ + MODEMDBG("misc_register err\n"); + } + return result; +err0: + gpio_free(pdata->bp_wakeup_ap); +err2: + kfree(mw100_data); + return 0; +} + +int mw100_suspend(struct platform_device *pdev, pm_message_t state) +{ + + struct rk29_mw100_data *pdata = pdev->dev.platform_data; + int irq; + gpio_set_value(pdata->ap_wakeup_bp, GPIO_LOW); + irq = gpio_to_irq(pdata->bp_wakeup_ap); + if (irq < 0) { + printk("can't get pdata->bp_statue irq \n"); + } + else + { + bpstatus_irq_enable = true; + enable_irq_wake(irq); + } + return 0; +} + +int mw100_resume(struct platform_device *pdev) +{ + struct rk29_mw100_data *pdata = pdev->dev.platform_data; + int irq; + gpio_set_value(pdata->ap_wakeup_bp, GPIO_HIGH); + irq = gpio_to_irq(pdata->bp_wakeup_ap); + if (irq ) { + disable_irq_wake(irq); + bpstatus_irq_enable = false; + } + return 0; +} + +void mw100_shutdown(struct platform_device *pdev) +{ + struct rk29_mw100_data *pdata = pdev->dev.platform_data; + struct modem_dev *mw100_data = platform_get_drvdata(pdev); + + gpio_set_value(pdata->bp_power, GPIO_HIGH); + mdelay(2010); + gpio_free(pdata->modem_power_en); + gpio_free(pdata->bp_power); + gpio_free(pdata->bp_reset); + gpio_free(pdata->ap_wakeup_bp); + gpio_free(pdata->bp_wakeup_ap); + kfree(mw100_data); +} + +static struct platform_driver mw100_driver = { + .probe = mw100_probe, + .shutdown = mw100_shutdown, + .suspend = mw100_suspend, + .resume = mw100_resume, + .driver = { + .name = "mw100", + .owner = THIS_MODULE, + }, +}; + +static int __init mw100_init(void) +{ + return platform_driver_register(&mw100_driver); +} + +static void __exit mw100_exit(void) +{ + platform_driver_unregister(&mw100_driver); +} + +module_init(mw100_init); + +module_exit(mw100_exit); diff --git a/drivers/misc/3g_module/sew868.c b/drivers/misc/3g_module/sew868.c new file mode 100755 index 000000000000..ae786be7e6d7 --- /dev/null +++ b/drivers/misc/3g_module/sew868.c @@ -0,0 +1,228 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_LICENSE("GPL"); + +#define DEBUG +#ifdef DEBUG +#define MODEMDBG(x...) printk(x) +#else +#define MODEMDBG(fmt,argss...) +#endif +#define SLEEP 1 +#define READY 0 +#define SEW868_RESET 0x01 +#define SEW868_POWON 0x02 +#define SEW868_POWOFF 0x03 +static struct wake_lock modem_wakelock; +#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_FALLING +//#define IRQ_BB_WAKEUP_AP_TRIGGER IRQF_TRIGGER_RISING +struct rk30_sew868_data *gpdata = NULL; +static int do_wakeup_irq = 0; + +extern void rk28_send_wakeup_key(void); + +static void do_wakeup(struct work_struct *work) +{ + rk28_send_wakeup_key(); +} + +static DECLARE_DELAYED_WORK(wakeup_work, do_wakeup); +static irqreturn_t detect_irq_handler(int irq, void *dev_id) +{ + printk("%s\n", __FUNCTION__); + if(do_wakeup_irq) + { + do_wakeup_irq = 0; + wake_lock_timeout(&modem_wakelock, 10 * HZ); + schedule_delayed_work(&wakeup_work, HZ / 10); + } + return IRQ_HANDLED; +} +int modem_poweron_off(int on_off) +{ + struct rk30_sew868_data *pdata = gpdata; + if(on_off) + { + gpio_direction_output(pdata->bp_sys, GPIO_HIGH); + gpio_set_value(pdata->bp_power, GPIO_LOW); + msleep(200);//for charge + gpio_set_value(pdata->bp_power, GPIO_HIGH); + msleep(4000); + gpio_set_value(pdata->bp_power, GPIO_LOW); + msleep(200); + } + else + { + gpio_set_value(pdata->bp_power, GPIO_HIGH); + msleep(4000); + gpio_set_value(pdata->bp_power, GPIO_LOW); + gpio_set_value(pdata->bp_sys, GPIO_LOW); + msleep(50); + gpio_set_value(pdata->bp_power, GPIO_LOW); + } + return 0; +} +static int sew868_open(struct inode *inode, struct file *file) +{ + return 0; +} + +static int sew868_release(struct inode *inode, struct file *file) +{ + return 0; +} + +static long sew868_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + struct rk30_sew868_data *pdata = gpdata; + switch(cmd) + { + case SEW868_RESET: + gpio_set_value(pdata->bp_reset, GPIO_HIGH); + mdelay(100); + gpio_set_value(pdata->bp_reset, GPIO_LOW); + mdelay(200); + modem_poweron_off(1); + break; + case SEW868_POWON: + modem_poweron_off(1); + break; + case SEW868_POWOFF: + modem_poweron_off(0); + break; + default: + break; + } + return 0; +} + +static struct file_operations sew868_fops = { + .owner = THIS_MODULE, + .open = sew868_open, + .release = sew868_release, + .unlocked_ioctl = sew868_ioctl +}; + +static struct miscdevice sew868_misc = { + .minor = MISC_DYNAMIC_MINOR, + .name = MODEM_NAME, + .fops = &sew868_fops +}; + +static int sew868_probe(struct platform_device *pdev) +{ + struct rk30_sew868_data *pdata = gpdata = pdev->dev.platform_data; + struct modem_dev *sew868_data = NULL; + int result, irq = 0; + + if(pdata->io_init) + pdata->io_init(); + + modem_poweron_off(1); + sew868_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL); + if(sew868_data == NULL) + { + printk("failed to request sew868_data\n"); + goto err1; + } + platform_set_drvdata(pdev, sew868_data); + + irq = gpio_to_irq(pdata->bp_wakeup_ap); + if(irq < 0) + { + gpio_free(pdata->bp_wakeup_ap); + printk("failed to request bp_wakeup_ap\n"); + } + + wake_lock_init(&modem_wakelock, WAKE_LOCK_SUSPEND, "bp_wakeup_ap"); + gpio_direction_input(pdata->bp_wakeup_ap); + gpio_pull_updown(pdata->bp_wakeup_ap, GPIONormal); + result = request_irq(irq, detect_irq_handler, IRQ_BB_WAKEUP_AP_TRIGGER, "bp_wakeup_ap", NULL); + if (result < 0) { + printk("%s: request_irq(%d) failed\n", __func__, irq); + gpio_free(pdata->bp_wakeup_ap); + goto err0; + } + enable_irq_wake(gpio_to_irq(pdata->bp_wakeup_ap)); + result = misc_register(&sew868_misc); + if(result) + { + MODEMDBG("misc_register err\n"); + } + + return result; +err0: + cancel_work_sync(&sew868_data->work); +err1: + kfree(sew868_data); + return 0; +} + +int sew868_suspend(struct platform_device *pdev, pm_message_t state) +{ + do_wakeup_irq = 1; + return 0; +} + +int sew868_resume(struct platform_device *pdev) +{ + return 0; +} + +void sew868_shutdown(struct platform_device *pdev) +{ + struct rk30_sew868_data *pdata = pdev->dev.platform_data; + struct modem_dev *sew868_data = platform_get_drvdata(pdev); + modem_poweron_off(0); + if(pdata->io_deinit) + pdata->io_deinit(); + cancel_work_sync(&sew868_data->work); + kfree(sew868_data); +} + +static struct platform_driver sew868_driver = { + .probe = sew868_probe, + .shutdown = sew868_shutdown, + .suspend = sew868_suspend, + .resume = sew868_resume, + .driver = { + .name = "sew868", + .owner = THIS_MODULE, + }, +}; + +static int __init sew868_init(void) +{ + return platform_driver_register(&sew868_driver); +} + +static void __exit sew868_exit(void) +{ + platform_driver_unregister(&sew868_driver); +} + +module_init(sew868_init); + +module_exit(sew868_exit); diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig index dcadfb3cffc9..683616d3abfb 100755 --- a/drivers/misc/Kconfig +++ b/drivers/misc/Kconfig @@ -566,5 +566,6 @@ source "drivers/misc/lis3lv02d/Kconfig" source "drivers/misc/carma/Kconfig" source "drivers/misc/bp/Kconfig" source "drivers/misc/rk2928_callpad_misc/Kconfig" +source "drivers/misc/3g_module/Kconfig" endif # MISC_DEVICES diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index 9119f6910d65..22cca16c75f8 100755 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -54,6 +54,7 @@ obj-$(CONFIG_SENSORS_AK8963) += akm8963.o obj-$(CONFIG_MTK23D) += mtk23d.o obj-$(CONFIG_FM580X) += fm580x.o obj-$(CONFIG_RK29_SUPPORT_MODEM) += rk29_modem/ +obj-$(CONFIG_3G_MODULE) += 3g_module/ obj-$(CONFIG_BP_AUTO) += bp/ obj-$(CONFIG_GPS_DEVICES) += gps/ obj-y += inv_mpu/ -- 2.34.1