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;
}
