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_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_mss_driver_probe(struct platform_device *pdev) { struct q6v5_data *drv; struct pil_desc *desc; struct resource *res; int ret; desc = pil_q6v5_init(pdev); if (IS_ERR(desc)) return PTR_ERR(desc); drv = platform_get_drvdata(pdev); if (drv == NULL) return -ENODEV; desc->ops = &pil_mss_ops; desc->owner = THIS_MODULE; desc->proxy_timeout = PROXY_TIMEOUT_MS; of_property_read_u32(pdev->dev.of_node, "qcom,pil-self-auth", &drv->self_auth); if (drv->self_auth) { res = platform_get_resource(pdev, IORESOURCE_MEM, 2); drv->rmb_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->rmb_base) return -ENOMEM; } res = platform_get_resource(pdev, IORESOURCE_MEM, 3); drv->restart_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->restart_reg) return -ENOMEM; drv->vreg = devm_regulator_get(&pdev->dev, "vdd_mss"); if (IS_ERR(drv->vreg)) return PTR_ERR(drv->vreg); ret = regulator_set_voltage(drv->vreg, 1150000, 1150000); if (ret) dev_err(&pdev->dev, "Failed to set regulator's voltage.\n"); 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->mem_clk = devm_clk_get(&pdev->dev, "mem_clk"); if (IS_ERR(drv->mem_clk)) return PTR_ERR(drv->mem_clk); drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) return PTR_ERR(drv->pil); return 0; }
static int __devinit pil_mba_driver_probe(struct platform_device *pdev) { struct mba_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); if (!res) return -EINVAL; drv->reg_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->reg_base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (res) { drv->metadata_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->metadata_base) return -ENOMEM; drv->metadata_phys = res->start; } desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL); if (!drv) return -ENOMEM; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ret; of_property_read_string(pdev->dev.of_node, "qcom,depends-on", &desc->depends_on); drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); desc->dev = &pdev->dev; desc->ops = &pil_mba_ops; desc->owner = THIS_MODULE; desc->proxy_timeout = PROXY_TIMEOUT_MS; drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) return PTR_ERR(drv->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 __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) { /* * Don't initialize PIL on simulated targets, as some * subsystems may not be emulated on them. */ if (machine_is_msm8960_sim() || machine_is_msm8960_rumi3()) return 0; use_secure_pil(); BUG_ON(platform_device_register(&pil_dsps)); BUG_ON(msm_pil_register(&pil_dsps_desc)); BUG_ON(platform_device_register(&pil_tzapps)); BUG_ON(msm_pil_register(&pil_tzapps_desc)); msm_riva_base = ioremap(MSM_RIVA_PHYS, SZ_256); if (!msm_riva_base) return -ENOMEM; BUG_ON(platform_device_register(&pil_riva)); BUG_ON(msm_pil_register(&pil_riva_desc)); 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_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_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_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_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_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 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 __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; }