static int __devinit exynos_dp_probe(struct platform_device *pdev) { struct resource *res; struct exynos_dp_device *dp; struct exynos_dp_platdata *pdata; int ret = 0; pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "no platform data\n"); return -EINVAL; } dp = devm_kzalloc(&pdev->dev, sizeof(struct exynos_dp_device), GFP_KERNEL); if (!dp) { dev_err(&pdev->dev, "no memory for device data\n"); return -ENOMEM; } dp->dev = &pdev->dev; dp->clock = devm_clk_get(&pdev->dev, "dp"); if (IS_ERR(dp->clock)) { dev_err(&pdev->dev, "failed to get clock\n"); return PTR_ERR(dp->clock); } clk_prepare_enable(dp->clock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); dp->reg_base = devm_request_and_ioremap(&pdev->dev, res); if (!dp->reg_base) { dev_err(&pdev->dev, "failed to ioremap\n"); return -ENOMEM; } dp->irq = platform_get_irq(pdev, 0); if (!dp->irq) { dev_err(&pdev->dev, "failed to get irq\n"); return -ENODEV; } ret = devm_request_irq(&pdev->dev, dp->irq, exynos_dp_irq_handler, 0, "exynos-dp", dp); if (ret) { dev_err(&pdev->dev, "failed to request irq\n"); return ret; } dp->video_info = pdata->video_info; if (pdata->phy_init) pdata->phy_init(); exynos_dp_init_dp(dp); ret = exynos_dp_detect_hpd(dp); if (ret) { dev_err(&pdev->dev, "unable to detect hpd\n"); return ret; } exynos_dp_handle_edid(dp); ret = exynos_dp_set_link_train(dp, dp->video_info->lane_count, dp->video_info->link_rate); if (ret) { dev_err(&pdev->dev, "unable to do link train\n"); return ret; } exynos_dp_enable_scramble(dp, 1); exynos_dp_enable_rx_to_enhanced_mode(dp, 1); exynos_dp_enable_enhanced_mode(dp, 1); exynos_dp_set_lane_count(dp, dp->video_info->lane_count); exynos_dp_set_link_bandwidth(dp, dp->video_info->link_rate); exynos_dp_init_video(dp); ret = exynos_dp_config_video(dp, dp->video_info); if (ret) { dev_err(&pdev->dev, "unable to config video\n"); return ret; } platform_set_drvdata(pdev, dp); return 0; }
static int pxa3xx_gcu_probe(struct platform_device *pdev) { int i, ret, irq; struct resource *r; struct pxa3xx_gcu_priv *priv; struct device *dev = &pdev->dev; priv = devm_kzalloc(dev, sizeof(struct pxa3xx_gcu_priv), GFP_KERNEL); if (!priv) return -ENOMEM; init_waitqueue_head(&priv->wait_idle); init_waitqueue_head(&priv->wait_free); spin_lock_init(&priv->spinlock); /* we allocate the misc device structure as part of our own allocation, * so we can get a pointer to our priv structure later on with * container_of(). This isn't really necessary as we have a fixed minor * number anyway, but this is to avoid statics. */ priv->misc_dev.minor = MISCDEV_MINOR, priv->misc_dev.name = DRV_NAME, priv->misc_dev.fops = &pxa3xx_gcu_miscdev_fops; /* handle IO resources */ r = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->mmio_base = devm_request_and_ioremap(dev, r); if (IS_ERR(priv->mmio_base)) { dev_err(dev, "failed to map I/O memory\n"); return PTR_ERR(priv->mmio_base); } /* enable the clock */ priv->clk = devm_clk_get(dev, NULL); if (IS_ERR(priv->clk)) { dev_err(dev, "failed to get clock\n"); return PTR_ERR(priv->clk); } /* request the IRQ */ irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(dev, "no IRQ defined\n"); return -ENODEV; } ret = devm_request_irq(dev, irq, pxa3xx_gcu_handle_irq, 0, DRV_NAME, priv); if (ret < 0) { dev_err(dev, "request_irq failed\n"); return ret; } /* allocate dma memory */ priv->shared = dma_alloc_coherent(dev, SHARED_SIZE, &priv->shared_phys, GFP_KERNEL); if (!priv->shared) { dev_err(dev, "failed to allocate DMA memory\n"); return -ENOMEM; } /* register misc device */ ret = misc_register(&priv->misc_dev); if (ret < 0) { dev_err(dev, "misc_register() for minor %d failed\n", MISCDEV_MINOR); goto err_free_dma; } ret = clk_enable(priv->clk); if (ret < 0) { dev_err(dev, "failed to enable clock\n"); goto err_misc_deregister; } for (i = 0; i < 8; i++) { ret = pxa3xx_gcu_add_buffer(dev, priv); if (ret) { dev_err(dev, "failed to allocate DMA memory\n"); goto err_disable_clk; } } platform_set_drvdata(pdev, priv); priv->resource_mem = r; pxa3xx_gcu_reset(priv); pxa3xx_gcu_init_debug_timer(); dev_info(dev, "registered @0x%p, DMA 0x%p (%d bytes), IRQ %d\n", (void *) r->start, (void *) priv->shared_phys, SHARED_SIZE, irq); return 0; err_free_dma: dma_free_coherent(dev, SHARED_SIZE, priv->shared, priv->shared_phys); err_misc_deregister: misc_deregister(&priv->misc_dev); err_disable_clk: clk_disable(priv->clk); return ret; }
static int mxs_saif_probe(struct platform_device *pdev) { struct resource *iores, *dmares; struct mxs_saif *saif; struct mxs_saif_platform_data *pdata; int ret = 0; if (pdev->id >= ARRAY_SIZE(mxs_saif)) return -EINVAL; saif = devm_kzalloc(&pdev->dev, sizeof(*saif), GFP_KERNEL); if (!saif) return -ENOMEM; mxs_saif[pdev->id] = saif; saif->id = pdev->id; pdata = pdev->dev.platform_data; if (pdata && !pdata->master_mode) { saif->master_id = pdata->master_id; if (saif->master_id < 0 || saif->master_id >= ARRAY_SIZE(mxs_saif) || saif->master_id == saif->id) { dev_err(&pdev->dev, "get wrong master id\n"); return -EINVAL; } } else { saif->master_id = saif->id; } saif->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(saif->clk)) { ret = PTR_ERR(saif->clk); dev_err(&pdev->dev, "Cannot get the clock: %d\n", ret); return ret; } iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); saif->base = devm_request_and_ioremap(&pdev->dev, iores); if (!saif->base) { dev_err(&pdev->dev, "ioremap failed\n"); ret = -ENODEV; goto failed_get_resource; } dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0); if (!dmares) { ret = -ENODEV; dev_err(&pdev->dev, "failed to get dma resource: %d\n", ret); goto failed_get_resource; } saif->dma_param.chan_num = dmares->start; saif->irq = platform_get_irq(pdev, 0); if (saif->irq < 0) { ret = saif->irq; dev_err(&pdev->dev, "failed to get irq resource: %d\n", ret); goto failed_get_resource; } saif->dev = &pdev->dev; ret = devm_request_irq(&pdev->dev, saif->irq, mxs_saif_irq, 0, "mxs-saif", saif); if (ret) { dev_err(&pdev->dev, "failed to request irq\n"); goto failed_get_resource; } saif->dma_param.chan_irq = platform_get_irq(pdev, 1); if (saif->dma_param.chan_irq < 0) { ret = saif->dma_param.chan_irq; dev_err(&pdev->dev, "failed to get dma irq resource: %d\n", ret); goto failed_get_resource; } platform_set_drvdata(pdev, saif); ret = snd_soc_register_dai(&pdev->dev, &mxs_saif_dai); if (ret) { dev_err(&pdev->dev, "register DAI failed\n"); goto failed_get_resource; } saif->soc_platform_pdev = platform_device_alloc( "mxs-pcm-audio", pdev->id); if (!saif->soc_platform_pdev) { ret = -ENOMEM; goto failed_pdev_alloc; } platform_set_drvdata(saif->soc_platform_pdev, saif); ret = platform_device_add(saif->soc_platform_pdev); if (ret) { dev_err(&pdev->dev, "failed to add soc platform device\n"); goto failed_pdev_add; } return 0; failed_pdev_add: platform_device_put(saif->soc_platform_pdev); failed_pdev_alloc: snd_soc_unregister_dai(&pdev->dev); failed_get_resource: clk_put(saif->clk); return ret; }
static int c_can_plat_probe(struct platform_device *pdev) { int ret; void __iomem *addr; struct rtcan_device *dev; struct c_can_priv *priv; const struct of_device_id *match; const struct platform_device_id *id; struct pinctrl *pinctrl; struct resource *mem, *res; int irq; struct clk *clk; if (pdev->dev.of_node) { match = of_match_device(c_can_of_table, &pdev->dev); if (!match) { dev_err(&pdev->dev, "Failed to find matching dt id\n"); ret = -EINVAL; goto exit; } id = match->data; } else { id = platform_get_device_id(pdev); } pinctrl = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR(pinctrl)) dev_warn(&pdev->dev, "failed to configure pins from driver\n"); /* get the appropriate clk */ clk = clk_get(&pdev->dev, NULL); if (IS_ERR(clk)) { dev_err(&pdev->dev, "no clock defined\n"); ret = -ENODEV; goto exit; } dev_info(&pdev->dev, "setting up step 1: platform_get_resource\n"); /* get the platform data */ mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); irq = platform_get_irq(pdev, 0); if (!mem || irq <= 0) { ret = -ENODEV; goto exit_free_clk; } dev_info(&pdev->dev, "setting up step 2: request mem region. Start %x, size %d\n", mem->start, resource_size(mem)); if (!request_mem_region(mem->start, resource_size(mem), "c_can")) { dev_err(&pdev->dev, "resource unavailable\n"); ret = -ENODEV; goto exit_free_clk; } dev_info(&pdev->dev, "setting up step 3: ioremap. Start %x, size %d\n", mem->start, resource_size(mem)); addr = ioremap(mem->start, resource_size(mem)); if (!addr) { dev_err(&pdev->dev, "failed to map can port\n"); ret = -ENOMEM; goto exit_release_mem; } dev_info(&pdev->dev, "alloc dev...\n"); /* allocate the c_can device */ dev = alloc_c_can_dev(); if (!dev) { ret = -ENOMEM; goto exit_iounmap; } priv = rtcan_priv(dev); switch (id->driver_data) { case BOSCH_C_CAN: priv->regs = reg_map_c_can; switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) { case IORESOURCE_MEM_32BIT: priv->read_reg = c_can_plat_read_reg_aligned_to_32bit; priv->write_reg = c_can_plat_write_reg_aligned_to_32bit; break; case IORESOURCE_MEM_16BIT: default: priv->read_reg = c_can_plat_read_reg_aligned_to_16bit; priv->write_reg = c_can_plat_write_reg_aligned_to_16bit; break; } break; case BOSCH_D_CAN: priv->regs = reg_map_d_can; priv->read_reg = c_can_plat_read_reg_aligned_to_16bit; priv->write_reg = c_can_plat_write_reg_aligned_to_16bit; if (pdev->dev.of_node) priv->instance = of_alias_get_id(pdev->dev.of_node, "d_can"); else priv->instance = pdev->id; dev_info(&pdev->dev, "platform_get_resource...\n"); res = platform_get_resource(pdev, IORESOURCE_MEM, 1); dev_info(&pdev->dev, "devm request and ioremap..\n"); priv->raminit_ctrlreg = devm_request_and_ioremap(&pdev->dev, res); if (!priv->raminit_ctrlreg || priv->instance < 0) dev_info(&pdev->dev, "control memory is not used for raminit\n"); else priv->raminit = c_can_hw_raminit; break; default: ret = -EINVAL; goto exit_free_device; } priv->irq = irq; priv->base = addr; priv->device = &pdev->dev; priv->priv = clk; priv->type = id->driver_data; platform_set_drvdata(pdev, dev); dev->ctrl_name = c_can_ctrl_name; dev->board_name = my_board_name; dev->base_addr = (unsigned long)addr; dev->can_sys_clock = clk_get_rate(clk); dev->hard_start_xmit = c_can_start_xmit; dev->do_set_mode = c_can_set_mode; dev->do_set_bit_time = c_can_save_bit_time; dev->bittiming_const = &c_can_bittiming_const; dev->state = CAN_STATE_STOPPED; /* Give device an interface name */ strncpy(dev->name, DEV_NAME, IFNAMSIZ); ret = register_c_candev(dev); if (ret) { dev_err(&pdev->dev, "registering %s failed (err=%d)\n", "c_can", ret); goto exit_free_device; } dev_info(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n", "c_can", priv->base, priv->irq); return 0; exit_free_device: platform_set_drvdata(pdev, NULL); exit_iounmap: iounmap(addr); exit_release_mem: release_mem_region(mem->start, resource_size(mem)); exit_free_clk: clk_put(clk); exit: dev_err(&pdev->dev, "probe failed\n"); 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; } scm_pas_init(MSM_BUS_MASTER_SPS); 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 jpeg_probe(struct platform_device *pdev) { struct jpeg_dev *jpeg; struct resource *res; int i, ret; jpeg = devm_kzalloc(&pdev->dev, sizeof(struct jpeg_dev), GFP_KERNEL); if (!jpeg) { dev_err(&pdev->dev, "%s: not enough memory\n", __func__); return -ENOMEM; } ret = of_property_read_u32(pdev->dev.of_node, "ip_ver", &jpeg->ver); if (ret) { dev_err(&pdev->dev, "%s: ip_ver doesn't exist\n", __func__); return -EINVAL; } jpeg->dev = &pdev->dev; spin_lock_init(&jpeg->slock); /* Get memory resource and map SFR region. */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); jpeg->regs = devm_request_and_ioremap(&pdev->dev, res); if (jpeg->regs == NULL) { dev_err(&pdev->dev, "failed to claim register region\n"); return -ENOENT; } /* Get IRQ resource and register IRQ handler. */ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res) { dev_err(&pdev->dev, "failed to get IRQ resource\n"); return -ENXIO; } /* Get memory resource and map SFR region. */ ret = devm_request_irq(&pdev->dev, res->start, (void *)jpeg_irq_handler, 0, pdev->name, jpeg); if (ret) { dev_err(&pdev->dev, "failed to install irq\n"); return ret; } /* clock */ for (i = 0; i < JPEG_CLK_NUM; i++) jpeg->clocks[i] = ERR_PTR(-ENOENT); ret = jpeg_clk_get(jpeg); if (ret) return ret; jpeg->oneshot_dev = m2m1shot_create_device(&pdev->dev, &jpeg_oneshot_ops, "jpeg", pdev->id, -1); if (IS_ERR(jpeg->oneshot_dev)) { pr_err("%s: Failed to create m2m1shot device\n", __func__); ret = PTR_ERR(jpeg->oneshot_dev); goto err_m2m1shot; } platform_set_drvdata(pdev, jpeg); ret = exynos_create_iovmm(&pdev->dev, 3, 3); if (ret) { dev_err(&pdev->dev, "%s: Failed(%d) to create IOVMM\n", __func__, ret); goto err_iovmm; } ret = iovmm_activate(&pdev->dev); if (ret) { dev_err(&pdev->dev, "%s: Failed(%d) to activate IOVMM\n", __func__, ret); /* nothing to do for exynos_create_iovmm() */ goto err_iovmm; } iovmm_set_fault_handler(&pdev->dev, jpeg_sysmmu_fault_handler, jpeg); pm_runtime_enable(&pdev->dev); if (!IS_ENABLED(CONFIG_PM_RUNTIME)) { jpeg_clock_gating(jpeg, true); set_bit(DEV_RUNTIME_RESUME, &jpeg->state); } dev_info(&pdev->dev, "JPEG driver register successfully"); return 0; err_iovmm: m2m1shot_destroy_device(jpeg->oneshot_dev); err_m2m1shot: jpeg_clk_put(jpeg); return ret; }
static int hdmi_probe(struct platform_device *pdev) { struct s5p_hdmi_platdata *pdata = NULL; struct device *dev = &pdev->dev; struct resource *res; struct i2c_adapter *phy_adapter; struct hdmi_device *hdmi_dev = NULL; struct hdmi_driver_data *drv_data; int ret; dev_info(dev, "probe start\n"); hdmi_dev = devm_kzalloc(&pdev->dev, sizeof(struct hdmi_device), GFP_KERNEL); if (!hdmi_dev) { dev_err(&pdev->dev, "no memory for hdmi device\n"); return -ENOMEM; } hdmi_dev->dev = dev; hdmi_dev->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!hdmi_dev->pdata) { dev_err(&pdev->dev, "no memory for state\n"); return -ENOMEM; } /* store platform data ptr to mixer context */ if (dev->of_node) { of_property_read_u32(dev->of_node, "ip_ver", &hdmi_dev->pdata->ip_ver); pdata = hdmi_dev->pdata; } else { hdmi_dev->pdata = dev->platform_data; pdata = hdmi_dev->pdata; } dev_info(dev, "HDMI ip version %d\n", pdata->ip_ver); /* mapping HDMI registers */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(dev, "get hdmi memory resource failed.\n"); return -ENXIO; } hdmi_dev->regs = devm_request_and_ioremap(&pdev->dev, res); if (hdmi_dev->regs == NULL) { dev_err(dev, "failed to claim register region for hdmi\n"); return -ENOENT; } /* mapping HDMIPHY_APB registers */ res = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (!res) { dev_err(dev, "get hdmiphy memory resource failed.\n"); return -ENXIO; } hdmi_dev->phy_regs = devm_request_and_ioremap(&pdev->dev, res); if (hdmi_dev->phy_regs == NULL) { dev_err(dev, "failed to claim register region for hdmiphy\n"); return -ENOENT; } /* Internal hpd */ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!res) { dev_err(dev, "get internal interrupt resource failed.\n"); return -ENXIO; } ret = devm_request_irq(dev, res->start, hdmi_irq_handler, 0, "hdmi-int", hdmi_dev); if (ret) { dev_err(dev, "request int interrupt failed.\n"); return ret; } else { hdmi_dev->int_irq = res->start; disable_irq(hdmi_dev->int_irq); dev_info(dev, "success request hdmi-int irq\n"); } /* setting v4l2 name to prevent WARN_ON in v4l2_device_register */ strlcpy(hdmi_dev->v4l2_dev.name, dev_name(dev), sizeof(hdmi_dev->v4l2_dev.name)); /* passing NULL owner prevents driver from erasing drvdata */ ret = v4l2_device_register(NULL, &hdmi_dev->v4l2_dev); if (ret) { dev_err(dev, "could not register v4l2 device.\n"); goto fail; } INIT_WORK(&hdmi_dev->hpd_work, hdmi_hpd_work); INIT_DELAYED_WORK(&hdmi_dev->hpd_work_ext, hdmi_hpd_work_ext); /* setting the clocks */ ret = hdmi_resources_init(hdmi_dev); if (ret) goto fail_vdev; /* setting the GPIO */ ret = hdmi_set_gpio(hdmi_dev); if (ret) { dev_err(dev, "failed to get GPIO\n"); goto fail_clk; } /* External hpd */ hdmi_dev->ext_irq = gpio_to_irq(hdmi_dev->res.gpio_hpd); ret = devm_request_irq(dev, hdmi_dev->ext_irq, hdmi_irq_handler_ext, IRQ_TYPE_EDGE_BOTH, "hdmi-ext", hdmi_dev); if (ret) { dev_err(dev, "request ext interrupt failed.\n"); goto fail_gpio; } else { dev_info(dev, "success request hdmi-ext irq\n"); } hdmi_dev->hpd_switch.name = "hdmi"; ret = switch_dev_register(&hdmi_dev->hpd_switch); if (ret) { dev_err(dev, "request switch class failed.\n"); goto fail_gpio; } mutex_init(&hdmi_dev->mutex); if (soc_is_exynos5250()) { drv_data = (struct hdmi_driver_data *) platform_get_device_id(pdev)->driver_data; dev_info(dev, "hdmiphy i2c bus number = %d\n", drv_data->hdmiphy_bus); phy_adapter = i2c_get_adapter(drv_data->hdmiphy_bus); if (phy_adapter == NULL) { dev_err(dev, "adapter request failed\n"); ret = -ENXIO; goto fail_switch; } hdmi_dev->phy_sd = v4l2_i2c_new_subdev_board(&hdmi_dev->v4l2_dev, phy_adapter, &hdmiphy_info, NULL); /* on failure or not adapter is no longer useful */ i2c_put_adapter(phy_adapter); if (hdmi_dev->phy_sd == NULL) { dev_err(dev, "missing subdev for hdmiphy\n"); ret = -ENODEV; goto fail_switch; } } hdmi_dev->cur_timings = hdmi_conf[HDMI_DEFAULT_TIMINGS_IDX].dv_timings; /* FIXME: missing fail preset is not supported */ hdmi_dev->cur_conf = hdmi_conf[HDMI_DEFAULT_TIMINGS_IDX].conf; /* default audio configuration : enable audio */ hdmi_dev->audio_enable = 1; hdmi_dev->audio_channel_count = 2; hdmi_dev->sample_rate = DEFAULT_SAMPLE_RATE; hdmi_dev->color_range = HDMI_RGB709_0_255; hdmi_dev->bits_per_sample = DEFAULT_BITS_PER_SAMPLE; hdmi_dev->audio_codec = DEFAULT_AUDIO_CODEC; /* default aspect ratio is 16:9 */ hdmi_dev->aspect = HDMI_ASPECT_RATIO_16_9; /* default HDMI streaming is stoped */ hdmi_dev->streaming = HDMI_STOP; /* register hdmi subdev as entity */ ret = hdmi_register_entity(hdmi_dev); if (ret) goto fail_switch; hdmi_entity_info_print(hdmi_dev); pm_runtime_enable(dev); /* initialize hdcp resource */ ret = hdcp_prepare(hdmi_dev); if (ret) goto fail_switch; /* work after booting */ queue_delayed_work(system_nrt_wq, &hdmi_dev->hpd_work_ext, msecs_to_jiffies(1500)); /* TODO : Check the PHY power off is implemented at pm_domains * If not, PHY power off should be applied at here */ dev_info(dev, "probe sucessful\n"); hdmi_debugfs_init(hdmi_dev); return 0; fail_switch: switch_dev_unregister(&hdmi_dev->hpd_switch); mutex_destroy(&hdmi_dev->mutex); fail_gpio: gpio_free(hdmi_dev->res.gpio_hpd); gpio_free(hdmi_dev->res.gpio_ls); gpio_free(hdmi_dev->res.gpio_dcdc); fail_clk: hdmi_resources_cleanup(hdmi_dev); fail_vdev: v4l2_device_unregister(&hdmi_dev->v4l2_dev); fail: dev_err(dev, "probe failed\n"); return ret; }
static int rotator_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct rot_context *rot; struct exynos_drm_ippdrv *ippdrv; int ret; rot = devm_kzalloc(dev, sizeof(*rot), GFP_KERNEL); if (!rot) { dev_err(dev, "failed to allocate rot\n"); return -ENOMEM; } rot->limit_tbl = (struct rot_limit_table *) platform_get_device_id(pdev)->driver_data; rot->regs_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); rot->regs = devm_request_and_ioremap(dev, rot->regs_res); if (!rot->regs) { dev_err(dev, "failed to map register\n"); return -ENXIO; } rot->irq = platform_get_irq(pdev, 0); if (rot->irq < 0) { dev_err(dev, "failed to get irq\n"); return rot->irq; } ret = request_threaded_irq(rot->irq, NULL, rotator_irq_handler, IRQF_ONESHOT, "drm_rotator", rot); if (ret < 0) { dev_err(dev, "failed to request irq\n"); return ret; } rot->clock = devm_clk_get(dev, "rotator"); if (IS_ERR_OR_NULL(rot->clock)) { dev_err(dev, "failed to get clock\n"); ret = PTR_ERR(rot->clock); goto err_clk_get; } pm_runtime_enable(dev); ippdrv = &rot->ippdrv; ippdrv->dev = dev; ippdrv->ops[EXYNOS_DRM_OPS_SRC] = &rot_src_ops; ippdrv->ops[EXYNOS_DRM_OPS_DST] = &rot_dst_ops; ippdrv->check_property = rotator_ippdrv_check_property; ippdrv->start = rotator_ippdrv_start; ret = rotator_init_prop_list(ippdrv); if (ret < 0) { dev_err(dev, "failed to init property list.\n"); goto err_ippdrv_register; } DRM_DEBUG_KMS("%s:ippdrv[0x%x]\n", __func__, (int)ippdrv); platform_set_drvdata(pdev, rot); ret = exynos_drm_ippdrv_register(ippdrv); if (ret < 0) { dev_err(dev, "failed to register drm rotator device\n"); goto err_ippdrv_register; } dev_info(dev, "The exynos rotator is probed successfully\n"); return 0; err_ippdrv_register: devm_kfree(dev, ippdrv->prop_list); pm_runtime_disable(dev); err_clk_get: free_irq(rot->irq, rot); return ret; }
static int dsps_create_musb_pdev(struct dsps_glue *glue, u8 id) { struct device *dev = glue->dev; struct platform_device *pdev = to_platform_device(dev); struct musb_hdrc_platform_data *pdata = dev->platform_data; struct device_node *np = pdev->dev.of_node; struct musb_hdrc_config *config; struct platform_device *musb; struct resource *res; struct resource resources[2]; char res_name[11]; int ret; resources[0].start = dsps_control_module_phys[id]; resources[0].end = resources[0].start + SZ_4 - 1; resources[0].flags = IORESOURCE_MEM; glue->usb_ctrl[id] = devm_request_and_ioremap(&pdev->dev, resources); if (glue->usb_ctrl[id] == NULL) { dev_err(dev, "Failed to obtain usb_ctrl%d memory\n", id); ret = -ENODEV; goto err0; } /* first resource is for usbss, so start index from 1 */ res = platform_get_resource(pdev, IORESOURCE_MEM, id + 1); if (!res) { dev_err(dev, "failed to get memory for instance %d\n", id); ret = -ENODEV; goto err0; } res->parent = NULL; resources[0] = *res; /* first resource is for usbss, so start index from 1 */ res = platform_get_resource(pdev, IORESOURCE_IRQ, id + 1); if (!res) { dev_err(dev, "failed to get irq for instance %d\n", id); ret = -ENODEV; goto err0; } res->parent = NULL; resources[1] = *res; resources[1].name = "mc"; /* allocate the child platform device */ musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO); if (!musb) { dev_err(dev, "failed to allocate musb device\n"); ret = -ENOMEM; goto err0; } musb->dev.parent = dev; musb->dev.dma_mask = &musb_dmamask; musb->dev.coherent_dma_mask = musb_dmamask; glue->musb[id] = musb; ret = platform_device_add_resources(musb, resources, 2); if (ret) { dev_err(dev, "failed to add resources\n"); goto err2; } if (np) { pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { dev_err(&pdev->dev, "failed to allocate musb platfrom data\n"); ret = -ENOMEM; goto err2; } config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL); if (!config) { dev_err(&pdev->dev, "failed to allocate musb hdrc config\n"); goto err2; } of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps); of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits); snprintf(res_name, sizeof(res_name), "port%d-mode", id); of_property_read_u32(np, res_name, (u32 *)&pdata->mode); of_property_read_u32(np, "power", (u32 *)&pdata->power); config->multipoint = of_property_read_bool(np, "multipoint"); pdata->config = config; } pdata->platform_ops = &dsps_ops; ret = platform_device_add_data(musb, pdata, sizeof(*pdata)); if (ret) { dev_err(dev, "failed to add platform_data\n"); goto err2; } ret = platform_device_add(musb); if (ret) { dev_err(dev, "failed to register musb device\n"); goto err2; } return 0; err2: platform_device_put(musb); err0: return ret; }
static int __devinit fimc_lite_probe(struct platform_device *pdev) { struct flite_drvdata *drv_data = fimc_lite_get_drvdata(pdev); struct fimc_lite *fimc; struct resource *res; int ret; fimc = devm_kzalloc(&pdev->dev, sizeof(*fimc), GFP_KERNEL); if (!fimc) return -ENOMEM; fimc->index = pdev->id; fimc->variant = drv_data->variant[fimc->index]; fimc->pdev = pdev; init_waitqueue_head(&fimc->irq_queue); spin_lock_init(&fimc->slock); mutex_init(&fimc->lock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); fimc->regs = devm_request_and_ioremap(&pdev->dev, res); if (fimc->regs == NULL) { dev_err(&pdev->dev, "Failed to obtain io memory\n"); return -ENOENT; } res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (res == NULL) { dev_err(&pdev->dev, "Failed to get IRQ resource\n"); return -ENXIO; } ret = fimc_lite_clk_get(fimc); if (ret) return ret; ret = devm_request_irq(&pdev->dev, res->start, flite_irq_handler, 0, dev_name(&pdev->dev), fimc); if (ret) { dev_err(&pdev->dev, "Failed to install irq (%d)\n", ret); goto err_clk; } /* The video node will be created within the subdev's registered() op */ ret = fimc_lite_create_capture_subdev(fimc); if (ret) goto err_clk; platform_set_drvdata(pdev, fimc); pm_runtime_enable(&pdev->dev); ret = pm_runtime_get_sync(&pdev->dev); if (ret < 0) goto err_sd; fimc->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev); if (IS_ERR(fimc->alloc_ctx)) { ret = PTR_ERR(fimc->alloc_ctx); goto err_pm; } pm_runtime_put(&pdev->dev); dev_dbg(&pdev->dev, "FIMC-LITE.%d registered successfully\n", fimc->index); return 0; err_pm: pm_runtime_put(&pdev->dev); err_sd: fimc_lite_unregister_capture_subdev(fimc); err_clk: fimc_lite_clk_put(fimc); return ret; }
static int pil_femto_modem_desc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *node; struct femto_modem_data *drv; struct modem_pil_data *modem; struct pil_desc *mba_desc; struct resource *res; struct modem_data *mba; void __iomem *rmb; int ret; u32 id; bool skip_entry; if (!dev->of_node) { dev_err(dev, "%s: device tree information missing\n", __func__); return -ENODEV; } node = dev->of_node; if (dev->parent == NULL) { dev_err(dev, "%s: parent device missing\n", __func__); return -ENODEV; } drv = dev_get_drvdata(dev->parent); if (drv == NULL) { dev_err(dev, "%s: driver data not found in parent device\n", __func__); return -ENODEV; } /* Make sure there are not more modems than specified */ if (drv->disc_modems == drv->max_num_modems) { dev_err(dev, "%s: found more than max of %u modems.\n", __func__, drv->max_num_modems); return -EINVAL; } ret = of_property_read_u32(node, "qcom,modem-id", &id); if (ret) return ret; /* Sanity check id */ if (id > MAX_MODEM_ID) return -EINVAL; modem = &drv->modem[drv->disc_modems]; modem->id = id; /* Retrieve the RMB base */ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rmb_base"); rmb = devm_request_and_ioremap(dev, res); if (!rmb) return -ENOMEM; /* The q6 structure should always point to modem[0] RMB regs */ if (!modem->id && drv->q6) drv->q6->rmb_base = rmb; /* Retrieve the firmware name */ ret = of_property_read_string(node, "qcom,firmware-name", &modem->name); if (ret) return ret; /* Retrieve the maximum number of images for this modem */ ret = of_property_read_u32(node, "qcom,max-num-images", &modem->num_images); if (ret) return ret; /* Read the skip entry check flag */ skip_entry = of_property_read_bool(node, "qcom,pil-skip-entry-check"); /* Initialize the image attributes */ mba = &modem->image; mba->rmb_base = rmb; /* Why isn't there one descriptor per file? Because, the pil_desc_init * function has a built-in maximum of 10, meaning it will fail after 10 * descriptors have been allocated. Since there could be many more than * 10 images loaded by this driver, it is necessary to have only one * PIL descriptor per modem and reuse it for each image. */ mba_desc = &mba->desc; mba_desc->name = modem->name; mba_desc->dev = dev; mba_desc->ops = &pil_msa_femto_mba_ops; mba_desc->owner = THIS_MODULE; mba_desc->proxy_timeout = 0; mba_desc->flags = skip_entry ? PIL_SKIP_ENTRY_CHECK : 0; mba_desc->map_fw_mem = pil_femto_modem_map_fw_mem; mba_desc->unmap_fw_mem = pil_femto_modem_unmap_fw_mem; ret = pil_desc_init(mba_desc); if (ret) return ret; platform_set_drvdata(pdev, modem); /* Create the sysfs attributes */ ret = pil_femto_modem_desc_create_sysfs(drv, modem); if (ret) pil_desc_release(mba_desc); drv->disc_modems++; 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); 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 exynos_dp_probe(struct platform_device *pdev) { struct resource *res; struct exynos_dp_device *dp; struct exynos_dp_platdata *pdata; int ret = 0; dp = devm_kzalloc(&pdev->dev, sizeof(struct exynos_dp_device), GFP_KERNEL); if (!dp) { dev_err(&pdev->dev, "no memory for device data\n"); return -ENOMEM; } dp->dev = &pdev->dev; if (pdev->dev.of_node) { pdata = exynos_dp_dt_parse_pdata(&pdev->dev); if (IS_ERR(pdata)) return PTR_ERR(pdata); ret = exynos_dp_dt_parse_phydata(dp); if (ret) return ret; } else { pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "no platform data\n"); return -EINVAL; } } dp->clock = devm_clk_get(&pdev->dev, "dp"); if (IS_ERR(dp->clock)) { dev_err(&pdev->dev, "failed to get clock\n"); return PTR_ERR(dp->clock); } clk_prepare_enable(dp->clock); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); dp->reg_base = devm_request_and_ioremap(&pdev->dev, res); if (!dp->reg_base) { dev_err(&pdev->dev, "failed to ioremap\n"); return -ENOMEM; } dp->irq = platform_get_irq(pdev, 0); if (dp->irq == -ENXIO) { dev_err(&pdev->dev, "failed to get irq\n"); return -ENODEV; } INIT_WORK(&dp->hotplug_work, exynos_dp_hotplug); dp->video_info = pdata->video_info; if (pdev->dev.of_node) { if (dp->phy_addr) exynos_dp_phy_init(dp); } else { if (pdata->phy_init) pdata->phy_init(); } exynos_dp_init_dp(dp); ret = devm_request_irq(&pdev->dev, dp->irq, exynos_dp_irq_handler, 0, "exynos-dp", dp); if (ret) { dev_err(&pdev->dev, "failed to request irq\n"); return ret; } platform_set_drvdata(pdev, dp); return 0; }
struct q6v5_data *pil_q6v5_init(struct platform_device *pdev) { struct q6v5_data *drv; struct resource *res; struct pil_desc *desc; int ret; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return ERR_PTR(-ENOMEM); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "qdsp6_base"); drv->reg_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->reg_base) return ERR_PTR(-ENOMEM); desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ERR_PTR(ret); desc->dev = &pdev->dev; drv->qdsp6v5_2_0 = of_device_is_compatible(pdev->dev.of_node, "qcom,pil-femto-modem"); if (drv->qdsp6v5_2_0) return drv; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base"); if (res) { drv->axi_halt_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->axi_halt_base) { dev_err(&pdev->dev, "Failed to map axi_halt_base.\n"); return ERR_PTR(-ENOMEM); } } if (!drv->axi_halt_base) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_q6"); if (res) { drv->axi_halt_q6 = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->axi_halt_q6) { dev_err(&pdev->dev, "Failed to map axi_halt_q6.\n"); return ERR_PTR(-ENOMEM); } } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_modem"); if (res) { drv->axi_halt_mss = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->axi_halt_mss) { dev_err(&pdev->dev, "Failed to map axi_halt_mss.\n"); return ERR_PTR(-ENOMEM); } } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_nc"); if (res) { drv->axi_halt_nc = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->axi_halt_nc) { dev_err(&pdev->dev, "Failed to map axi_halt_nc.\n"); return ERR_PTR(-ENOMEM); } } } if (!(drv->axi_halt_base || (drv->axi_halt_q6 && drv->axi_halt_mss && drv->axi_halt_nc))) { dev_err(&pdev->dev, "halt bases for Q6 are not defined.\n"); return ERR_PTR(-EINVAL); } drv->qdsp6v55 = of_device_is_compatible(pdev->dev.of_node, "qcom,pil-q6v55-mss"); drv->qdsp6v56 = of_device_is_compatible(pdev->dev.of_node, "qcom,pil-q6v56-mss"); drv->non_elf_image = of_property_read_bool(pdev->dev.of_node, "qcom,mba-image-is-not-elf"); drv->override_acc = of_property_read_bool(pdev->dev.of_node, "qcom,override-acc"); drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return ERR_CAST(drv->xo); drv->vreg_cx = devm_regulator_get(&pdev->dev, "vdd_cx"); if (IS_ERR(drv->vreg_cx)) return ERR_CAST(drv->vreg_cx); drv->vreg_pll = devm_regulator_get(&pdev->dev, "vdd_pll"); if (!IS_ERR_OR_NULL(drv->vreg_pll)) { int voltage; ret = of_property_read_u32(pdev->dev.of_node, "qcom,vdd_pll", &voltage); if (ret) { dev_err(&pdev->dev, "Failed to find vdd_pll voltage.\n"); return ERR_PTR(ret); } ret = regulator_set_voltage(drv->vreg_pll, voltage, voltage); if (ret) { dev_err(&pdev->dev, "Failed to request vdd_pll voltage.\n"); return ERR_PTR(ret); } ret = regulator_set_optimum_mode(drv->vreg_pll, 10000); if (ret < 0) { dev_err(&pdev->dev, "Failed to set vdd_pll mode.\n"); return ERR_PTR(ret); } } else { drv->vreg_pll = NULL; } return drv; }
static int __devinit sdhci_s3c_probe(struct platform_device *pdev) { struct s3c_sdhci_platdata *pdata; struct sdhci_s3c_drv_data *drv_data; struct device *dev = &pdev->dev; struct sdhci_host *host; struct sdhci_s3c *sc; struct resource *res; int ret, irq, ptr, clks; if (!pdev->dev.platform_data) { dev_err(dev, "no device data specified\n"); return -ENOENT; } irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(dev, "no irq specified\n"); return irq; } host = sdhci_alloc_host(dev, sizeof(struct sdhci_s3c)); if (IS_ERR(host)) { dev_err(dev, "sdhci_alloc_host() failed\n"); return PTR_ERR(host); } pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { ret = -ENOMEM; goto err_io_clk; } memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata)); drv_data = sdhci_s3c_get_driver_data(pdev); sc = sdhci_priv(host); sc->host = host; sc->pdev = pdev; sc->pdata = pdata; sc->ext_cd_gpio = -1; /* invalid gpio number */ platform_set_drvdata(pdev, host); sc->clk_io = clk_get(dev, "hsmmc"); if (IS_ERR(sc->clk_io)) { dev_err(dev, "failed to get io clock\n"); ret = PTR_ERR(sc->clk_io); goto err_io_clk; } /* enable the local io clock and keep it running for the moment. */ clk_enable(sc->clk_io); for (clks = 0, ptr = 0; ptr < MAX_BUS_CLK; ptr++) { struct clk *clk; char name[14]; snprintf(name, 14, "mmc_busclk.%d", ptr); clk = clk_get(dev, name); if (IS_ERR(clk)) { continue; } clks++; sc->clk_bus[ptr] = clk; /* * save current clock index to know which clock bus * is used later in overriding functions. */ sc->cur_clk = ptr; clk_enable(clk); dev_info(dev, "clock source %d: %s (%ld Hz)\n", ptr, name, clk_get_rate(clk)); } if (clks == 0) { dev_err(dev, "failed to find any bus clocks\n"); ret = -ENOENT; goto err_no_busclks; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); host->ioaddr = devm_request_and_ioremap(&pdev->dev, res); if (!host->ioaddr) { dev_err(dev, "failed to map registers\n"); ret = -ENXIO; goto err_req_regs; } /* Ensure we have minimal gpio selected CMD/CLK/Detect */ if (pdata->cfg_gpio) pdata->cfg_gpio(pdev, pdata->max_width); host->hw_name = "samsung-hsmmc"; host->ops = &sdhci_s3c_ops; host->quirks = 0; host->irq = irq; /* Setup quirks for the controller */ host->quirks |= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC; host->quirks |= SDHCI_QUIRK_NO_HISPD_BIT; if (drv_data) host->quirks |= drv_data->sdhci_quirks; #ifndef CONFIG_MMC_SDHCI_S3C_DMA /* we currently see overruns on errors, so disable the SDMA * support as well. */ host->quirks |= SDHCI_QUIRK_BROKEN_DMA; #endif /* CONFIG_MMC_SDHCI_S3C_DMA */ /* It seems we do not get an DATA transfer complete on non-busy * transfers, not sure if this is a problem with this specific * SDHCI block, or a missing configuration that needs to be set. */ host->quirks |= SDHCI_QUIRK_NO_BUSY_IRQ; /* This host supports the Auto CMD12 */ host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; /* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */ host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC; if (pdata->cd_type == S3C_SDHCI_CD_NONE || pdata->cd_type == S3C_SDHCI_CD_PERMANENT) host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT) host->mmc->caps = MMC_CAP_NONREMOVABLE; switch (pdata->max_width) { case 8: host->mmc->caps |= MMC_CAP_8_BIT_DATA; case 4: host->mmc->caps |= MMC_CAP_4_BIT_DATA; break; } if (pdata->pm_caps) host->mmc->pm_caps |= pdata->pm_caps; host->quirks |= (SDHCI_QUIRK_32BIT_DMA_ADDR | SDHCI_QUIRK_32BIT_DMA_SIZE); /* HSMMC on Samsung SoCs uses SDCLK as timeout clock */ host->quirks |= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK; /* * If controller does not have internal clock divider, * we can use overriding functions instead of default. */ if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK) { sdhci_s3c_ops.set_clock = sdhci_cmu_set_clock; sdhci_s3c_ops.get_min_clock = sdhci_cmu_get_min_clock; sdhci_s3c_ops.get_max_clock = sdhci_cmu_get_max_clock; } /* It supports additional host capabilities if needed */ if (pdata->host_caps) host->mmc->caps |= pdata->host_caps; if (pdata->host_caps2) host->mmc->caps2 |= pdata->host_caps2; pm_runtime_enable(&pdev->dev); pm_runtime_set_autosuspend_delay(&pdev->dev, 50); pm_runtime_use_autosuspend(&pdev->dev); pm_suspend_ignore_children(&pdev->dev, 1); ret = sdhci_add_host(host); if (ret) { dev_err(dev, "sdhci_add_host() failed\n"); pm_runtime_forbid(&pdev->dev); pm_runtime_get_noresume(&pdev->dev); goto err_req_regs; } /* The following two methods of card detection might call sdhci_s3c_notify_change() immediately, so they can be called only after sdhci_add_host(). Setup errors are ignored. */ if (pdata->cd_type == S3C_SDHCI_CD_EXTERNAL && pdata->ext_cd_init) pdata->ext_cd_init(&sdhci_s3c_notify_change); if (pdata->cd_type == S3C_SDHCI_CD_GPIO && gpio_is_valid(pdata->ext_cd_gpio)) sdhci_s3c_setup_card_detect_gpio(sc); return 0; err_req_regs: for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) { if (sc->clk_bus[ptr]) { clk_disable(sc->clk_bus[ptr]); clk_put(sc->clk_bus[ptr]); } } err_no_busclks: clk_disable(sc->clk_io); clk_put(sc->clk_io); err_io_clk: sdhci_free_host(host); return ret; }
static int __devinit usb_hcd_nxp_probe(struct platform_device *pdev) { struct usb_hcd *hcd = 0; struct ohci_hcd *ohci; const struct hc_driver *driver = &ohci_nxp_hc_driver; struct resource *res; int ret = 0, irq; struct device_node *isp1301_node; if (pdev->dev.of_node) { isp1301_node = of_parse_phandle(pdev->dev.of_node, "transceiver", 0); } else { isp1301_node = NULL; } isp1301_i2c_client = isp1301_get_client(isp1301_node); if (!isp1301_i2c_client) { ret = -EPROBE_DEFER; goto out; } pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; dev_dbg(&pdev->dev, "%s: " DRIVER_DESC " (nxp)\n", hcd_name); if (usb_disabled()) { dev_err(&pdev->dev, "USB is disabled\n"); ret = -ENODEV; goto out; } /* Enable AHB slave USB clock, needed for further USB clock control */ __raw_writel(USB_SLAVE_HCLK_EN | PAD_CONTROL_LAST_DRIVEN, USB_CTRL); isp1301_configure(); /* Enable USB PLL */ usb_clk = clk_get(&pdev->dev, "ck_pll5"); if (IS_ERR(usb_clk)) { dev_err(&pdev->dev, "failed to acquire USB PLL\n"); ret = PTR_ERR(usb_clk); goto out1; } ret = clk_enable(usb_clk); if (ret < 0) { dev_err(&pdev->dev, "failed to start USB PLL\n"); goto out2; } ret = clk_set_rate(usb_clk, 48000); if (ret < 0) { dev_err(&pdev->dev, "failed to set USB clock rate\n"); goto out3; } __raw_writel(__raw_readl(USB_CTRL) | USB_HOST_NEED_CLK_EN, USB_CTRL); /* Set to enable all needed USB clocks */ __raw_writel(USB_CLOCK_MASK, USB_OTG_CLK_CTRL); while ((__raw_readl(USB_OTG_CLK_STAT) & USB_CLOCK_MASK) != USB_CLOCK_MASK) ; hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); if (!hcd) { dev_err(&pdev->dev, "Failed to allocate HC buffer\n"); ret = -ENOMEM; goto out3; } /* Set all USB bits in the Start Enable register */ nxp_set_usb_bits(); res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "Failed to get MEM resource\n"); ret = -ENOMEM; goto out4; } hcd->regs = devm_request_and_ioremap(&pdev->dev, res); if (!hcd->regs) { dev_err(&pdev->dev, "Failed to devm_request_and_ioremap\n"); ret = -ENOMEM; goto out4; } hcd->rsrc_start = res->start; hcd->rsrc_len = resource_size(res); irq = platform_get_irq(pdev, 0); if (irq < 0) { ret = -ENXIO; goto out4; } nxp_start_hc(); platform_set_drvdata(pdev, hcd); ohci = hcd_to_ohci(hcd); ohci_hcd_init(ohci); dev_info(&pdev->dev, "at 0x%p, irq %d\n", hcd->regs, hcd->irq); ret = usb_add_hcd(hcd, irq, 0); if (ret == 0) return ret; nxp_stop_hc(); out4: nxp_unset_usb_bits(); usb_put_hcd(hcd); out3: clk_disable(usb_clk); out2: clk_put(usb_clk); out1: isp1301_i2c_client = NULL; out: return ret; }
static int __init txx9ndfmc_probe(struct platform_device *dev) { struct txx9ndfmc_platform_data *plat = dev->dev.platform_data; int hold, spw; int i; struct txx9ndfmc_drvdata *drvdata; unsigned long gbusclk = plat->gbus_clock; struct resource *res; res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; drvdata = devm_kzalloc(&dev->dev, sizeof(*drvdata), GFP_KERNEL); if (!drvdata) return -ENOMEM; drvdata->base = devm_request_and_ioremap(&dev->dev, res); if (!drvdata->base) return -EBUSY; hold = plat->hold ?: 20; /* tDH */ spw = plat->spw ?: 90; /* max(tREADID, tWP, tRP) */ hold = TXX9NDFMC_NS_TO_CYC(gbusclk, hold); spw = TXX9NDFMC_NS_TO_CYC(gbusclk, spw); if (plat->flags & NDFMC_PLAT_FLAG_HOLDADD) hold -= 2; /* actual hold time : (HOLD + 2) BUSCLK */ spw -= 1; /* actual wait time : (SPW + 1) BUSCLK */ hold = clamp(hold, 1, 15); drvdata->hold = hold; spw = clamp(spw, 1, 15); drvdata->spw = spw; dev_info(&dev->dev, "CLK:%ldMHz HOLD:%d SPW:%d\n", (gbusclk + 500000) / 1000000, hold, spw); spin_lock_init(&drvdata->hw_control.lock); init_waitqueue_head(&drvdata->hw_control.wq); platform_set_drvdata(dev, drvdata); txx9ndfmc_initialize(dev); for (i = 0; i < MAX_TXX9NDFMC_DEV; i++) { struct txx9ndfmc_priv *txx9_priv; struct nand_chip *chip; struct mtd_info *mtd; if (!(plat->ch_mask & (1 << i))) continue; txx9_priv = kzalloc(sizeof(struct txx9ndfmc_priv), GFP_KERNEL); if (!txx9_priv) { dev_err(&dev->dev, "Unable to allocate " "TXx9 NDFMC MTD device structure.\n"); continue; } chip = &txx9_priv->chip; mtd = &txx9_priv->mtd; mtd->owner = THIS_MODULE; mtd->priv = chip; chip->read_byte = txx9ndfmc_read_byte; chip->read_buf = txx9ndfmc_read_buf; chip->write_buf = txx9ndfmc_write_buf; chip->verify_buf = txx9ndfmc_verify_buf; chip->cmd_ctrl = txx9ndfmc_cmd_ctrl; chip->dev_ready = txx9ndfmc_dev_ready; chip->ecc.calculate = txx9ndfmc_calculate_ecc; chip->ecc.correct = txx9ndfmc_correct_data; chip->ecc.hwctl = txx9ndfmc_enable_hwecc; chip->ecc.mode = NAND_ECC_HW; /* txx9ndfmc_nand_scan will overwrite ecc.size and ecc.bytes */ chip->ecc.size = 256; chip->ecc.bytes = 3; chip->ecc.strength = 1; chip->chip_delay = 100; chip->controller = &drvdata->hw_control; chip->priv = txx9_priv; txx9_priv->dev = dev; if (plat->ch_mask != 1) { txx9_priv->cs = i; txx9_priv->mtdname = kasprintf(GFP_KERNEL, "%s.%u", dev_name(&dev->dev), i); } else { txx9_priv->cs = -1; txx9_priv->mtdname = kstrdup(dev_name(&dev->dev), GFP_KERNEL); } if (!txx9_priv->mtdname) { kfree(txx9_priv); dev_err(&dev->dev, "Unable to allocate MTD name.\n"); continue; } if (plat->wide_mask & (1 << i)) chip->options |= NAND_BUSWIDTH_16; if (txx9ndfmc_nand_scan(mtd)) { kfree(txx9_priv->mtdname); kfree(txx9_priv); continue; } mtd->name = txx9_priv->mtdname; mtd_device_parse_register(mtd, NULL, NULL, NULL, 0); drvdata->mtds[i] = mtd; } return 0; }
static int __devinit mxs_saif_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct resource *iores, *dmares; struct mxs_saif *saif; struct mxs_saif_platform_data *pdata; struct pinctrl *pinctrl; int ret = 0; if (!np && pdev->id >= ARRAY_SIZE(mxs_saif)) return -EINVAL; saif = devm_kzalloc(&pdev->dev, sizeof(*saif), GFP_KERNEL); if (!saif) return -ENOMEM; if (np) { struct device_node *master; saif->id = of_alias_get_id(np, "saif"); if (saif->id < 0) return saif->id; /* * If there is no "fsl,saif-master" phandle, it's a saif * master. Otherwise, it's a slave and its phandle points * to the master. */ master = of_parse_phandle(np, "fsl,saif-master", 0); if (!master) { saif->master_id = saif->id; } else { saif->master_id = of_alias_get_id(master, "saif"); if (saif->master_id < 0) return saif->master_id; } } else { saif->id = pdev->id; pdata = pdev->dev.platform_data; if (pdata && !pdata->master_mode) saif->master_id = pdata->master_id; else saif->master_id = saif->id; } if (saif->master_id < 0 || saif->master_id >= ARRAY_SIZE(mxs_saif)) { dev_err(&pdev->dev, "get wrong master id\n"); return -EINVAL; } mxs_saif[saif->id] = saif; pinctrl = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR(pinctrl)) { ret = PTR_ERR(pinctrl); return ret; } saif->clk = clk_get(&pdev->dev, NULL); if (IS_ERR(saif->clk)) { ret = PTR_ERR(saif->clk); dev_err(&pdev->dev, "Cannot get the clock: %d\n", ret); return ret; } iores = platform_get_resource(pdev, IORESOURCE_MEM, 0); saif->base = devm_request_and_ioremap(&pdev->dev, iores); if (!saif->base) { dev_err(&pdev->dev, "ioremap failed\n"); ret = -ENODEV; goto failed_get_resource; } dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0); if (!dmares) { /* * TODO: This is a temporary solution and should be changed * to use generic DMA binding later when the helplers get in. */ ret = of_property_read_u32(np, "fsl,saif-dma-channel", &saif->dma_param.chan_num); if (ret) { dev_err(&pdev->dev, "failed to get dma channel\n"); goto failed_get_resource; } } else { saif->dma_param.chan_num = dmares->start; } saif->irq = platform_get_irq(pdev, 0); if (saif->irq < 0) { ret = saif->irq; dev_err(&pdev->dev, "failed to get irq resource: %d\n", ret); goto failed_get_resource; } saif->dev = &pdev->dev; ret = devm_request_irq(&pdev->dev, saif->irq, mxs_saif_irq, 0, "mxs-saif", saif); if (ret) { dev_err(&pdev->dev, "failed to request irq\n"); goto failed_get_resource; } saif->dma_param.chan_irq = platform_get_irq(pdev, 1); if (saif->dma_param.chan_irq < 0) { ret = saif->dma_param.chan_irq; dev_err(&pdev->dev, "failed to get dma irq resource: %d\n", ret); goto failed_get_resource; } platform_set_drvdata(pdev, saif); ret = snd_soc_register_dai(&pdev->dev, &mxs_saif_dai); if (ret) { dev_err(&pdev->dev, "register DAI failed\n"); goto failed_get_resource; } ret = mxs_pcm_platform_register(&pdev->dev); if (ret) { dev_err(&pdev->dev, "register PCM failed: %d\n", ret); goto failed_pdev_alloc; } return 0; failed_pdev_alloc: snd_soc_unregister_dai(&pdev->dev); failed_get_resource: clk_put(saif->clk); return ret; }
struct q6v5_data __devinit *pil_q6v5_init(struct platform_device *pdev) { struct q6v5_data *drv; struct resource *res; struct pil_desc *desc; int ret; drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL); if (!drv) return ERR_PTR(-ENOMEM); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "qdsp6_base"); drv->reg_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->reg_base) return ERR_PTR(-ENOMEM); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "halt_base"); if (!res) return ERR_PTR(-ENOMEM); drv->axi_halt_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->axi_halt_base) return ERR_PTR(-ENOMEM); desc = &drv->desc; ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name", &desc->name); if (ret) return ERR_PTR(ret); drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return ERR_CAST(drv->xo); drv->vreg_cx = devm_regulator_get(&pdev->dev, "vdd_cx"); if (IS_ERR(drv->vreg_cx)) return ERR_CAST(drv->vreg_cx); drv->vreg_pll = devm_regulator_get(&pdev->dev, "vdd_pll"); if (!IS_ERR(drv->vreg_pll)) { int voltage; ret = of_property_read_u32(pdev->dev.of_node, "qcom,vdd_pll", &voltage); if (ret) { dev_err(&pdev->dev, "Failed to find vdd_pll voltage.\n"); return ERR_PTR(ret); } ret = regulator_set_voltage(drv->vreg_pll, voltage, voltage); if (ret) { dev_err(&pdev->dev, "Failed to request vdd_pll voltage.\n"); return ERR_PTR(ret); } ret = regulator_set_optimum_mode(drv->vreg_pll, 10000); if (ret < 0) { dev_err(&pdev->dev, "Failed to set vdd_pll mode.\n"); return ERR_PTR(ret); } } else { drv->vreg_pll = NULL; } desc->dev = &pdev->dev; return drv; }
static int pil_mss_loadable_init(struct modem_data *drv, struct platform_device *pdev) { struct q6v5_data *q6; struct pil_desc *q6_desc; struct resource *res; struct property *prop; int ret; q6 = pil_q6v5_init(pdev); if (IS_ERR(q6)) return PTR_ERR(q6); drv->q6 = q6; drv->xo = q6->xo; q6_desc = &q6->desc; q6_desc->owner = THIS_MODULE; q6_desc->proxy_timeout = PROXY_TIMEOUT_MS; q6_desc->ops = &pil_msa_mss_ops; q6->self_auth = of_property_read_bool(pdev->dev.of_node, "qcom,pil-self-auth"); if (q6->self_auth) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rmb_base"); q6->rmb_base = devm_request_and_ioremap(&pdev->dev, res); if (!q6->rmb_base) return -ENOMEM; drv->rmb_base = q6->rmb_base; q6_desc->ops = &pil_msa_mss_ops_selfauth; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "restart_reg"); if (!res) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "restart_reg_sec"); q6->restart_reg_sec = true; } q6->restart_reg = devm_request_and_ioremap(&pdev->dev, res); if (!q6->restart_reg) return -ENOMEM; q6->vreg = NULL; prop = of_find_property(pdev->dev.of_node, "vdd_mss-supply", NULL); if (prop) { q6->vreg = devm_regulator_get(&pdev->dev, "vdd_mss"); if (IS_ERR(q6->vreg)) return PTR_ERR(q6->vreg); ret = regulator_set_voltage(q6->vreg, VDD_MSS_UV, MAX_VDD_MSS_UV); if (ret) dev_err(&pdev->dev, "Failed to set vreg voltage.\n"); ret = regulator_set_optimum_mode(q6->vreg, 100000); if (ret < 0) { dev_err(&pdev->dev, "Failed to set vreg mode.\n"); return ret; } } q6->vreg_mx = devm_regulator_get(&pdev->dev, "vdd_mx"); if (IS_ERR(q6->vreg_mx)) return PTR_ERR(q6->vreg_mx); prop = of_find_property(pdev->dev.of_node, "vdd_mx-uV", NULL); if (!prop) { dev_err(&pdev->dev, "Missing vdd_mx-uV property\n"); return -EINVAL; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cxrail_bhs_reg"); if (res) q6->cxrail_bhs = devm_ioremap(&pdev->dev, res->start, resource_size(res)); 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->rom_clk = devm_clk_get(&pdev->dev, "mem_clk"); if (IS_ERR(q6->rom_clk)) return PTR_ERR(q6->rom_clk); #ifdef VENDOR_EDIT /* [email protected] add QCM patch for 3G ram in 20150303*/ q6->mba_region = of_property_read_bool(pdev->dev.of_node, "qcom,pil-mba-region"); #endif ret = pil_desc_init(q6_desc); return ret; }
static int brcmstb_gisb_arb_probe(struct platform_device *pdev) { struct device_node *dn = pdev->dev.of_node; struct brcmstb_gisb_arb_device *gdev; struct resource *r; int err, timeout_irq, tea_irq; unsigned int num_masters, j = 0; int i, first, last; r = platform_get_resource(pdev, IORESOURCE_MEM, 0); timeout_irq = platform_get_irq(pdev, 0); tea_irq = platform_get_irq(pdev, 1); gdev = devm_kzalloc(&pdev->dev, sizeof(*gdev), GFP_KERNEL); if (!gdev) return -ENOMEM; mutex_init(&gdev->lock); INIT_LIST_HEAD(&gdev->next); gdev->base = devm_request_and_ioremap(&pdev->dev, r); if (!gdev->base) return -ENOMEM; err = devm_request_irq(&pdev->dev, timeout_irq, brcmstb_gisb_timeout_handler, 0, pdev->name, gdev); if (err < 0) return err; err = devm_request_irq(&pdev->dev, tea_irq, brcmstb_gisb_tea_handler, 0, pdev->name, gdev); if (err < 0) return err; /* If we do not have a valid mask, assume all masters are enabled */ if (of_property_read_u32(dn, "brcm,gisb-arb-master-mask", &gdev->valid_mask)) gdev->valid_mask = 0xffffffff; /* Proceed with reading the litteral names if we agree on the * number of masters */ num_masters = of_property_count_strings(dn, "brcm,gisb-arb-master-names"); if (hweight_long(gdev->valid_mask) == num_masters) { first = ffs(gdev->valid_mask) - 1; last = fls(gdev->valid_mask) - 1; for (i = first; i < last; i++) { if (!(gdev->valid_mask & BIT(i))) continue; of_property_read_string_index(dn, "brcm,gisb-arb-master-names", j, &gdev->master_names[i]); j++; } } err = sysfs_create_group(&pdev->dev.kobj, &gisb_arb_sysfs_attr_group); if (err) return err; platform_set_drvdata(pdev, gdev); list_add_tail(&gdev->next, &brcmstb_gisb_arb_device_list); dev_info(&pdev->dev, "registered mem: %p, irqs: %d, %d\n", gdev->base, timeout_irq, tea_irq); return 0; }
static int __devinit 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); drv->modem_base = devm_request_and_ioremap(&pdev->dev, res); if (!drv->modem_base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (!res) return -EINVAL; drv->cbase = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->cbase) return -ENOMEM; ret = pil_desc_init(&drv_fw->desc); if (ret) return ret; ret = pil_desc_init(&drv_sw->desc); if (ret) goto err_pil_sw; } 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.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", &pdev->dev); if (!drv->fw_ramdump_dev) { ret = -ENOMEM; goto err_fw_ramdump; } drv->sw_ramdump_dev = create_ramdump_device("modem_sw", &pdev->dev); if (!drv->sw_ramdump_dev) { ret = -ENOMEM; goto err_sw_ramdump; } drv->smem_ramdump_dev = create_ramdump_device("smem-modem", &pdev->dev); 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; } if (!drv->loadable) subsys_default_online(drv->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; disable_irq(drv_fw->wdog_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; disable_irq(drv_sw->wdog_irq); scm_pas_init(MSM_BUS_MASTER_SPS); 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) pil_desc_release(&drv_sw->desc); err_pil_sw: pil_desc_release(&drv_fw->desc); return ret; }
static int __devinit exynos_tmu_probe(struct platform_device *pdev) { struct exynos_tmu_data *data; struct exynos_tmu_platform_data *pdata = pdev->dev.platform_data; int ret, i; if (!pdata) pdata = exynos_get_driver_data(pdev); if (!pdata) { dev_err(&pdev->dev, "No platform init data supplied.\n"); return -ENODEV; } data = devm_kzalloc(&pdev->dev, sizeof(struct exynos_tmu_data), GFP_KERNEL); if (!data) { dev_err(&pdev->dev, "Failed to allocate driver structure\n"); return -ENOMEM; } data->irq = platform_get_irq(pdev, 0); if (data->irq < 0) { dev_err(&pdev->dev, "Failed to get platform irq\n"); return data->irq; } INIT_WORK(&data->irq_work, exynos_tmu_work); data->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!data->mem) { dev_err(&pdev->dev, "Failed to get platform resource\n"); return -ENOENT; } data->base = devm_request_and_ioremap(&pdev->dev, data->mem); if (!data->base) { dev_err(&pdev->dev, "Failed to ioremap memory\n"); return -ENODEV; } ret = devm_request_irq(&pdev->dev, data->irq, exynos_tmu_irq, IRQF_TRIGGER_RISING, "exynos-tmu", data); if (ret) { dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq); return ret; } data->regulator = regulator_get(&pdev->dev, "vdd_tmu"); if (IS_ERR(data->regulator)) { dev_err(&pdev->dev, "Failed to get regulator:vdd_tmu\n"); return PTR_ERR(data->regulator); } data->clk = clk_get(NULL, "tmu_apbif"); if (IS_ERR(data->clk)) { dev_err(&pdev->dev, "Failed to get clock\n"); goto err_reg; } if (pdata->type == SOC_ARCH_EXYNOS || pdata->type == SOC_ARCH_EXYNOS4210) data->soc = pdata->type; else { ret = -EINVAL; dev_err(&pdev->dev, "Platform not supported\n"); goto err_clk; } data->pdata = pdata; platform_set_drvdata(pdev, data); mutex_init(&data->lock); regulator_enable(data->regulator); ret = exynos_tmu_initialize(pdev); if (ret) { dev_err(&pdev->dev, "Failed to initialize TMU\n"); goto err_clk; } exynos_tmu_control(pdev, true); /* Register the sensor with thermal management interface */ (&exynos_sensor_conf)->private_data = data; exynos_sensor_conf.trip_data.trip_count = pdata->trigger_level0_en + pdata->trigger_level1_en + pdata->trigger_level2_en + pdata->trigger_level3_en; for (i = 0; i < exynos_sensor_conf.trip_data.trip_count; i++) exynos_sensor_conf.trip_data.trip_val[i] = pdata->threshold + pdata->trigger_levels[i]; exynos_sensor_conf.cooling_data.freq_clip_count = pdata->freq_tab_count; for (i = 0; i < pdata->freq_tab_count; i++) { exynos_sensor_conf.cooling_data.freq_data[i].freq_clip_max = pdata->freq_tab[i].freq_clip_max; exynos_sensor_conf.cooling_data.freq_data[i].temp_level = pdata->freq_tab[i].temp_level; } ret = exynos_register_thermal(&exynos_sensor_conf); if (ret) { dev_err(&pdev->dev, "Failed to register thermal interface\n"); goto err_clk; } return 0; err_clk: platform_set_drvdata(pdev, NULL); clk_put(data->clk); err_reg: regulator_put(data->regulator); return ret; }