static int __init msm_peripheral_reset_init(void) { unsigned i; msm_mms_regs_base = ioremap(MSM_MMS_REGS_BASE, SZ_256); if (!msm_mms_regs_base) goto err; msm_lpass_qdsp6ss_base = ioremap(MSM_LPASS_QDSP6SS_BASE, SZ_256); if (!msm_lpass_qdsp6ss_base) goto err_lpass; pxo = msm_xo_get(MSM_XO_PXO, "pil"); if (IS_ERR(pxo)) goto err_pxo; pll4 = clk_get_sys("peripheral-reset", "pll4"); if (IS_ERR(pll4)) goto err_clk; if (pas_supported(PAS_MODEM) > 0) { pil_modem_ops.init_image = init_image_modem_trusted; pil_modem_ops.auth_and_reset = reset_modem_trusted; pil_modem_ops.shutdown = shutdown_modem_trusted; } if (pas_supported(PAS_Q6) > 0) { pil_q6_ops.init_image = init_image_q6_trusted; pil_q6_ops.auth_and_reset = reset_q6_trusted; pil_q6_ops.shutdown = shutdown_q6_trusted; } if (pas_supported(PAS_DSPS) > 0) { pil_dsps_ops.init_image = init_image_dsps_trusted; pil_dsps_ops.auth_and_reset = reset_dsps_trusted; pil_dsps_ops.shutdown = shutdown_dsps_trusted; } for (i = 0; i < ARRAY_SIZE(peripherals); i++) msm_pil_add_device(&peripherals[i]); return 0; err_clk: msm_xo_put(pxo); err_pxo: iounmap(msm_lpass_qdsp6ss_base); err_lpass: iounmap(msm_mms_regs_base); err: return -ENOMEM; }
static void __init use_secure_pil(void) { if (pas_supported(PAS_DSPS) > 0) { pil_dsps_ops.init_image = init_image_dsps_trusted; pil_dsps_ops.auth_and_reset = reset_dsps_trusted; pil_dsps_ops.shutdown = shutdown_dsps_trusted; } if (pas_supported(PAS_RIVA) > 0) { pil_riva_ops.init_image = init_image_riva_trusted; pil_riva_ops.auth_and_reset = reset_riva_trusted; pil_riva_ops.shutdown = shutdown_riva_trusted; } }
static int __devinit pil_q6v4_driver_probe(struct platform_device *pdev) { const struct pil_q6v4_pdata *pdata = pdev->dev.platform_data; struct q6v4_data *drv; struct resource *res; struct pil_desc *desc; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); 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->modem_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->modem_base) return -ENOMEM; } desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!drv) return -ENOMEM; desc->name = pdata->name; desc->depends_on = pdata->depends; desc->dev = &pdev->dev; if (pas_supported(pdata->pas_id) > 0) { desc->ops = &pil_q6v4_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_q6v4_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->vreg = regulator_get(&pdev->dev, "core_vdd"); if (IS_ERR(drv->vreg)) return PTR_ERR(drv->vreg); setup_timer(&drv->xo_timer, pil_q6v4_remove_xo_proxy_votes, (unsigned long)drv); drv->xo = msm_xo_get(pdata->xo_id, pdata->name); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); if (msm_pil_register(desc)) { regulator_put(drv->vreg); return -EINVAL; } return 0; }
static int pil_bcss_driver_probe(struct platform_device *pdev) { struct bcss_data *drv; struct pil_desc *desc; int ret; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qti,firmware-name", &desc->name); if (ret) return ret; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; ret = pas_supported(PAS_BCSS); if (ret > 0) { desc->ops = &pil_bcss_ops; dev_info(&pdev->dev, "using secure boot\n"); } else { dev_err(&pdev->dev, "Secure boot is not supported\n"); return ret; } ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = desc->name; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.shutdown = bcss_shutdown; drv->subsys_desc.powerup = bcss_powerup; drv->subsys_desc.ramdump = bcss_ramdump; drv->ramdump_dev = create_ramdump_device("bcss", &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; } return ret; err_subsys: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: pil_desc_release(desc); return ret; }
static int pil_dsps_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; struct pil_device *pil; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; desc->name = pdev->dev.platform_data; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; 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"); } pil = msm_pil_register(desc); if (IS_ERR(pil)) { devm_kfree(&pdev->dev, desc); return PTR_ERR(pil); } platform_set_drvdata(pdev, pil); return 0; }
static int __devinit pil_vidc_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; struct vidc_data *drv; int ret; if (pas_supported(PAS_VIDC) < 0) { ret = -ENOSYS; goto error; } desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) { ret = -ENOMEM; goto error; } drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) { ret = -ENOMEM; goto alloc_fail1; } platform_set_drvdata(pdev, drv); drv->smmu_iface = devm_clk_get(&pdev->dev, "smmu_iface_clk"); if (IS_ERR(drv->smmu_iface)) { ret = PTR_ERR(drv->smmu_iface); goto alloc_fail2; } drv->core = devm_clk_get(&pdev->dev, "core_clk"); if (IS_ERR(drv->core)) { ret = PTR_ERR(drv->core); goto alloc_fail2; } desc->name = "vidc"; desc->dev = &pdev->dev; desc->ops = &pil_vidc_ops; desc->owner = THIS_MODULE; drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) { ret = PTR_ERR(drv->pil); goto alloc_fail2; } return 0; alloc_fail2: devm_kfree(&pdev->dev, drv); alloc_fail1: devm_kfree(&pdev->dev, desc); error: return ret; }
static int pil_q6v4_proc_init(struct q6v4_data *drv, struct platform_device *pdev, int i) { static const char *name[2] = { "fw", "sw" }; const struct pil_q6v4_pdata *pdata_p = pdev->dev.platform_data; const struct pil_q6v4_pdata *pdata = pdata_p + i; char reg_name[12]; struct pil_desc *desc; struct resource *res; res = platform_get_resource(pdev, IORESOURCE_MEM, 1 + (i * 2)); 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, 2 + (i * 2)); if (!res) return -EINVAL; drv->wdog_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->wdog_base) return -ENOMEM; snprintf(reg_name, sizeof(reg_name), "%s_core_vdd", name[i]); drv->vreg = devm_regulator_get(&pdev->dev, reg_name); if (IS_ERR(drv->vreg)) return PTR_ERR(drv->vreg); drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); desc = &drv->desc; desc->name = pdata->name; desc->depends_on = pdata->depends; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; pil_q6v4_init(drv, pdata); if (pas_supported(pdata->pas_id) > 0) { desc->ops = &pil_q6v4_modem_ops_trusted; dev_info(&pdev->dev, "using secure boot for %s\n", name[i]); } else { desc->ops = &pil_q6v4_modem_ops; dev_info(&pdev->dev, "using non-secure boot for %s\n", name[i]); } return 0; }
static int __init msm_peripheral_reset_init(void) { msm_mms_regs_base = ioremap(MSM_MMS_REGS_BASE, SZ_256); if (!msm_mms_regs_base) goto err; pxo = msm_xo_get(MSM_XO_PXO, "pil"); if (IS_ERR(pxo)) goto err_pxo; if (pas_supported(PAS_MODEM) > 0) { pil_modem_ops.init_image = init_image_modem_trusted; pil_modem_ops.auth_and_reset = reset_modem_trusted; pil_modem_ops.shutdown = shutdown_modem_trusted; } if (pas_supported(PAS_DSPS) > 0) { pil_dsps_ops.init_image = init_image_dsps_trusted; pil_dsps_ops.auth_and_reset = reset_dsps_trusted; pil_dsps_ops.shutdown = shutdown_dsps_trusted; } BUG_ON(platform_device_register(&pil_modem)); BUG_ON(msm_pil_register(&pil_modem_desc)); BUG_ON(platform_device_register(&pil_playready)); BUG_ON(msm_pil_register(&pil_playready_desc)); if (machine_is_msm8x60_fluid()) pil_dsps_desc.name = "dsps_fluid"; BUG_ON(platform_device_register(&pil_dsps)); BUG_ON(msm_pil_register(&pil_dsps_desc)); return 0; err_pxo: iounmap(msm_mms_regs_base); err: return -ENOMEM; }
static int __devinit pil_q6v3_driver_probe(struct platform_device *pdev) { struct q6v3_data *drv; struct resource *res; struct pil_desc *desc; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!drv) return -ENOMEM; drv->pll = devm_clk_get(&pdev->dev, "pll4"); if (IS_ERR(drv->pll)) return PTR_ERR(drv->pll); desc->name = "q6"; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; #ifndef CONFIG_MSM_INSECURE_PIL_QDSP6V3 if (pas_supported(PAS_Q6) > 0) { desc->ops = &pil_q6v3_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { #endif desc->ops = &pil_q6v3_ops; dev_info(&pdev->dev, "using non-secure boot\n"); #ifndef CONFIG_MSM_INSECURE_PIL_QDSP6V3 } #endif drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) { return PTR_ERR(drv->pil); } return 0; }
static int __init msm_peripheral_reset_init(void) { if (pas_supported(PAS_DSPS) > 0) { pil_dsps_ops.init_image = init_image_dsps_trusted; pil_dsps_ops.auth_and_reset = reset_dsps_trusted; pil_dsps_ops.shutdown = shutdown_dsps_trusted; } if (machine_is_msm8x60_fluid()) pil_dsps_desc.name = "dsps_fluid"; BUG_ON(platform_device_register(&pil_dsps)); BUG_ON(IS_ERR(msm_pil_register(&pil_dsps_desc))); return 0; }
static int __devinit pil_vidc_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; struct vidc_data *drv; int ret; if (pas_supported(PAS_VIDC) < 0) return -ENOSYS; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->smmu_iface = devm_clk_get(&pdev->dev, "smmu_iface_clk"); if (IS_ERR(drv->smmu_iface)) return PTR_ERR(drv->smmu_iface); drv->core = devm_clk_get(&pdev->dev, "core_clk"); if (IS_ERR(drv->core)) return PTR_ERR(drv->core); desc = &drv->pil_desc; desc->name = "vidc"; desc->dev = &pdev->dev; desc->ops = &pil_vidc_ops; desc->owner = THIS_MODULE; ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = "vidc"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.powerup = vidc_powerup; drv->subsys_desc.shutdown = vidc_shutdown; drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { pil_desc_release(desc); return PTR_ERR(drv->subsys); } scm_pas_init(MSM_BUS_MASTER_SPS); return 0; }
static int __devinit pil_modem_driver_probe(struct platform_device *pdev) { struct modem_data *drv; struct resource *res; struct pil_desc *desc; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; drv->pxo = msm_xo_get(MSM_XO_PXO, dev_name(&pdev->dev)); if (IS_ERR(drv->pxo)) return PTR_ERR(drv->pxo); desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; setup_timer(&drv->timer, remove_proxy_votes, (unsigned long)drv); desc->name = "modem"; desc->depends_on = "q6"; desc->dev = &pdev->dev; if (pas_supported(PAS_MODEM) > 0) { desc->ops = &pil_modem_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_modem_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } if (msm_pil_register(desc)) { msm_xo_put(drv->pxo); return -EINVAL; } return 0; }
static int __devinit pil_modem_driver_probe(struct platform_device *pdev) { struct modem_data *drv; struct resource *res; struct pil_desc *desc; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; desc->name = "modem"; desc->depends_on = "q6"; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_MODEM) > 0) { desc->ops = &pil_modem_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_modem_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) { return PTR_ERR(drv->pil); } return 0; }
static int __devinit pil_tzapps_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; if (pas_supported(PAS_TZAPPS) < 0) return -ENOSYS; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; desc->name = "tzapps"; desc->dev = &pdev->dev; desc->ops = &pil_tzapps_ops; if (msm_pil_register(desc)) return -EINVAL; return 0; }
static int __devinit pil_q6v3_driver_probe(struct platform_device *pdev) { struct q6v3_data *drv; struct resource *res; struct pil_desc *desc; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!drv) return -ENOMEM; drv->pll = clk_get(&pdev->dev, "pll4"); if (IS_ERR(drv->pll)) return PTR_ERR(drv->pll); setup_timer(&drv->timer, q6v3_remove_proxy_votes, (unsigned long)drv); desc->name = "q6"; desc->dev = &pdev->dev; if (pas_supported(PAS_Q6) > 0) { desc->ops = &pil_q6v3_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_q6v3_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } if (msm_pil_register(desc)) return -EINVAL; return 0; }
static int __devinit pil_vidc_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; if (pas_supported(PAS_VIDC) < 0) return -ENOSYS; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; desc->name = "vidc"; desc->dev = &pdev->dev; desc->ops = &pil_vidc_ops; if (msm_pil_register(desc)) { devm_kfree(&pdev->dev, desc); return -EINVAL; } return 0; }
static int __devinit pil_tzapps_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; struct pil_device *pil; if (pas_supported(PAS_TZAPPS) < 0) return -ENOSYS; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; desc->name = "tzapps"; desc->dev = &pdev->dev; desc->ops = &pil_tzapps_ops; desc->owner = THIS_MODULE; pil = msm_pil_register(desc); if (IS_ERR(pil)) return PTR_ERR(pil); platform_set_drvdata(pdev, pil); return 0; }
static int __devinit pil_tzapps_driver_probe(struct platform_device *pdev) { struct pil_desc *desc; struct tzapps_data *drv; int ret; if (pas_supported(PAS_TZAPPS) < 0) return -ENOSYS; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); desc = &drv->pil_desc; desc->name = "tzapps"; desc->dev = &pdev->dev; desc->ops = &pil_tzapps_ops; desc->owner = THIS_MODULE; ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = "tzapps"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.start = tzapps_start; drv->subsys_desc.stop = tzapps_stop; drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { pil_desc_release(desc); return PTR_ERR(drv->subsys); } return 0; }
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 __devinit pil_q6v3_driver_probe(struct platform_device *pdev) { struct q6v3_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->wk_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->wk_base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 2); drv->wd_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->wd_base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 3); if (!res) return -EINVAL; drv->cbase = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->cbase) return -ENOMEM; drv->irq = platform_get_irq(pdev, 0); if (drv->irq < 0) return drv->irq; drv->pll = devm_clk_get(&pdev->dev, "pll4"); if (IS_ERR(drv->pll)) return PTR_ERR(drv->pll); desc = &drv->pil_desc; desc->name = "q6"; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_Q6) > 0) { desc->ops = &pil_q6v3_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_q6v3_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = "adsp"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.start = lpass_q6_start; drv->subsys_desc.stop = lpass_q6_stop; drv->subsys_desc.shutdown = lpass_q6_shutdown; drv->subsys_desc.powerup = lpass_q6_powerup; drv->subsys_desc.ramdump = lpass_q6_ramdump; drv->subsys_desc.crash_shutdown = lpass_q6_crash_shutdown; INIT_WORK(&drv->fatal_wrk, q6_fatal_fn); drv->ramdump_dev = create_ramdump_device("lpass", &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; } ret = devm_request_irq(&pdev->dev, drv->irq, lpass_wdog_bite_irq, IRQF_TRIGGER_RISING, "lpass_wdog", drv); if (ret) { dev_err(&pdev->dev, "Unable to request wdog irq.\n"); goto err_irq; } return 0; err_irq: subsys_unregister(drv->subsys); err_subsys: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: pil_desc_release(desc); return ret; }
static int __devinit pil_modem_driver_probe(struct platform_device *pdev) { struct modem_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); drv->irq = platform_get_irq(pdev, 0); if (drv->irq < 0) return drv->irq; drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); 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->wdog = devm_request_and_ioremap(&pdev->dev, res); if (!drv->wdog) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 2); if (!res) return -EINVAL; drv->cbase = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->cbase) return -ENOMEM; desc = &drv->pil_desc; desc->name = "modem"; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_MODEM) > 0) { desc->ops = &pil_modem_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_modem_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } ret = pil_desc_init(desc); if (ret) return ret; drv->notifier.notifier_call = modem_notif_handler, ret = modem_register_notifier(&drv->notifier); if (ret) goto err_notify; drv->subsys_desc.name = "modem"; drv->subsys_desc.depends_on = "adsp"; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.start = modem_start; drv->subsys_desc.stop = modem_stop; 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; INIT_WORK(&drv->fatal_work, modem_fatal_fn); INIT_DELAYED_WORK(&drv->unlock_work, modem_unlock_timeout); drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } drv->ramdump_dev = create_ramdump_device("modem", &pdev->dev); if (!drv->ramdump_dev) { ret = -ENOMEM; goto err_ramdump; } ret = devm_request_irq(&pdev->dev, drv->irq, modem_wdog_bite_irq, IRQF_TRIGGER_RISING, "modem_watchdog", drv); if (ret) goto err_irq; return 0; err_irq: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: subsys_unregister(drv->subsys); err_subsys: modem_unregister_notifier(&drv->notifier); err_notify: pil_desc_release(desc); return ret; }
static int __devinit pil_pronto_probe(struct platform_device *pdev) { struct pronto_data *drv; struct resource *res; struct pil_desc *desc; int ret; uint32_t regval; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pmu_base"); drv->base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->base) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "clk_base"); drv->reset_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->reset_base) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base"); drv->axi_halt_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->axi_halt_base) return -ENOMEM; desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ret; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(PAS_WCNSS) > 0) { desc->ops = &pil_pronto_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_pronto_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->vreg = devm_regulator_get(&pdev->dev, "vdd_pronto_pll"); if (IS_ERR(drv->vreg)) { dev_err(&pdev->dev, "failed to get pronto pll supply"); return PTR_ERR(drv->vreg); } ret = regulator_set_voltage(drv->vreg, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll supply voltage\n"); return ret; } ret = regulator_set_optimum_mode(drv->vreg, 18000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll supply mode\n"); return ret; } drv->cxo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->cxo)) return PTR_ERR(drv->cxo); scm_pas_init(MSM_BUS_MASTER_CRYPTO_CORE0); ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = desc->name; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.shutdown = wcnss_shutdown; drv->subsys_desc.powerup = wcnss_powerup; drv->subsys_desc.ramdump = wcnss_ramdump; drv->subsys_desc.crash_shutdown = crash_shutdown; drv->subsys_desc.start = pronto_start; drv->subsys_desc.stop = pronto_stop; drv->subsys_desc.err_fatal_handler = wcnss_err_fatal_intr_handler; drv->subsys_desc.wdog_bite_handler = wcnss_wdog_bite_irq_hdlr; INIT_DELAYED_WORK(&drv->cancel_vote_work, wcnss_post_bootup); INIT_WORK(&drv->wcnss_wdog_bite_work, wcnss_wdog_bite_work_hdlr); //S [VY52/VY55][bug_1807] Frank_Chan add INIT_DELAYED_WORK(&drv->subsys_crash_work, wcnss_subsys_crash_info); //E [VY52/VY55][bug_1807] Frank_Chan add drv->subsys = subsys_register(&drv->subsys_desc); if (IS_ERR(drv->subsys)) { ret = PTR_ERR(drv->subsys); goto err_subsys; } drv->ramdump_dev = create_ramdump_device("pronto", &pdev->dev); if (!drv->ramdump_dev) { ret = -ENOMEM; goto err_irq; } /* Initialize common_ss GDSCR to wait 4 cycles between states */ regval = readl_relaxed(drv->base + PRONTO_PMU_COMMON_GDSCR) & PRONTO_PMU_COMMON_GDSCR_SW_COLLAPSE; regval |= (2 << EN_REST_WAIT) | (2 << EN_FEW_WAIT) | (2 << CLK_DIS_WAIT); writel_relaxed(regval, drv->base + PRONTO_PMU_COMMON_GDSCR); return 0; err_irq: subsys_unregister(drv->subsys); err_subsys: pil_desc_release(desc); return ret; }
static int __devinit pil_lpass_driver_probe(struct platform_device *pdev) { struct lpass_data *drv; struct q6v5_data *q6; 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); q6 = pil_q6v5_init(pdev); if (IS_ERR(q6)) return PTR_ERR(q6); drv->q6 = q6; desc = &q6->desc; desc->owner = THIS_MODULE; desc->proxy_timeout = PROXY_TIMEOUT_MS; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "restart_reg"); q6->restart_reg = devm_request_and_ioremap(&pdev->dev, res); if (!q6->restart_reg) return -ENOMEM; q6->core_clk = devm_clk_get(&pdev->dev, "core_clk"); if (IS_ERR(q6->core_clk)) return PTR_ERR(q6->core_clk); q6->ahb_clk = devm_clk_get(&pdev->dev, "iface_clk"); if (IS_ERR(q6->ahb_clk)) return PTR_ERR(q6->ahb_clk); q6->axi_clk = devm_clk_get(&pdev->dev, "bus_clk"); if (IS_ERR(q6->axi_clk)) return PTR_ERR(q6->axi_clk); q6->reg_clk = devm_clk_get(&pdev->dev, "reg_clk"); if (IS_ERR(q6->reg_clk)) return PTR_ERR(q6->reg_clk); if (pas_supported(PAS_Q6) > 0) { desc->ops = &pil_lpass_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_lpass_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } scm_pas_init(MSM_BUS_MASTER_CRYPTO_CORE0); ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = desc->name; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.shutdown = adsp_shutdown; drv->subsys_desc.powerup = adsp_powerup; drv->subsys_desc.ramdump = adsp_ramdump; drv->subsys_desc.crash_shutdown = adsp_crash_shutdown; drv->subsys_desc.err_fatal_handler = adsp_err_fatal_intr_handler; drv->subsys_desc.wdog_bite_handler = adsp_wdog_bite_irq; INIT_WORK(&drv->work, adsp_fatal_fn); drv->ramdump_dev = create_ramdump_device("adsp", &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; } lpass_status = kobject_create_and_add("audio_voice_service", kernel_kobj); if (!lpass_status) { pr_err("%s: kobject create failed\n", __func__); ret = -ENOMEM; goto err_create_kobj; } ret = sysfs_create_group(lpass_status, &attr_group); if (ret) { pr_err("%s: sysfs create group failed\n", __func__); goto err_kobj; } adsp_set_state("ONLINE"); return 0; err_kobj: kobject_put(lpass_status); err_create_kobj: subsys_unregister(drv->subsys); err_subsys: destroy_ramdump_device(drv->ramdump_dev); err_ramdump: pil_desc_release(desc); return ret; }
static int __devinit pil_q6v4_driver_probe(struct platform_device *pdev) { const struct pil_q6v4_pdata *pdata = pdev->dev.platform_data; struct q6v4_data *drv; struct resource *res; struct pil_desc *desc; int ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); 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->modem_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->modem_base) return -ENOMEM; } desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; drv->pll_supply = devm_regulator_get(&pdev->dev, "pll_vdd"); if (IS_ERR(drv->pll_supply)) { drv->pll_supply = NULL; } else { ret = regulator_set_voltage(drv->pll_supply, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll voltage\n"); return ret; } ret = regulator_set_optimum_mode(drv->pll_supply, 100000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll optimum mode\n"); return ret; } } desc->name = pdata->name; desc->depends_on = pdata->depends; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; if (pas_supported(pdata->pas_id) > 0) { desc->ops = &pil_q6v4_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_q6v4_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->vreg = devm_regulator_get(&pdev->dev, "core_vdd"); if (IS_ERR(drv->vreg)) return PTR_ERR(drv->vreg); ret = regulator_set_optimum_mode(drv->vreg, 100000); if (ret < 0) { dev_err(&pdev->dev, "Failed to set regulator's mode.\n"); return ret; } drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); if (pdata->xo1_id) { drv->xo1 = msm_xo_get(pdata->xo1_id, pdata->name); if (IS_ERR(drv->xo1)) return PTR_ERR(drv->xo1); } if (pdata->xo2_id) { drv->xo2 = msm_xo_get(pdata->xo2_id, pdata->name); if (IS_ERR(drv->xo2)) { msm_xo_put(drv->xo1); return PTR_ERR(drv->xo2); } } drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) { msm_xo_put(drv->xo2); msm_xo_put(drv->xo1); return PTR_ERR(drv->pil); } return 0; }
static int __devinit pil_riva_probe(struct platform_device *pdev) { struct riva_data *drv; struct resource *res; struct pil_desc *desc; int ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) return -ENOMEM; drv->pll_supply = 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); } ret = regulator_set_voltage(drv->pll_supply, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll supply voltage\n"); goto err; } ret = regulator_set_optimum_mode(drv->pll_supply, 100000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll supply optimum mode\n"); goto err; } desc->name = "wcnss"; desc->dev = &pdev->dev; if (pas_supported(PAS_RIVA) > 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"); } drv->xo = clk_get(&pdev->dev, "cxo"); if (IS_ERR(drv->xo)) { ret = PTR_ERR(drv->xo); goto err; } INIT_DELAYED_WORK(&drv->work, pil_riva_remove_proxy_votes); ret = msm_pil_register(desc); if (ret) goto err_register; return 0; err_register: cancel_delayed_work_sync(&drv->work); clk_put(drv->xo); err: regulator_put(drv->pll_supply); return ret; }
static int __devinit pil_pronto_probe(struct platform_device *pdev) { struct pronto_data *drv; struct resource *res; struct pil_desc *desc; int ret, err_fatal_gpio, irq; uint32_t regval; int clk_ready = of_get_named_gpio(pdev->dev.of_node, "qcom,gpio-proxy-unvote", 0); if (clk_ready < 0) return clk_ready; clk_ready = gpio_to_irq(clk_ready); if (clk_ready < 0) return clk_ready; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->irq = platform_get_irq(pdev, 0); if (drv->irq < 0) return drv->irq; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pmu_base"); drv->base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->base) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "clk_base"); drv->reset_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->reset_base) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base"); drv->axi_halt_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->axi_halt_base) return -ENOMEM; desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ret; err_fatal_gpio = of_get_named_gpio(pdev->dev.of_node, "qcom,gpio-err-fatal", 0); if (err_fatal_gpio < 0) return err_fatal_gpio; irq = gpio_to_irq(err_fatal_gpio); if (irq < 0) return irq; drv->err_fatal_irq = irq; drv->force_stop_gpio = of_get_named_gpio(pdev->dev.of_node, "qcom,gpio-force-stop", 0); if (drv->force_stop_gpio < 0) return drv->force_stop_gpio; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; desc->proxy_unvote_irq = clk_ready; if (pas_supported(PAS_WCNSS) > 0) { desc->ops = &pil_pronto_ops_trusted; dev_info(&pdev->dev, "using secure boot\n"); } else { desc->ops = &pil_pronto_ops; dev_info(&pdev->dev, "using non-secure boot\n"); } drv->vreg = devm_regulator_get(&pdev->dev, "vdd_pronto_pll"); if (IS_ERR(drv->vreg)) { dev_err(&pdev->dev, "failed to get pronto pll supply"); return PTR_ERR(drv->vreg); } ret = regulator_set_voltage(drv->vreg, 1800000, 1800000); if (ret) { dev_err(&pdev->dev, "failed to set pll supply voltage\n"); return ret; } ret = regulator_set_optimum_mode(drv->vreg, 18000); if (ret < 0) { dev_err(&pdev->dev, "failed to set pll supply mode\n"); return ret; } drv->cxo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->cxo)) return PTR_ERR(drv->cxo); ret = pil_desc_init(desc); if (ret) return ret; drv->subsys_desc.name = desc->name; drv->subsys_desc.dev = &pdev->dev; drv->subsys_desc.owner = THIS_MODULE; drv->subsys_desc.shutdown = wcnss_shutdown; drv->subsys_desc.powerup = wcnss_powerup; drv->subsys_desc.ramdump = wcnss_ramdump; drv->subsys_desc.crash_shutdown = crash_shutdown; drv->subsys_desc.start = pronto_start; drv->subsys_desc.stop = pronto_stop; ret = of_get_named_gpio(pdev->dev.of_node, "qcom,gpio-err-ready", 0); if (ret < 0) return ret; ret = gpio_to_irq(ret); if (ret < 0) return ret; drv->subsys_desc.err_ready_irq = ret; INIT_DELAYED_WORK(&drv->cancel_vote_work, wcnss_post_bootup); 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->irq, wcnss_wdog_bite_irq_hdlr, IRQF_TRIGGER_HIGH, "wcnss_wdog", drv); if (ret < 0) goto err_irq; ret = devm_request_irq(&pdev->dev, drv->err_fatal_irq, wcnss_err_fatal_intr_handler, IRQF_TRIGGER_RISING, "pil-pronto", drv); if (ret < 0) { dev_err(&pdev->dev, "Unable to register SMP2P err fatal handler!\n"); goto err_irq; } drv->ramdump_dev = create_ramdump_device("pronto", &pdev->dev); if (!drv->ramdump_dev) { ret = -ENOMEM; goto err_irq; } /* Initialize common_ss GDSCR to wait 4 cycles between states */ regval = readl_relaxed(drv->base + PRONTO_PMU_COMMON_GDSCR) & PRONTO_PMU_COMMON_GDSCR_SW_COLLAPSE; regval |= (2 << EN_REST_WAIT) | (2 << EN_FEW_WAIT) | (2 << CLK_DIS_WAIT); writel_relaxed(regval, drv->base + PRONTO_PMU_COMMON_GDSCR); return 0; err_irq: subsys_unregister(drv->subsys); err_subsys: pil_desc_release(desc); 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; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -EINVAL; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return -ENOMEM; platform_set_drvdata(pdev, drv); drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!desc) 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; } } 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"); } drv->xo = devm_clk_get(&pdev->dev, "cxo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) return PTR_ERR(drv->pil); return 0; }
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; }