int modem_poweron_off(int on_off)
{
struct rk29_mi700_data *pdata = gpdata;
mutex_lock(&pdata->bp_mutex);
if(on_off)
{
MODEMDBG("------------modem_poweron\n");
gpio_set_value(pdata->bp_reset, GPIO_LOW);
msleep(100);
gpio_set_value(pdata->bp_reset, GPIO_HIGH);
gpio_set_value(pdata->bp_power, GPIO_HIGH);
msleep(1000);
gpio_set_value(pdata->bp_power, GPIO_LOW);
msleep(700);
gpio_set_value(pdata->bp_power, GPIO_HIGH);
}
else
{
MODEMDBG("------------modem_poweroff\n");
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);
}
mutex_unlock(&pdata->bp_mutex);
return 0;
}
int modem_poweron_off(int on_off)
{
struct rk29_mu509_data *pdata = gpdata;
if(on_off)
{
MODEMDBG("------------modem_poweron\n");
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);
gpio_set_value(airplane_mode, GPIO_HIGH);
}
else
{
MODEMDBG("------------modem_poweroff\n");
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 mtk23d_release(struct inode *inode, struct file *file)
{
MODEMDBG("mtk23d_release\n");
//gpio_free(pdata->bp_power);
return 0;
}
static void ap_wakeup(struct platform_device *pdev)
{
struct rk2818_23d_data *pdata = pdev->dev.platform_data;
MODEMDBG("ap wakeup!\n");
gpio_set_value(pdata->ap_statue,GPIO_LOW);
}
static void bpwakeup_work_func_work(struct work_struct *work)
{
//struct modem_dev *bdata = container_of(work, struct modem_dev, work);
MODEMDBG("%s\n", __FUNCTION__);
}
static void ap_wakeup_bp(struct platform_device *pdev, int wake)
{
struct rk29_mi700_data *pdata = pdev->dev.platform_data;
MODEMDBG("ap_wakeup_bp\n");
gpio_set_value(pdata->ap_wakeup_bp, wake);
}
static void ap_wakeup_bp(struct platform_device *pdev, int wake)//low to wakeup bp
{
struct rk2818_23d_data *pdata = pdev->dev.platform_data;
//struct modem_dev *mt6223d_data = platform_get_drvdata(pdev);
MODEMDBG("ap_wakeup_bp\n");
gpio_set_value(pdata->ap_bp_wakeup, wake); // phc
//gpio_set_value(RK2818_PIN_PF5, wake);
}
static int mtk23d_open(struct inode *inode, struct file *file)
{
struct rk2818_23d_data *pdata = gpdata;
MODEMDBG("modem_open\n");
if(power_on)
{
power_on = 0;
modem_poweron_off(1);
}
device_init_wakeup(pdata->dev, 1);
return 0;
}
static irqreturn_t BBwakeup_isr(int irq, void *dev_id)
{
//struct rk2818_23d_data *pdata = dev_id;
MODEMDBG("%s \n", __FUNCTION__);
//if(irq != gpio_to_irq(RK29_PIN1_PC0))
//{
// printk("irq != gpio_to_irq(RK29_PIN1_PC0) \n");
// return IRQ_NONE;
//}
// disable_irq_wake(irq);
if(bpstatus_irq_enable == true)
{
MODEMDBG("mtk23d_wakelock 3s \n");
wake_lock_timeout(&mtk23d_wakelock, 3 * HZ);
}
return IRQ_HANDLED;
}
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;
}
void mtk23d_shutdown(struct platform_device *pdev)
{
struct rk2818_23d_data *pdata = pdev->dev.platform_data;
struct modem_dev *mt6223d_data = platform_get_drvdata(pdev);
MODEMDBG("%s \n", __FUNCTION__);
modem_poweron_off(0); // power down
cancel_work_sync(&mt6223d_data->work);
gpio_free(pdata->bp_ap_wakeup);
gpio_free(pdata->bp_power);
gpio_free(pdata->bp_reset);
gpio_free(pdata->ap_bp_wakeup);
gpio_free(pdata->ap_statue);
gpio_free(pdata->bp_statue);
kfree(mt6223d_data);
}
int mtk23d_resume(struct platform_device *pdev)
{
struct rk2818_23d_data *pdata = pdev->dev.platform_data;
int irq = 0;
MODEMDBG("%s \n", __FUNCTION__);
irq = gpio_to_irq(pdata->bp_statue);
if(irq)
{
printk("disable pdata->bp_statue irq_wake!! \n");
bpstatus_irq_enable = false;
disable_irq_wake(irq);
}
ap_wakeup(pdev);
ap_wakeup_bp(pdev, 1);
return 0;
}
int mtk23d_suspend(struct platform_device *pdev, pm_message_t state)
{
int irq;
struct rk2818_23d_data *pdata = pdev->dev.platform_data;
MODEMDBG("%s \n", __FUNCTION__);
//enable_irq_wake(irq);
ap_sleep(pdev);
ap_wakeup_bp(pdev, 0);
irq = gpio_to_irq(pdata->bp_statue);
if (irq < 0) {
printk("can't get pdata->bp_statue irq \n");
}
else
{
printk("enable pdata->bp_statue irq_wake!! \n");
bpstatus_irq_enable = true;
enable_irq_wake(irq);
}
return 0;
}
static int mtk23d_probe(struct platform_device *pdev)
{
struct rk2818_23d_data *pdata = gpdata = pdev->dev.platform_data;
struct modem_dev *mt6223d_data = NULL;
int result=1;
MODEMDBG("mtk23d_probe\n");
//pdata->io_init();
pdata->dev = &pdev->dev;
mt6223d_data = kzalloc(sizeof(struct modem_dev), GFP_KERNEL);
if(NULL == mt6223d_data)
{
printk("failed to request mt6223d_data\n");
goto err6;
}
platform_set_drvdata(pdev, mt6223d_data);
result = gpio_request(pdata->bp_statue, "mtk23d");
if (result) {
printk("failed to request BP_STATUS gpio\n");
goto err5;
}
result = gpio_request(pdata->ap_statue, "mtk23d");
if (result) {
printk("failed to request AP_STATUS gpio\n");
goto err4;
}
result = gpio_request(pdata->ap_bp_wakeup, "mtk23d");
if (result) {
printk("failed to request AP_BP_WAKEUP gpio\n");
goto err3;
}
result = gpio_request(pdata->bp_reset, "mtk23d");
if (result) {
printk("failed to request BP_RESET gpio\n");
goto err2;
}
result = gpio_request(pdata->bp_power, "mtk23d");
if (result) {
printk("failed to request BP_POW_EN gpio\n");
goto err1;
}
if(pdata->bp_ap_wakeup) // SDK板中，该口没有引出
{
result = gpio_request(pdata->bp_ap_wakeup, "mtk23d");
if (result) {
printk("failed to request BP_AP_WAKEUP gpio\n");
goto err0;
}
}
#if 1 // GPIO初始化，并且防止漏电
rk29_uart_to_gpio(0);
/***power off 23d***/
gpio_direction_output(pdata->bp_power, pdata->bp_power_active_low? GPIO_LOW:GPIO_HIGH);
gpio_direction_output(pdata->ap_statue, GPIO_LOW);
gpio_direction_output(pdata->ap_bp_wakeup, GPIO_LOW);
//gpio_direction_output(pdata->bp_statue,GPIO_LOW);
gpio_direction_input(pdata->bp_statue);
if(pdata->bp_ap_wakeup) // SDK板中，该口没有引出
{
//gpio_direction_output(pdata->bp_ap_wakeup,GPIO_LOW);
gpio_direction_input(pdata->bp_ap_wakeup);
}
/*复位BP*/
gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_LOW:GPIO_HIGH);
//mdelay(200);
//gpio_set_value(pdata->bp_reset, pdata->bp_reset_active_low? GPIO_HIGH:GPIO_LOW);
#endif
INIT_WORK(&mt6223d_data->work, bpwakeup_work_func_work);
sema_init(&pdata->power_sem,1);
power_on = 1;
result = misc_register(&mtk23d_misc);
if(result)
{
MODEMDBG("misc_register err\n");
}
MODEMDBG("mtk23d_probe ok\n");
return result;
err0:
cancel_work_sync(&mt6223d_data->work);
gpio_free(pdata->bp_ap_wakeup);
err1:
gpio_free(pdata->bp_power);
err2:
gpio_free(pdata->bp_reset);
err3:
gpio_free(pdata->ap_bp_wakeup);
err4:
gpio_free(pdata->ap_statue);
err5:
gpio_free(pdata->bp_statue);
err6:
kfree(mt6223d_data);
return result;
}
static void do_wakeup(struct work_struct *work)
{
MODEMDBG("%s[%d]: %s\n", __FILE__, __LINE__, __FUNCTION__);
//rk28_send_wakeup_key();
}
static int mi700_release(struct inode *inode, struct file *file)
{
MODEMDBG("%s::%d--bruins--\n",__func__,__LINE__);
//modem_poweron_off(0);
return 0;
}
static void __exit mtk23d_exit(void)
{
MODEMDBG("mtk23d_exit\n");
platform_driver_unregister(&mtk23d_driver);
}
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;
}
