static int __init modem_8974_init(void) { int ret; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); if (ret < 0) { pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); goto out; } ret = request_irq(MSS_Q6SS_WDOG_EXP_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n", __func__, ret); goto out; } modem_ssr_dev = subsys_register(&modem_8974); if (IS_ERR_OR_NULL(modem_ssr_dev)) { pr_err("%s: Unable to reg with subsystem restart. (%ld)\n", __func__, PTR_ERR(modem_ssr_dev)); ret = PTR_ERR(modem_ssr_dev); goto out; } pr_info("%s: modem subsystem restart driver init'ed.\n", __func__); out: return ret; }
static int modem_shutdown(const struct subsys_data *subsys) { void __iomem *q6_fw_wdog_addr; void __iomem *q6_sw_wdog_addr; int smsm_notif_unregistered = 0; if (!(smsm_get_state(SMSM_MODEM_STATE) & SMSM_RESET)) { smsm_state_cb_deregister(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); smsm_notif_unregistered = 1; smsm_reset_modem(SMSM_RESET); } /* * Cancel any pending wdog_check work items, since we're shutting * down anyway. */ cancel_delayed_work(&modem_wdog_check_work); /* * Disable the modem watchdog since it keeps running even after the * modem is shutdown. */ q6_fw_wdog_addr = ioremap_nocache(Q6_FW_WDOG_ENABLE, 4); if (!q6_fw_wdog_addr) return -ENOMEM; q6_sw_wdog_addr = ioremap_nocache(Q6_SW_WDOG_ENABLE, 4); if (!q6_sw_wdog_addr) { iounmap(q6_fw_wdog_addr); return -ENOMEM; } writel_relaxed(0x0, q6_fw_wdog_addr); writel_relaxed(0x0, q6_sw_wdog_addr); mb(); iounmap(q6_sw_wdog_addr); iounmap(q6_fw_wdog_addr); pil_force_shutdown("modem"); pil_force_shutdown("modem_fw"); disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ); disable_irq_nosync(Q6SW_WDOG_EXPIRED_IRQ); if (smsm_notif_unregistered) smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); return 0; }
static int __init riva_ssr_module_init(void) { int ret; /* 8960_LA1P5_CR #:XXX, WH Lee, 20120621 */ /* Add Boot log */ printk("BootLog, +%s\n", __func__); /* WH Lee, 20120621 */ ret = smsm_state_cb_register(SMSM_WCNSS_STATE, SMSM_RESET, smsm_state_cb_hdlr, 0); if (ret < 0) { pr_err("%s: Unable to register smsm callback for Riva Reset! %d\n", MODULE_NAME, ret); goto out; } ret = request_irq(RIVA_APSS_WDOG_BITE_RESET_RDY_IRQ, riva_wdog_bite_irq_hdlr, IRQF_TRIGGER_RISING, "riva_wdog", NULL); if (ret < 0) { pr_err("%s: Unable to register for Riva bite interrupt (%d)\n", MODULE_NAME, ret); goto out; } ret = riva_restart_init(); if (ret < 0) { pr_err("%s: Unable to register with ssr. (%d)\n", MODULE_NAME, ret); goto out; } riva_ramdump_dev = create_ramdump_device("riva"); if (!riva_ramdump_dev) { pr_err("%s: Unable to create ramdump device.\n", MODULE_NAME); ret = -ENOMEM; goto out; } INIT_DELAYED_WORK(&cancel_vote_work, riva_post_bootup); pr_info("%s: module initialized\n", MODULE_NAME); out: /* 8960_LA1P5_CR #:XXX, WH Lee, 20120621 */ /* Add Boot log */ printk("BootLog, -%s, ret=%d\n", __func__,ret); /* WH Lee, 20120621 */ return ret; }
static int __init modem_8960_init(void) { int ret; if (!cpu_is_msm8960()) return -ENODEV; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); if (ret < 0) pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); ret = request_irq(Q6FW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_fw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6fw watchdog IRQ. (%d)\n", __func__, ret); goto out; } ret = request_irq(Q6SW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n", __func__, ret); disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ); goto out; } ret = modem_subsystem_restart_init(); if (ret < 0) { pr_err("%s: Unable to reg with subsystem restart. (%d)\n", __func__, ret); goto out; } ret = modem_debugfs_init(); pr_info("%s: 8960 modem fatal driver init'ed.\n", __func__); out: return ret; }
static int __init riva_ssr_module_init(void) { int ret; ret = smsm_state_cb_register(SMSM_WCNSS_STATE, SMSM_RESET, smsm_state_cb_hdlr, 0); if (ret < 0) { pr_err("%s: Unable to register smsm callback for Riva Reset!" " (%d)\n", MODULE_NAME, ret); goto out; } ret = request_irq(RIVA_APSS_WDOG_BITE_RESET_RDY_IRQ, riva_wdog_bite_irq_hdlr, IRQF_TRIGGER_HIGH, "riva_wdog", NULL); if (ret < 0) { pr_err("%s: Unable to register for Riva bite interrupt" " (%d)\n", MODULE_NAME, ret); goto out1; } ret = riva_restart_init(); if (ret < 0) { pr_err("%s: Unable to register with ssr. (%d)\n", MODULE_NAME, ret); goto out2; } riva_ramdump_dev = create_ramdump_device("riva"); if (!riva_ramdump_dev) { pr_err("%s: Unable to create ramdump device.\n", MODULE_NAME); ret = -ENOMEM; goto out2; } INIT_DELAYED_WORK(&cancel_vote_work, riva_post_bootup); pr_info("%s: module initialized\n", MODULE_NAME); return ret; out2: free_irq(RIVA_APSS_WDOG_BITE_RESET_RDY_IRQ, NULL); out1: smsm_state_cb_deregister(SMSM_WCNSS_STATE, SMSM_RESET, smsm_state_cb_hdlr, 0); out: return ret; }
static int __devinit pil_riva_probe(struct platform_device *pdev) { struct riva_data *drv; struct resource *res; struct pil_desc *desc; int ret; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); drv->base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 1); drv->cbase = devm_request_and_ioremap(&pdev->dev, res); if (!drv->cbase) return -ENOMEM; drv->pll_supply = devm_regulator_get(&pdev->dev, "pll_vdd"); if (IS_ERR(drv->pll_supply)) { dev_err(&pdev->dev, "failed to get pll supply\n"); return PTR_ERR(drv->pll_supply); } if (regulator_count_voltages(drv->pll_supply) > 0) { ret = regulator_set_voltage(drv->pll_supply, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll supply voltage\n"); return ret; } ret = regulator_set_optimum_mode(drv->pll_supply, 100000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll supply optimum mode\n"); return ret; } } drv->irq = platform_get_irq(pdev, 0); if (drv->irq < 0) return drv->irq; drv->xo = devm_clk_get(&pdev->dev, "cxo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); desc = &drv->pil_desc; desc->name = "wcnss"; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_WCNSS) > 0) { desc->ops = &pil_riva_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_riva_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } ret = pil_desc_init(desc); ret = smsm_state_cb_register(SMSM_WCNSS_STATE, SMSM_RESET, smsm_state_cb_hdlr, drv); if (ret < 0) goto err_smsm; drv->subsys_desc.name = "wcnss"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.start = riva_start; drv->subsys_desc.stop = riva_stop; drv->subsys_desc.shutdown = riva_shutdown; drv->subsys_desc.powerup = riva_powerup; drv->subsys_desc.ramdump = riva_ramdump; drv->subsys_desc.crash_shutdown = riva_crash_shutdown; INIT_DELAYED_WORK(&drv->cancel_work, riva_post_bootup); drv->ramdump_dev = create_ramdump_device("riva", &pdev->dev); if (!drv->ramdump_dev) { ret = -ENOMEM; goto err_ramdump; } drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } scm_pas_init(MSM_BUS_MASTER_SPS); ret = devm_request_irq(&pdev->dev, drv->irq, riva_wdog_bite_irq_hdlr, IRQF_TRIGGER_RISING, "riva_wdog", drv); if (ret < 0) goto err; return 0; err: subsys_unregister(drv->subsys); err_subsys: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: smsm_state_cb_deregister(SMSM_WCNSS_STATE, SMSM_RESET, smsm_state_cb_hdlr, drv); err_smsm: pil_desc_release(desc); return ret; }
static int __init gss_8064_init(void) { int ret; if (!cpu_is_apq8064()) return -ENODEV; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); if (ret < 0) pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); ret = request_irq(GSS_A5_WDOG_EXPIRED, gss_wdog_bite_irq, IRQF_TRIGGER_RISING, "gss_a5_wdog", NULL); if (ret < 0) { pr_err("%s: Unable to request gss watchdog IRQ. (%d)\n", __func__, ret); disable_irq_nosync(GSS_A5_WDOG_EXPIRED); goto out; } ret = gss_subsystem_restart_init(); if (ret < 0) { pr_err("%s: Unable to reg with subsystem restart. (%d)\n", __func__, ret); goto out; } gss_data.gss_dev.minor = MISC_DYNAMIC_MINOR; gss_data.gss_dev.name = "gss"; gss_data.gss_dev.fops = &gss_file_ops; ret = misc_register(&gss_data.gss_dev); if (ret) { pr_err("%s: misc_registers failed for %s (%d)", __func__, gss_data.gss_dev.name, ret); goto out; } gss_data.gss_ramdump_dev = create_ramdump_device("gss"); if (!gss_data.gss_ramdump_dev) { pr_err("%s: Unable to create gss ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } gss_data.smem_ramdump_dev = create_ramdump_device("smem-gss"); if (!gss_data.smem_ramdump_dev) { pr_err("%s: Unable to create smem ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } pr_info("%s: gss fatal driver init'ed.\n", __func__); out: return ret; }
/** * platform driver * */ static int __devinit dsps_probe(struct platform_device *pdev) { int ret; pr_debug("%s.\n", __func__); if (pdev->dev.platform_data == NULL) { pr_err("%s: platform data is NULL.\n", __func__); return -ENODEV; } drv = kzalloc(sizeof(*drv), GFP_KERNEL); if (drv == NULL) { pr_err("%s: kzalloc fail.\n", __func__); goto alloc_err; } drv->pdata = pdev->dev.platform_data; drv->dev_class = class_create(THIS_MODULE, DRV_NAME); if (drv->dev_class == NULL) { pr_err("%s: class_create fail.\n", __func__); goto res_err; } ret = alloc_chrdev_region(&drv->dev_num, 0, 1, DRV_NAME); if (ret) { pr_err("%s: alloc_chrdev_region fail.\n", __func__); goto alloc_chrdev_region_err; } drv->dev = device_create(drv->dev_class, NULL, drv->dev_num, drv, DRV_NAME); if (IS_ERR(drv->dev)) { pr_err("%s: device_create fail.\n", __func__); goto device_create_err; } drv->cdev = cdev_alloc(); if (drv->cdev == NULL) { pr_err("%s: cdev_alloc fail.\n", __func__); goto cdev_alloc_err; } cdev_init(drv->cdev, &dsps_fops); drv->cdev->owner = THIS_MODULE; ret = cdev_add(drv->cdev, drv->dev_num, 1); if (ret) { pr_err("%s: cdev_add fail.\n", __func__); goto cdev_add_err; } ret = dsps_alloc_resources(pdev); if (ret) { pr_err("%s: failed to allocate dsps resources.\n", __func__); goto cdev_add_err; } ret = smsm_state_cb_register(SMSM_DSPS_STATE, SMSM_RESET, dsps_smsm_state_cb, 0); if (ret) { pr_err("%s: smsm_state_cb_register fail %d\n", __func__, ret); goto smsm_register_err; } ret = ssr_register_subsystem(&dsps_ssrops); if (ret) { pr_err("%s: ssr_register_subsystem fail %d\n", __func__, ret); goto ssr_register_err; } return 0; ssr_register_err: smsm_state_cb_deregister(SMSM_DSPS_STATE, SMSM_RESET, dsps_smsm_state_cb, 0); smsm_register_err: cdev_del(drv->cdev); cdev_add_err: kfree(drv->cdev); cdev_alloc_err: device_destroy(drv->dev_class, drv->dev_num); device_create_err: unregister_chrdev_region(drv->dev_num, 1); alloc_chrdev_region_err: class_destroy(drv->dev_class); res_err: kfree(drv); drv = NULL; alloc_err: return -ENODEV; }
static int debug_test_smsm(char *buf, int max) { int i = 0; int test_num = 0; int ret; /* Test case 1 - Register new callback for notification */ do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); /* de-assert SMSM_SMD_INIT to trigger state update */ UT_EQ_INT(smsm_cb_data.cb_count, 0); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); UT_EQ_INT(smsm_cb_data.old_state & SMSM_SMDINIT, SMSM_SMDINIT); UT_EQ_INT(smsm_cb_data.new_state & SMSM_SMDINIT, 0x0); UT_EQ_INT((int)smsm_cb_data.data, 0x1234); /* re-assert SMSM_SMD_INIT to trigger state update */ INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); UT_EQ_INT(smsm_cb_data.old_state & SMSM_SMDINIT, 0x0); UT_EQ_INT(smsm_cb_data.new_state & SMSM_SMDINIT, SMSM_SMDINIT); /* deregister callback */ ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); /* make sure state change doesn't cause any more callbacks */ INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); /* Test case 2 - Update already registered callback */ do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 1); /* verify both callback bits work */ INIT_COMPLETION(smsm_cb_completion); UT_EQ_INT(smsm_cb_data.cb_count, 0); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 3); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 4); /* deregister 1st callback */ ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 1); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 4); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 5); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 6); /* deregister 2nd callback */ ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); /* make sure state change doesn't cause any more callbacks */ INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 6); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); /* Test case 3 - Two callback registrations with different data */ do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x3456); UT_EQ_INT(ret, 0); /* verify both callbacks work */ INIT_COMPLETION(smsm_cb_completion); UT_EQ_INT(smsm_cb_data.cb_count, 0); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); UT_EQ_INT((int)smsm_cb_data.data, 0x1234); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); UT_EQ_INT((int)smsm_cb_data.data, 0x3456); /* cleanup and unregister * degregister in reverse to verify data field is * being used */ smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x3456); UT_EQ_INT(ret, 2); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); return i; }
static int pil_q6v4_modem_driver_probe(struct platform_device *pdev) { struct q6v4_data *drv_fw, *drv_sw; struct q6v4_modem *drv; struct resource *res; struct regulator *pll_supply; int ret; const struct pil_q6v4_pdata *pdata = pdev->dev.platform_data; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv_fw = &drv->q6_fw; drv_sw = &drv->q6_sw; drv_fw->wdog_irq = platform_get_irq(pdev, 0); if (drv_fw->wdog_irq < 0) return drv_fw->wdog_irq; drv_sw->wdog_irq = platform_get_irq(pdev, 1); if (drv_sw->wdog_irq < 0) return drv_sw->wdog_irq; drv->loadable = !!pdata; /* No pdata = don't use PIL */ if (drv->loadable) { ret = pil_q6v4_proc_init(drv_fw, pdev, 0); if (ret) return ret; ret = pil_q6v4_proc_init(drv_sw, pdev, 1); if (ret) return ret; pll_supply = devm_regulator_get(&pdev->dev, "pll_vdd"); drv_fw->pll_supply = drv_sw->pll_supply = pll_supply; if (IS_ERR(pll_supply)) return PTR_ERR(pll_supply); ret = regulator_set_voltage(pll_supply, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll voltage\n"); return ret; } ret = regulator_set_optimum_mode(pll_supply, 100000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll optimum mode\n"); return ret; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv->modem_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->modem_base) return -ENOMEM; drv_fw->pil = msm_pil_register(&drv_fw->desc); if (IS_ERR(drv_fw->pil)) return PTR_ERR(drv_fw->pil); drv_sw->pil = msm_pil_register(&drv_sw->desc); if (IS_ERR(drv_sw->pil)) { ret = PTR_ERR(drv_sw->pil); goto err_pil_sw; } } drv->subsys_desc.name = "modem"; drv->subsys_desc.shutdown = modem_shutdown; drv->subsys_desc.powerup = modem_powerup; drv->subsys_desc.ramdump = modem_ramdump; drv->subsys_desc.crash_shutdown = modem_crash_shutdown; drv->fw_ramdump_dev = create_ramdump_device("modem_fw"); if (!drv->fw_ramdump_dev) { ret = -ENOMEM; goto err_fw_ramdump; } drv->sw_ramdump_dev = create_ramdump_device("modem_sw"); if (!drv->sw_ramdump_dev) { ret = -ENOMEM; goto err_sw_ramdump; } drv->smem_ramdump_dev = create_ramdump_device("smem-modem"); if (!drv->smem_ramdump_dev) { ret = -ENOMEM; goto err_smem_ramdump; } drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } ret = devm_request_irq(&pdev->dev, drv_fw->wdog_irq, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, dev_name(&pdev->dev), drv); if (ret) goto err_irq; ret = devm_request_irq(&pdev->dev, drv_sw->wdog_irq, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, dev_name(&pdev->dev), drv); if (ret) goto err_irq; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, drv); if (ret) goto err_irq; return 0; err_irq: subsys_unregister(drv->subsys); err_subsys: destroy_ramdump_device(drv->smem_ramdump_dev); err_smem_ramdump: destroy_ramdump_device(drv->sw_ramdump_dev); err_sw_ramdump: destroy_ramdump_device(drv->fw_ramdump_dev); err_fw_ramdump: if (drv->loadable) msm_pil_unregister(drv_sw->pil); err_pil_sw: msm_pil_unregister(drv_fw->pil); return ret; }
static int __init modem_8960_init(void) { int ret; if (!cpu_is_msm8960() && !cpu_is_msm8930() && !cpu_is_msm9615()) return -ENODEV; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); xo1 = msm_xo_get(MSM_XO_TCXO_A0, "modem-8960"); if (IS_ERR(xo1)) { ret = PTR_ERR(xo1); goto out; } xo2 = msm_xo_get(MSM_XO_TCXO_A1, "modem-8960"); if (IS_ERR(xo2)) { ret = PTR_ERR(xo2); goto out; } if (ret < 0) pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); ret = request_irq(Q6FW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_fw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6fw watchdog IRQ. (%d)\n", __func__, ret); goto out; } ret = request_irq(Q6SW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n", __func__, ret); disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ); goto out; } ret = modem_subsystem_restart_init(); if (ret < 0) { pr_err("%s: Unable to reg with subsystem restart. (%d)\n", __func__, ret); goto out; } modemfw_ramdump_dev = create_ramdump_device("modem_fw"); if (!modemfw_ramdump_dev) { pr_err("%s: Unable to create modem fw ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } modemsw_ramdump_dev = create_ramdump_device("modem_sw"); if (!modemsw_ramdump_dev) { pr_err("%s: Unable to create modem sw ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } smem_ramdump_dev = create_ramdump_device("smem"); if (!smem_ramdump_dev) { pr_err("%s: Unable to create smem ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } modem_coredump_dev = create_modem_coredump_device("modem"); if (!modem_coredump_dev) { pr_err("%s: Unable to create modem coredump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } ret = modem_debugfs_init(); pr_info("%s: modem fatal driver init'ed.\n", __func__); out: return ret; }
static int __devinit pil_dsps_driver_probe(struct platform_device *pdev) { struct dsps_data *drv; struct pil_desc *desc; struct resource *res; int ret; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (res) { drv->ppss_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->ppss_base) return -ENOMEM; } desc = &drv->desc; desc->name = pdev->dev.platform_data; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->flags = PIL_SKIP_ENTRY_CHECK; if (pas_supported(PAS_DSPS) > 0) { desc->ops = &pil_dsps_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_dsps_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } ret = pil_desc_init(desc); if (ret) return ret; drv->ramdump_dev = create_ramdump_device("dsps", &pdev->dev); if (!drv->ramdump_dev) { ret = -ENOMEM; goto err_ramdump; } drv->smem_ramdump_segments[0].address = PHYS_OFFSET - SZ_2M; drv->smem_ramdump_segments[0].size = SZ_2M; drv->smem_ramdump_dev = create_ramdump_device("smem-dsps", &pdev->dev); if (!drv->smem_ramdump_dev) { ret = -ENOMEM; goto err_smem_ramdump; } drv->subsys_desc.name = "dsps"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.start = dsps_start; drv->subsys_desc.stop = dsps_stop; drv->subsys_desc.shutdown = dsps_shutdown; drv->subsys_desc.powerup = dsps_powerup; drv->subsys_desc.ramdump = dsps_ramdump, drv->subsys_desc.crash_shutdown = dsps_crash_shutdown; drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } ret = smsm_state_cb_register(SMSM_DSPS_STATE, SMSM_RESET, dsps_smsm_state_cb, drv); if (ret) goto err_smsm; drv->wdog_irq = platform_get_irq(pdev, 0); if (drv->wdog_irq >= 0) { ret = devm_request_irq(&pdev->dev, drv->wdog_irq, dsps_wdog_bite_irq, IRQF_TRIGGER_RISING, "dsps_wdog", drv); if (ret) { dev_err(&pdev->dev, "request_irq failed\n"); goto err_smsm; } } else { drv->wdog_irq = -1; dev_dbg(&pdev->dev, "ppss_wdog not supported\n"); } return 0; err_smsm: subsys_unregister(drv->subsys); err_subsys: destroy_ramdump_device(drv->smem_ramdump_dev); err_smem_ramdump: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: pil_desc_release(desc); return ret; }
static int debug_test_smsm(char *buf, int max) { int i = 0; int test_num = 0; int ret; do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); UT_EQ_INT(smsm_cb_data.cb_count, 0); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); UT_EQ_INT(smsm_cb_data.old_state & SMSM_SMDINIT, SMSM_SMDINIT); UT_EQ_INT(smsm_cb_data.new_state & SMSM_SMDINIT, 0x0); UT_EQ_INT((int)smsm_cb_data.data, 0x1234); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); UT_EQ_INT(smsm_cb_data.old_state & SMSM_SMDINIT, 0x0); UT_EQ_INT(smsm_cb_data.new_state & SMSM_SMDINIT, SMSM_SMDINIT); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 1); INIT_COMPLETION(smsm_cb_completion); UT_EQ_INT(smsm_cb_data.cb_count, 0); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 3); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 4); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 1); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 4); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 5); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 6); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); UT_EQ_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 6); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); do { test_num++; SMSM_CB_TEST_INIT(); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 0); ret = smsm_state_cb_register(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x3456); UT_EQ_INT(ret, 0); INIT_COMPLETION(smsm_cb_completion); UT_EQ_INT(smsm_cb_data.cb_count, 0); smsm_change_state(SMSM_APPS_STATE, SMSM_SMDINIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 1); UT_EQ_INT((int)smsm_cb_data.data, 0x1234); INIT_COMPLETION(smsm_cb_completion); smsm_change_state(SMSM_APPS_STATE, SMSM_INIT, 0x0); UT_GT_INT((int)wait_for_completion_timeout(&smsm_cb_completion, msecs_to_jiffies(20)), 0); UT_EQ_INT(smsm_cb_data.cb_count, 2); UT_EQ_INT((int)smsm_cb_data.data, 0x3456); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_SMDINIT); smsm_change_state(SMSM_APPS_STATE, 0x0, SMSM_INIT); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_INIT, smsm_state_cb, (void *)0x3456); UT_EQ_INT(ret, 2); ret = smsm_state_cb_deregister(SMSM_APPS_STATE, SMSM_SMDINIT, smsm_state_cb, (void *)0x1234); UT_EQ_INT(ret, 2); i += scnprintf(buf + i, max - i, "Test %d - PASS\n", test_num); } while (0); return i; }
static int __init modem_8960_init(void) { int ret; if (!cpu_is_msm8960() && !cpu_is_msm8930() && !cpu_is_msm8930aa() && !cpu_is_msm9615() && !cpu_is_msm8627()) return -ENODEV; ret = smsm_state_cb_register(SMSM_MODEM_STATE, SMSM_RESET, smsm_state_cb, 0); if (ret < 0) pr_err("%s: Unable to register SMSM callback! (%d)\n", __func__, ret); ret = request_irq(Q6FW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_fw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6fw watchdog IRQ. (%d)\n", __func__, ret); goto out; } ret = request_irq(Q6SW_WDOG_EXPIRED_IRQ, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_wdog_sw", NULL); if (ret < 0) { pr_err("%s: Unable to request q6sw watchdog IRQ. (%d)\n", __func__, ret); disable_irq_nosync(Q6FW_WDOG_EXPIRED_IRQ); goto out; } ret = modem_subsystem_restart_init(); if (ret < 0) { pr_err("%s: Unable to reg with subsystem restart. (%d)\n", __func__, ret); goto out; } modemfw_ramdump_dev = create_ramdump_device("modem_fw"); if (!modemfw_ramdump_dev) { pr_err("%s: Unable to create modem fw ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } modemsw_ramdump_dev = create_ramdump_device("modem_sw"); if (!modemsw_ramdump_dev) { pr_err("%s: Unable to create modem sw ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } #if defined(CONFIG_LGE_HANDLE_PANIC) if(smem_ramdump_dev==NULL) #endif smem_ramdump_dev = create_ramdump_device("smem-modem"); if (!smem_ramdump_dev) { pr_err("%s: Unable to create smem ramdump device. (%d)\n", __func__, -ENOMEM); ret = -ENOMEM; goto out; } ret = modem_debugfs_init(); pr_info("%s: modem fatal driver init'ed.\n", __func__); out: return ret; }