static int omap_pwm_led_probe(struct platform_device *pdev) { struct omap_pwm_led_platform_data *pdata = pdev->dev.platform_data; struct omap_pwm_led *led; int ret; led = kzalloc(sizeof(struct omap_pwm_led), GFP_KERNEL); if (led == NULL) { dev_err(&pdev->dev, "No memory for device\n"); return -ENOMEM; } platform_set_drvdata(pdev, led); led->cdev.brightness_set = omap_pwm_led_set; led->cdev.default_trigger = NULL; led->cdev.name = pdata->name; led->pdata = pdata; dev_info(&pdev->dev, "OMAP PWM LED (%s) at GP timer %d/%d\n", pdata->name, pdata->intensity_timer, pdata->blink_timer); /* register our new led device */ ret = led_classdev_register(&pdev->dev, &led->cdev); if (ret < 0) { dev_err(&pdev->dev, "led_classdev_register failed\n"); goto error_classdev; } /* get related dm timers */ led->intensity_timer = omap_dm_timer_request_specific(pdata->intensity_timer); if (led->intensity_timer == NULL) { dev_err(&pdev->dev, "failed to request intensity pwm timer\n"); ret = -ENODEV; goto error_intensity; } omap_dm_timer_disable(led->intensity_timer); if (pdata->blink_timer != 0) { led->blink_timer = omap_dm_timer_request_specific(pdata->blink_timer); if (led->blink_timer == NULL) { dev_err(&pdev->dev, "failed to request blinking pwm timer\n"); ret = -ENODEV; goto error_blink; } omap_dm_timer_disable(led->blink_timer); class_device_create_file(led->cdev.class_dev, &class_device_attr_on_period); class_device_create_file(led->cdev.class_dev, &class_device_attr_off_period); } return 0; error_blink: omap_dm_timer_free(led->intensity_timer); error_intensity: led_classdev_unregister(&led->cdev); error_classdev: kfree(led); return ret; }
static __devinit int wm831x_boostp_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *pdata = wm831x->dev->platform_data; int id = pdev->id % ARRAY_SIZE(pdata->dcdc); struct wm831x_dcdc *dcdc; struct resource *res; int ret, irq; dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); if (pdata == NULL || pdata->dcdc[id] == NULL) return -ENODEV; dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL); if (dcdc == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } dcdc->wm831x = wm831x; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource\n"); ret = -EINVAL; goto err; } dcdc->base = res->start; snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); dcdc->desc.name = dcdc->name; dcdc->desc.id = id; dcdc->desc.type = REGULATOR_VOLTAGE; dcdc->desc.ops = &wm831x_boostp_ops; dcdc->desc.owner = THIS_MODULE; dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev, pdata->dcdc[id], dcdc, NULL); if (IS_ERR(dcdc->regulator)) { ret = PTR_ERR(dcdc->regulator); dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", id + 1, ret); goto err; } irq = platform_get_irq_byname(pdev, "UV"); ret = request_threaded_irq(irq, NULL, wm831x_dcdc_uv_irq, IRQF_TRIGGER_RISING, dcdc->name, dcdc); if (ret != 0) { dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", irq, ret); goto err_regulator; } platform_set_drvdata(pdev, dcdc); return 0; err_regulator: regulator_unregister(dcdc->regulator); err: kfree(dcdc); return ret; }
static int __devinit pmic8058_tm_probe(struct platform_device *pdev) { struct pm8058_tm_device *tmdev; struct pm8058_chip *pm_chip; unsigned int irq; int rc; pm_chip = dev_get_drvdata(pdev->dev.parent); if (pm_chip == NULL) { pr_err("%s: no driver data passed in.\n", __func__); return -EFAULT; } irq = platform_get_irq(pdev, 0); if (!irq) { pr_err("%s: no IRQ passed in.\n", __func__); return -EFAULT; } tmdev = kzalloc(sizeof *tmdev, GFP_KERNEL); if (tmdev == NULL) { pr_err("%s: kzalloc() failed.\n", __func__); return -ENOMEM; } rc = adc_channel_open(PM8058_TEMP_ADC_CH, &(tmdev->adc_handle)); if (rc < 0) { pr_err("%s: adc_channel_open() failed.\n", __func__); kfree(tmdev); return rc; } tmdev->pm_chip = pm_chip; tmdev->tz_dev = thermal_zone_device_register("pm8058_tz", PM8058_TRIP_NUM, tmdev, &pm8058_thermal_zone_ops, 0, 0, 0, 0); if (tmdev->tz_dev == NULL) { pr_err("%s: thermal_zone_device_register() failed.\n", __func__); adc_channel_close(tmdev->adc_handle); kfree(tmdev); return -ENODEV; } rc = pm8058_tm_init_reg(tmdev); pm8058_tm_shutdown_override(tmdev->pm_chip, SOFTWARE_OVERRIDE_DISABLED); if (rc < 0) { thermal_zone_device_unregister(tmdev->tz_dev); adc_channel_close(tmdev->adc_handle); kfree(tmdev); return rc; } /* start in HW control, switch to SW control when user changes mode */ tmdev->mode = THERMAL_DEVICE_DISABLED; thermal_zone_device_update(tmdev->tz_dev); platform_set_drvdata(pdev, tmdev); rc = request_threaded_irq(irq, NULL, pm8058_tm_isr, IRQF_TRIGGER_RISING | IRQF_DISABLED, "pm8058-tm-irq", tmdev); if (rc < 0) { pr_err("%s: request_irq(%d) FAIL: %d\n", __func__, irq, rc); thermal_zone_device_unregister(tmdev->tz_dev); platform_set_drvdata(pdev, tmdev->pm_chip); adc_channel_close(tmdev->adc_handle); kfree(tmdev); return rc; } tmdev->irq = irq; pr_notice("%s: OK\n", __func__); return 0; }
static int bcl_remove(struct platform_device *pdev) { remove_bcl_sysfs(gbcl); platform_set_drvdata(pdev, NULL); return 0; }
static int minivosc_probe(struct platform_device *devptr) #endif { struct snd_card *card; struct minivosc_device *mydev; int ret; int nr_subdevs; // how many capture substreams we want struct snd_pcm *pcm; int dev = devptr->id; // from aloop-kernel.c dbg("%s: probe", __func__); // no need to kzalloc minivosc_device separately, if the sizeof is included here ret = snd_card_create(index[dev], id[dev], THIS_MODULE, sizeof(struct minivosc_device), &card); if (ret < 0) goto __nodev; mydev = card->private_data; mydev->card = card; // MUST have mutex_init here - else crash on mutex_lock!! mutex_init(&mydev->cable_lock); dbg2("-- mydev %p", mydev); sprintf(card->driver, "my_driver-%s", SND_MINIVOSC_DRIVER); sprintf(card->shortname, "MySoundCard Audio %s", SND_MINIVOSC_DRIVER); sprintf(card->longname, "%s", card->shortname); snd_card_set_dev(card, &devptr->dev); // present in dummy, not in aloop though ret = snd_device_new(card, SNDRV_DEV_LOWLEVEL, mydev, &dev_ops); if (ret < 0) goto __nodev; nr_subdevs = 1; // how many capture substreams we want // * we want 0 playback, and 1 capture substreams (4th and 5th arg) .. ret = snd_pcm_new(card, card->driver, 0, 0, nr_subdevs, &pcm); if (ret < 0) goto __nodev; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &minivosc_pcm_ops); // in both aloop-kernel.c and dummy.c, after snd_pcm_new... pcm->private_data = mydev; //here it should be dev/card struct (the one containing struct snd_card *card) - this DOES NOT end up in substream->private_data pcm->info_flags = 0; strcpy(pcm->name, card->shortname); /* trid to add this - but it crashes here: //mydev->substream->private_data = mydev; Well, first time real substream comes in, is in _open - so that has to be handled there.. That is: at this point, mydev->substream is null, and we first have a chance to set it ... in _open! */ ret = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, snd_dma_continuous_data(GFP_KERNEL), MAX_BUFFER, MAX_BUFFER); // in both aloop-kernel.c and dummy.c, after snd_pcm_set_ops... if (ret < 0) goto __nodev; // * will use the snd_card_register form from aloop-kernel.c/dummy.c here.. ret = snd_card_register(card); if (ret == 0) // or... (!ret) { platform_set_drvdata(devptr, card); return 0; // success } __nodev: // as in aloop/dummy... dbg("__nodev reached!!"); snd_card_free(card); // this will autocall .dev_free (= minivosc_pcm_dev_free) return ret; }
static int __devinit sgiwd93_probe(struct platform_device *pdev) { struct sgiwd93_platform_data *pd = pdev->dev.platform_data; unsigned char *wdregs = pd->wdregs; struct hpc3_scsiregs *hregs = pd->hregs; struct ip22_hostdata *hdata; struct Scsi_Host *host; wd33c93_regs regs; unsigned int unit = pd->unit; unsigned int irq = pd->irq; int err; host = scsi_host_alloc(&sgiwd93_template, sizeof(struct ip22_hostdata)); if (!host) { err = -ENOMEM; goto out; } host->base = (unsigned long) hregs; host->irq = irq; hdata = host_to_hostdata(host); hdata->dev = &pdev->dev; hdata->cpu = dma_alloc_noncoherent(&pdev->dev, HPC_DMA_SIZE, &hdata->dma, GFP_KERNEL); if (!hdata->cpu) { printk(KERN_WARNING "sgiwd93: Could not allocate memory for " "host %d buffer.\n", unit); err = -ENOMEM; goto out_put; } init_hpc_chain(hdata); regs.SASR = wdregs + 3; regs.SCMD = wdregs + 7; hdata->wh.no_sync = 0; hdata->wh.fast = 1; hdata->wh.dma_mode = CTRL_BURST; wd33c93_init(host, regs, dma_setup, dma_stop, WD33C93_FS_MHZ(20)); err = request_irq(irq, sgiwd93_intr, 0, "SGI WD93", host); if (err) { printk(KERN_WARNING "sgiwd93: Could not register irq %d " "for host %d.\n", irq, unit); goto out_free; } platform_set_drvdata(pdev, host); err = scsi_add_host(host, NULL); if (err) goto out_irq; scsi_scan_host(host); return 0; out_irq: free_irq(irq, host); out_free: dma_free_noncoherent(&pdev->dev, HPC_DMA_SIZE, hdata->cpu, hdata->dma); out_put: scsi_host_put(host); out: return err; }
static int tvenc_probe(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct platform_device *mdp_dev = NULL; struct msm_fb_panel_data *pdata = NULL; int rc; if (pdev->id == 0) { tvenc_base = ioremap(pdev->resource[0].start, pdev->resource[0].end - pdev->resource[0].start + 1); if (!tvenc_base) { pr_err("tvenc_base ioremap failed!\n"); return -ENOMEM; } tvenc_pdata = pdev->dev.platform_data; tvenc_resource_initialized = 1; return 0; } if (!tvenc_resource_initialized) return -EPERM; mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (pdev_list_cnt >= MSM_FB_MAX_DEV_LIST) return -ENOMEM; if (tvenc_base == NULL) return -ENOMEM; mdp_dev = platform_device_alloc("mdp", pdev->id); if (!mdp_dev) return -ENOMEM; /* * link to the latest pdev */ mfd->pdev = mdp_dev; mfd->dest = DISPLAY_TV; /* * alloc panel device data */ if (platform_device_add_data (mdp_dev, pdev->dev.platform_data, sizeof(struct msm_fb_panel_data))) { pr_err("tvenc_probe: platform_device_add_data failed!\n"); platform_device_put(mdp_dev); return -ENOMEM; } /* * data chain */ pdata = mdp_dev->dev.platform_data; pdata->on = tvenc_on; pdata->off = tvenc_off; pdata->next = pdev; /* * get/set panel specific fb info */ mfd->panel_info = pdata->panel_info; #ifdef CONFIG_FB_MSM_MDP40 mfd->fb_imgType = MDP_RGB_565; /* base layer */ #else mfd->fb_imgType = MDP_YCRYCB_H2V1; #endif #ifdef CONFIG_MSM_BUS_SCALING if (!tvenc_bus_scale_handle && tvenc_pdata && tvenc_pdata->bus_scale_table) { tvenc_bus_scale_handle = msm_bus_scale_register_client( tvenc_pdata->bus_scale_table); if (!tvenc_bus_scale_handle) { printk(KERN_ERR "%s not able to get bus scale\n", __func__); } } #else mfd->ebi1_clk = clk_get(NULL, "ebi1_tv_clk"); if (IS_ERR(mfd->ebi1_clk)) { rc = PTR_ERR(mfd->ebi1_clk); goto tvenc_probe_err; } clk_set_rate(mfd->ebi1_clk, MSM_SYSTEM_BUS_RATE); #endif /* * set driver data */ platform_set_drvdata(mdp_dev, mfd); /* * register in mdp driver */ rc = platform_device_add(mdp_dev); if (rc) goto tvenc_probe_err; pm_runtime_set_active(&pdev->dev); pm_runtime_enable(&pdev->dev); pdev_list[pdev_list_cnt++] = pdev; return 0; tvenc_probe_err: #ifdef CONFIG_MSM_BUS_SCALING if (tvenc_pdata && tvenc_pdata->bus_scale_table && tvenc_bus_scale_handle > 0) { msm_bus_scale_unregister_client(tvenc_bus_scale_handle); tvenc_bus_scale_handle = 0; } #endif platform_device_put(mdp_dev); return rc; }
static int __devinit attiny_probe(struct platform_device *pdev) { int result = 0; struct attiny_platform_data * attiny_data = NULL; struct input_dev *idev = NULL; attiny_data = (struct attiny_platform_data *)pdev->dev.platform_data; if (!attiny_data || (!attiny_data->enable) || (attiny_data->irq < 0)) { dev_err(&pdev->dev, "get platform data failed!\n"); return -ENODATA; } attiny_private_data = kzalloc(sizeof(struct attiny_private), GFP_KERNEL); if (!attiny_private_data) { dev_err(&pdev->dev, "allocate memory failed!\n"); return -ENOMEM; } attiny_private_data->platform_data = attiny_data; mutex_init(&attiny_private_data->mutex); attiny_private_data->state = ATTI_OFF; platform_set_drvdata(pdev, attiny_private_data); idev = input_allocate_device(); if (!idev) { dev_err(&pdev->dev, "allocate input device failed!\n"); result = -ENOMEM; goto err_allocate_input; } idev->name = ATTINY_NAME; idev->id.bustype = BUS_VIRTUAL; __set_bit(EV_ABS, idev->evbit); input_set_abs_params(idev, ABS_DISTANCE, 0, 1, 0, 0); result = input_register_device(idev); if (result) { dev_err(&pdev->dev, "register input device failed!\n"); goto err_register_input; } attiny_private_data->idev = idev; result = request_irq(attiny_data->irq, attiny_handler, IRQ_TYPE_EDGE_BOTH, "attiny_irq", attiny_private_data); if (result) { dev_err(&pdev->dev, "request_irq failed\n"); goto err_request_irq; } disable_irq(attiny_data->irq); result = device_create_file(&idev->dev, &dev_attr_enable); if(result ) { dev_err(&pdev->dev, "create device file failed\n"); goto err_create_file; } return result; err_create_file: free_irq(attiny_data->irq, attiny_private_data); err_request_irq: input_unregister_device(idev); goto err_allocate_input; err_register_input: input_free_device(idev); err_allocate_input: platform_set_drvdata(pdev, NULL); mutex_destroy(&attiny_private_data->mutex); kfree(attiny_private_data); return result; }
static int __devexit snd_smdk_remove(struct platform_device *pdev) { snd_soc_unregister_card(&smdk_pcm); platform_set_drvdata(pdev, NULL); return 0; }
static int tps65910_rtc_probe(struct platform_device *pdev) { struct tps65910 *tps65910 = NULL; struct tps65910_rtc *tps_rtc = NULL; int ret; int irq; u32 rtc_reg; tps65910 = dev_get_drvdata(pdev->dev.parent); tps_rtc = devm_kzalloc(&pdev->dev, sizeof(struct tps65910_rtc), GFP_KERNEL); if (!tps_rtc) return -ENOMEM; /* Clear pending interrupts */ ret = regmap_read(tps65910->regmap, TPS65910_RTC_STATUS, &rtc_reg); if (ret < 0) return ret; ret = regmap_write(tps65910->regmap, TPS65910_RTC_STATUS, rtc_reg); if (ret < 0) return ret; dev_dbg(&pdev->dev, "Enabling rtc-tps65910.\n"); /* Enable RTC digital power domain */ ret = regmap_update_bits(tps65910->regmap, TPS65910_DEVCTRL, DEVCTRL_RTC_PWDN_MASK, 0 << DEVCTRL_RTC_PWDN_SHIFT); if (ret < 0) return ret; rtc_reg = TPS65910_RTC_CTRL_STOP_RTC; ret = regmap_write(tps65910->regmap, TPS65910_RTC_CTRL, rtc_reg); if (ret < 0) return ret; irq = platform_get_irq(pdev, 0); if (irq <= 0) { dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n", irq); return ret; } ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, tps65910_rtc_interrupt, IRQF_TRIGGER_LOW | IRQF_EARLY_RESUME, dev_name(&pdev->dev), &pdev->dev); if (ret < 0) { dev_err(&pdev->dev, "IRQ is not free.\n"); return ret; } tps_rtc->irq = irq; device_set_wakeup_capable(&pdev->dev, 1); tps_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev, &tps65910_rtc_ops, THIS_MODULE); if (IS_ERR(tps_rtc->rtc)) { ret = PTR_ERR(tps_rtc->rtc); dev_err(&pdev->dev, "RTC device register: err %d\n", ret); return ret; } platform_set_drvdata(pdev, tps_rtc); return 0; }
static int __devinit em_gio_probe(struct platform_device *pdev) { struct gpio_em_config *pdata = pdev->dev.platform_data; struct em_gio_priv *p; struct resource *io[2], *irq[2]; struct gpio_chip *gpio_chip; struct irq_chip *irq_chip; const char *name = dev_name(&pdev->dev); int ret; p = kzalloc(sizeof(*p), GFP_KERNEL); if (!p) { dev_err(&pdev->dev, "failed to allocate driver data\n"); ret = -ENOMEM; goto err0; } p->pdev = pdev; platform_set_drvdata(pdev, p); spin_lock_init(&p->sense_lock); io[0] = platform_get_resource(pdev, IORESOURCE_MEM, 0); io[1] = platform_get_resource(pdev, IORESOURCE_MEM, 1); irq[0] = platform_get_resource(pdev, IORESOURCE_IRQ, 0); irq[1] = platform_get_resource(pdev, IORESOURCE_IRQ, 1); if (!io[0] || !io[1] || !irq[0] || !irq[1] || !pdata) { dev_err(&pdev->dev, "missing IRQ, IOMEM or configuration\n"); ret = -EINVAL; goto err1; } p->base0 = ioremap_nocache(io[0]->start, resource_size(io[0])); if (!p->base0) { dev_err(&pdev->dev, "failed to remap low I/O memory\n"); ret = -ENXIO; goto err1; } p->base1 = ioremap_nocache(io[1]->start, resource_size(io[1])); if (!p->base1) { dev_err(&pdev->dev, "failed to remap high I/O memory\n"); ret = -ENXIO; goto err2; } gpio_chip = &p->gpio_chip; gpio_chip->direction_input = em_gio_direction_input; gpio_chip->get = em_gio_get; gpio_chip->direction_output = em_gio_direction_output; gpio_chip->set = em_gio_set; gpio_chip->to_irq = em_gio_to_irq; gpio_chip->label = name; gpio_chip->owner = THIS_MODULE; gpio_chip->base = pdata->gpio_base; gpio_chip->ngpio = pdata->number_of_pins; irq_chip = &p->irq_chip; irq_chip->name = name; irq_chip->irq_mask = em_gio_irq_disable; irq_chip->irq_unmask = em_gio_irq_enable; irq_chip->irq_enable = em_gio_irq_enable; irq_chip->irq_disable = em_gio_irq_disable; irq_chip->irq_set_type = em_gio_irq_set_type; irq_chip->flags = IRQCHIP_SKIP_SET_WAKE; ret = em_gio_irq_domain_init(p); if (ret) { dev_err(&pdev->dev, "cannot initialize irq domain\n"); goto err3; } if (request_irq(irq[0]->start, em_gio_irq_handler, 0, name, p)) { dev_err(&pdev->dev, "failed to request low IRQ\n"); ret = -ENOENT; goto err4; } if (request_irq(irq[1]->start, em_gio_irq_handler, 0, name, p)) { dev_err(&pdev->dev, "failed to request high IRQ\n"); ret = -ENOENT; goto err5; } ret = gpiochip_add(gpio_chip); if (ret) { dev_err(&pdev->dev, "failed to add GPIO controller\n"); goto err6; } return 0; err6: free_irq(irq[1]->start, pdev); err5: free_irq(irq[0]->start, pdev); err4: em_gio_irq_domain_cleanup(p); err3: iounmap(p->base1); err2: iounmap(p->base0); err1: kfree(p); err0: return ret; }
static int __init n810_soc_init(void) { int err; struct device *dev; if (!of_have_populated_dt() || (!of_machine_is_compatible("nokia,n810") && !of_machine_is_compatible("nokia,n810-wimax"))) return -ENODEV; n810_snd_device = platform_device_alloc("soc-audio", -1); if (!n810_snd_device) return -ENOMEM; platform_set_drvdata(n810_snd_device, &snd_soc_n810); err = platform_device_add(n810_snd_device); if (err) goto err1; dev = &n810_snd_device->dev; sys_clkout2_src = clk_get(dev, "sys_clkout2_src"); if (IS_ERR(sys_clkout2_src)) { dev_err(dev, "Could not get sys_clkout2_src clock\n"); err = PTR_ERR(sys_clkout2_src); goto err2; } sys_clkout2 = clk_get(dev, "sys_clkout2"); if (IS_ERR(sys_clkout2)) { dev_err(dev, "Could not get sys_clkout2\n"); err = PTR_ERR(sys_clkout2); goto err3; } /* * Configure 12 MHz output on SYS_CLKOUT2. Therefore we must use * 96 MHz as its parent in order to get 12 MHz */ func96m_clk = clk_get(dev, "func_96m_ck"); if (IS_ERR(func96m_clk)) { dev_err(dev, "Could not get func 96M clock\n"); err = PTR_ERR(func96m_clk); goto err4; } clk_set_parent(sys_clkout2_src, func96m_clk); clk_set_rate(sys_clkout2, 12000000); if (WARN_ON((gpio_request(N810_HEADSET_AMP_GPIO, "hs_amp") < 0) || (gpio_request(N810_SPEAKER_AMP_GPIO, "spk_amp") < 0))) { err = -EINVAL; goto err4; } gpio_direction_output(N810_HEADSET_AMP_GPIO, 0); gpio_direction_output(N810_SPEAKER_AMP_GPIO, 0); return 0; err4: clk_put(sys_clkout2); err3: clk_put(sys_clkout2_src); err2: platform_device_del(n810_snd_device); err1: platform_device_put(n810_snd_device); return err; }
static int omap_usb2_probe(struct platform_device *pdev) { struct omap_usb *phy; struct phy *generic_phy; struct phy_provider *phy_provider; struct usb_otg *otg; struct device_node *node = pdev->dev.of_node; struct device_node *control_node; struct platform_device *control_pdev; if (!node) return -EINVAL; phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL); if (!phy) { dev_err(&pdev->dev, "unable to allocate memory for USB2 PHY\n"); return -ENOMEM; } otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL); if (!otg) { dev_err(&pdev->dev, "unable to allocate memory for USB OTG\n"); return -ENOMEM; } phy->dev = &pdev->dev; phy->phy.dev = phy->dev; phy->phy.label = "omap-usb2"; phy->phy.set_suspend = omap_usb2_suspend; phy->phy.otg = otg; phy->phy.type = USB_PHY_TYPE_USB2; control_node = of_parse_phandle(node, "ctrl-module", 0); if (!control_node) { dev_err(&pdev->dev, "Failed to get control device phandle\n"); return -EINVAL; } control_pdev = of_find_device_by_node(control_node); if (!control_pdev) { dev_err(&pdev->dev, "Failed to get control device\n"); return -EINVAL; } phy->control_dev = &control_pdev->dev; phy->is_suspended = 1; omap_control_usb_phy_power(phy->control_dev, 0); otg->set_host = omap_usb_set_host; otg->set_peripheral = omap_usb_set_peripheral; otg->set_vbus = omap_usb_set_vbus; otg->start_srp = omap_usb_start_srp; otg->phy = &phy->phy; platform_set_drvdata(pdev, phy); pm_runtime_enable(phy->dev); generic_phy = devm_phy_create(phy->dev, &ops, NULL); if (IS_ERR(generic_phy)) return PTR_ERR(generic_phy); phy_set_drvdata(generic_phy, phy); phy_provider = devm_of_phy_provider_register(phy->dev, of_phy_simple_xlate); if (IS_ERR(phy_provider)) return PTR_ERR(phy_provider); phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k"); if (IS_ERR(phy->wkupclk)) { dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n"); return PTR_ERR(phy->wkupclk); } clk_prepare(phy->wkupclk); phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m"); if (IS_ERR(phy->optclk)) dev_vdbg(&pdev->dev, "unable to get refclk960m\n"); else clk_prepare(phy->optclk); usb_add_phy_dev(&phy->phy); return 0; }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up; struct resource *mem, *irq; struct omap_uart_port_info *omap_up_info = dev_get_platdata(&pdev->dev); int ret, uartirq = 0, wakeirq = 0; /* The optional wakeirq may be specified in the board dts file */ if (pdev->dev.of_node) { uartirq = irq_of_parse_and_map(pdev->dev.of_node, 0); if (!uartirq) return -EPROBE_DEFER; wakeirq = irq_of_parse_and_map(pdev->dev.of_node, 1); omap_up_info = of_get_uart_port_info(&pdev->dev); pdev->dev.platform_data = omap_up_info; } else { irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } uartirq = irq->start; } mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } if (!devm_request_mem_region(&pdev->dev, mem->start, resource_size(mem), pdev->dev.driver->name)) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } if (gpio_is_valid(omap_up_info->DTR_gpio) && omap_up_info->DTR_present) { ret = gpio_request(omap_up_info->DTR_gpio, "omap-serial"); if (ret < 0) return ret; ret = gpio_direction_output(omap_up_info->DTR_gpio, omap_up_info->DTR_inverted); if (ret < 0) return ret; } up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL); if (!up) return -ENOMEM; if (gpio_is_valid(omap_up_info->DTR_gpio) && omap_up_info->DTR_present) { up->DTR_gpio = omap_up_info->DTR_gpio; up->DTR_inverted = omap_up_info->DTR_inverted; } else up->DTR_gpio = -EINVAL; up->DTR_active = 0; up->dev = &pdev->dev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.irq = uartirq; up->wakeirq = wakeirq; if (!up->wakeirq) dev_info(up->port.dev, "no wakeirq for uart%d\n", up->port.line); up->port.regshift = 2; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; if (pdev->dev.of_node) up->port.line = of_alias_get_id(pdev->dev.of_node, "serial"); else up->port.line = pdev->id; if (up->port.line < 0) { dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n", up->port.line); ret = -ENODEV; goto err_port_line; } ret = serial_omap_probe_rs485(up, pdev->dev.of_node); if (ret < 0) goto err_rs485; sprintf(up->name, "OMAP UART%d", up->port.line); up->port.mapbase = mem->start; up->port.membase = devm_ioremap(&pdev->dev, mem->start, resource_size(mem)); if (!up->port.membase) { dev_err(&pdev->dev, "can't ioremap UART\n"); ret = -ENOMEM; goto err_ioremap; } up->port.flags = omap_up_info->flags; up->port.uartclk = omap_up_info->uartclk; if (!up->port.uartclk) { up->port.uartclk = DEFAULT_CLK_SPEED; dev_warn(&pdev->dev, "No clock speed specified: using default: %d\n", DEFAULT_CLK_SPEED); } up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE; pm_qos_add_request(&up->pm_qos_request, PM_QOS_CPU_DMA_LATENCY, up->latency); serial_omap_uart_wq = create_singlethread_workqueue(up->name); INIT_WORK(&up->qos_work, serial_omap_uart_qos_work); platform_set_drvdata(pdev, up); if (omap_up_info->autosuspend_timeout == 0) omap_up_info->autosuspend_timeout = -1; device_init_wakeup(up->dev, true); pm_runtime_use_autosuspend(&pdev->dev); pm_runtime_set_autosuspend_delay(&pdev->dev, omap_up_info->autosuspend_timeout); pm_runtime_irq_safe(&pdev->dev); pm_runtime_enable(&pdev->dev); pm_runtime_get_sync(&pdev->dev); omap_serial_fill_features_erratas(up); ui[up->port.line] = up; serial_omap_add_console_port(up); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto err_add_port; pm_runtime_mark_last_busy(up->dev); pm_runtime_put_autosuspend(up->dev); return 0; err_add_port: pm_runtime_put(&pdev->dev); pm_runtime_disable(&pdev->dev); err_ioremap: err_rs485: err_port_line: dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", pdev->id, __func__, ret); return ret; }
static int s3c_rtc_probe(struct platform_device *pdev) { struct rtc_device *rtc; struct resource *res; int ret; pr_debug("%s: probe=%p\n", __func__, pdev); /* find the IRQs */ s3c_rtc_tickno = platform_get_irq(pdev, 1); if (s3c_rtc_tickno < 0) { dev_err(&pdev->dev, "no irq for rtc tick\n"); return -ENOENT; } s3c_rtc_alarmno = platform_get_irq(pdev, 0); if (s3c_rtc_alarmno < 0) { dev_err(&pdev->dev, "no irq for alarm\n"); return -ENOENT; } pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n", s3c_rtc_tickno, s3c_rtc_alarmno); /* get the memory region */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&pdev->dev, "failed to get memory region resource\n"); return -ENOENT; } s3c_rtc_mem = request_mem_region(res->start, res->end-res->start+1, pdev->name); if (s3c_rtc_mem == NULL) { dev_err(&pdev->dev, "failed to reserve memory region\n"); ret = -ENOENT; goto err_nores; } s3c_rtc_base = ioremap(res->start, res->end - res->start + 1); if (s3c_rtc_base == NULL) { dev_err(&pdev->dev, "failed ioremap()\n"); ret = -EINVAL; goto err_nomap; } /* check to see if everything is setup correctly */ s3c_rtc_enable(pdev, 1); pr_debug("s3c2410_rtc: RTCCON=%02x\n", readb(s3c_rtc_base + S3C2410_RTCCON)); s3c_rtc_setfreq(s3c_rtc_freq); /* register RTC and exit */ rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops, THIS_MODULE); if (IS_ERR(rtc)) { dev_err(&pdev->dev, "cannot attach rtc\n"); ret = PTR_ERR(rtc); goto err_nortc; } rtc->max_user_freq = 128; platform_set_drvdata(pdev, rtc); return 0; err_nortc: s3c_rtc_enable(pdev, 0); iounmap(s3c_rtc_base); err_nomap: release_resource(s3c_rtc_mem); err_nores: return ret; }
static int __init gpio_event_probe(struct platform_device *pdev) { int err; struct gpio_event *ip; struct gpio_event_platform_data *event_info; int dev_count = 1; int i; int registered = 0; event_info = pdev->dev.platform_data; if (event_info == NULL) { pr_err("gpio_event_probe: No pdata\n"); return -ENODEV; } if ((!event_info->name && !event_info->names[0]) || !event_info->info || !event_info->info_count) { pr_err("gpio_event_probe: Incomplete pdata\n"); return -ENODEV; } if (!event_info->name) while (event_info->names[dev_count]) dev_count++; ip = kzalloc(sizeof(*ip) + sizeof(ip->state[0]) * event_info->info_count + sizeof(*ip->input_devs) + sizeof(ip->input_devs->dev[0]) * dev_count, GFP_KERNEL); if (ip == NULL) { err = -ENOMEM; pr_err("gpio_event_probe: Failed to allocate private data\n"); goto err_kp_alloc_failed; } ip->input_devs = (void*)&ip->state[event_info->info_count]; platform_set_drvdata(pdev, ip); for (i = 0; i < dev_count; i++) { struct input_dev *input_dev = input_allocate_device(); if (input_dev == NULL) { err = -ENOMEM; pr_err("gpio_event_probe: " "Failed to allocate input device\n"); goto err_input_dev_alloc_failed; } input_set_drvdata(input_dev, ip); input_dev->name = event_info->name ? event_info->name : event_info->names[i]; input_dev->event = gpio_input_event; ip->input_devs->dev[i] = input_dev; } ip->input_devs->count = dev_count; ip->info = event_info; if (event_info->power) { #ifdef CONFIG_HAS_EARLYSUSPEND ip->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; ip->early_suspend.suspend = gpio_event_suspend; ip->early_suspend.resume = gpio_event_resume; register_early_suspend(&ip->early_suspend); #endif ip->info->power(ip->info, 1); } err = gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_INIT); if (err) goto err_call_all_func_failed; for (i = 0; i < dev_count; i++) { err = input_register_device(ip->input_devs->dev[i]); if (err) { pr_err("gpio_event_probe: Unable to register %s " "input device\n", ip->input_devs->dev[i]->name); goto err_input_register_device_failed; } registered++; } #if (defined(CONFIG_MACH_EUROPA) || defined(CONFIG_MACH_CALLISTO)|| defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS) || defined(CONFIG_MACH_LUCAS)) /* sys fs */ key_class = class_create(THIS_MODULE, "key"); if (IS_ERR(key_class)) pr_err("Failed to create class(key)!\n"); key_dev = device_create(key_class, NULL, 0, NULL, "key"); if (IS_ERR(key_dev)) pr_err("Failed to create device(key)!\n"); if (device_create_file(key_dev, &dev_attr_key) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_key.attr.name); /* sys fs */ #endif #ifndef CONFIG_MACH_LUCAS //for landscape UI (temporary patch) for (i = 0; i < registered; i++) { input_report_switch(ip->input_devs->dev[i], SW_LID, 1); input_sync(ip->input_devs->dev[i]); } #endif return 0; err_input_register_device_failed: gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT); err_call_all_func_failed: if (event_info->power) { #ifdef CONFIG_HAS_EARLYSUSPEND unregister_early_suspend(&ip->early_suspend); #endif ip->info->power(ip->info, 0); } for (i = 0; i < registered; i++) input_unregister_device(ip->input_devs->dev[i]); for (i = dev_count - 1; i >= registered; i--) { input_free_device(ip->input_devs->dev[i]); err_input_dev_alloc_failed: ; } kfree(ip); err_kp_alloc_failed: return err; }
static int s2mps11_pmic_probe(struct platform_device *pdev) { struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent); struct sec_platform_data *pdata = NULL; struct of_regulator_match *rdata = NULL; struct regulator_config config = { }; struct s2mps11_info *s2mps11; int i, ret = 0; const struct regulator_desc *regulators; s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info), GFP_KERNEL); if (!s2mps11) return -ENOMEM; s2mps11->dev_type = platform_get_device_id(pdev)->driver_data; switch (s2mps11->dev_type) { case S2MPS11X: s2mps11->rdev_num = ARRAY_SIZE(s2mps11_regulators); regulators = s2mps11_regulators; break; case S2MPS13X: s2mps11->rdev_num = ARRAY_SIZE(s2mps13_regulators); regulators = s2mps13_regulators; break; case S2MPS14X: s2mps11->rdev_num = ARRAY_SIZE(s2mps14_regulators); regulators = s2mps14_regulators; break; case S2MPU02: s2mps11->rdev_num = ARRAY_SIZE(s2mpu02_regulators); regulators = s2mpu02_regulators; break; default: dev_err(&pdev->dev, "Invalid device type: %u\n", s2mps11->dev_type); return -EINVAL; }; s2mps11->ext_control_gpio = devm_kmalloc(&pdev->dev, sizeof(*s2mps11->ext_control_gpio) * s2mps11->rdev_num, GFP_KERNEL); if (!s2mps11->ext_control_gpio) return -ENOMEM; /* * 0 is a valid GPIO so initialize all GPIO-s to negative value * to indicate that external control won't be used for this regulator. */ for (i = 0; i < s2mps11->rdev_num; i++) s2mps11->ext_control_gpio[i] = -EINVAL; if (!iodev->dev->of_node) { if (iodev->pdata) { pdata = iodev->pdata; goto common_reg; } else { dev_err(pdev->dev.parent, "Platform data or DT node not supplied\n"); return -ENODEV; } } rdata = kzalloc(sizeof(*rdata) * s2mps11->rdev_num, GFP_KERNEL); if (!rdata) return -ENOMEM; for (i = 0; i < s2mps11->rdev_num; i++) rdata[i].name = regulators[i].name; ret = s2mps11_pmic_dt_parse(pdev, rdata, s2mps11); if (ret) goto out; common_reg: platform_set_drvdata(pdev, s2mps11); config.dev = &pdev->dev; config.regmap = iodev->regmap_pmic; config.driver_data = s2mps11; config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH; config.ena_gpio_initialized = true; for (i = 0; i < s2mps11->rdev_num; i++) { struct regulator_dev *regulator; if (pdata) { config.init_data = pdata->regulators[i].initdata; config.of_node = pdata->regulators[i].reg_node; } else { config.init_data = rdata[i].init_data; config.of_node = rdata[i].of_node; } config.ena_gpio = s2mps11->ext_control_gpio[i]; regulator = devm_regulator_register(&pdev->dev, ®ulators[i], &config); if (IS_ERR(regulator)) { ret = PTR_ERR(regulator); dev_err(&pdev->dev, "regulator init failed for %d\n", i); goto out; } if (gpio_is_valid(s2mps11->ext_control_gpio[i])) { ret = s2mps14_pmic_enable_ext_control(s2mps11, regulator); if (ret < 0) { dev_err(&pdev->dev, "failed to enable GPIO control over %s: %d\n", regulator->desc->name, ret); goto out; } } } out: kfree(rdata); return ret; }
/* * ubicom32_spi_gpio_probe */ static int ubicom32_spi_gpio_probe(struct platform_device *dev) { struct ubicom32_spi_gpio_platform_data *pdata; struct spi_master *master; struct ubicom32_spi_gpio *usg; int ret; master = spi_alloc_master(&dev->dev, sizeof(struct ubicom32_spi_gpio)); if (master == NULL) { dev_err(&dev->dev, "failed to allocate spi master\n"); ret = -ENOMEM; goto err; } usg = (struct ubicom32_spi_gpio *)spi_master_get_devdata(master); platform_set_drvdata(dev, usg); /* * Copy in the platform data */ pdata = dev->dev.platform_data; usg->pdata = dev->dev.platform_data; /* * Request the GPIO lines */ ret = gpio_request(pdata->pin_mosi, "spi-mosi"); if (ret) { dev_err(&dev->dev, "Failed to allocate spi-mosi GPIO\n"); goto err; } ret = gpio_request(pdata->pin_miso, "spi-miso"); if (ret) { dev_err(&dev->dev, "Failed to allocate spi-miso GPIO\n"); goto err_nomiso; } ret = gpio_request(pdata->pin_clk, "spi-clk"); if (ret) { dev_err(&dev->dev, "Failed to allocate spi-clk GPIO\n"); goto err_noclk; } /* * Setup spi-bitbang adaptor */ usg->bitbang.flags |= SPI_CS_HIGH; usg->bitbang.master = spi_master_get(master); usg->bitbang.master->bus_num = pdata->bus_num; usg->bitbang.master->num_chipselect = pdata->num_chipselect; usg->bitbang.chipselect = ubicom32_spi_gpio_chipselect; usg->bitbang.txrx_word[SPI_MODE_0] = ubicom32_spi_gpio_txrx_mode0; usg->bitbang.txrx_word[SPI_MODE_1] = ubicom32_spi_gpio_txrx_mode1; usg->bitbang.txrx_word[SPI_MODE_2] = ubicom32_spi_gpio_txrx_mode2; usg->bitbang.txrx_word[SPI_MODE_3] = ubicom32_spi_gpio_txrx_mode3; /* * Setup the GPIO pins */ gpio_direction_output(pdata->pin_clk, pdata->clk_default); gpio_direction_output(pdata->pin_mosi, 0); gpio_direction_input(pdata->pin_miso); /* * Ready to go */ ret = spi_bitbang_start(&usg->bitbang); if (ret) { goto err_no_bitbang; } return 0; err_no_bitbang: spi_master_put(usg->bitbang.master); gpio_free(pdata->pin_clk); err_noclk: gpio_free(pdata->pin_miso); err_nomiso: gpio_free(pdata->pin_mosi); err: return ret; }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up; struct resource *mem, *irq; int ret = -ENOSPC; char str[7]; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } ret = (int) request_mem_region(mem->start, (mem->end - mem->start) + 1, pdev->dev.driver->name); if (!ret) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } up = kzalloc(sizeof(*up), GFP_KERNEL); if (up == NULL) { ret = -ENOMEM; goto do_release_region; } sprintf(up->name, "OMAP UART%d", pdev->id); up->pdev = pdev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.mapbase = mem->start; up->port.irq = irq->start; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; up->port.line = line++; #define QUART_CLK (1843200) if (pdev->id == 4) { up->port.membase = ioremap_nocache(mem->start, 0x16 << 1); up->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP | UPF_SHARE_IRQ; up->port.uartclk = QUART_CLK; up->port.regshift = 1; } else { up->port.membase = (void *) io_p2v(mem->start); up->port.flags = UPF_BOOT_AUTOCONF; up->port.uartclk = 48000000; up->port.regshift = 2; } if (pdev->id == (UART1+1)) { #ifdef CONFIG_SERIAL_OMAP_DMA_UART1 up->use_dma = 1; up->uart_dma.rx_buf_size = CONFIG_SERIAL_OMAP_UART1_RXDMA_BUFSIZE; up->uart_dma.rx_timeout = CONFIG_SERIAL_OMAP_UART1_RXDMA_TIMEOUT; #endif } else if (pdev->id == (UART2+1)) { #ifdef CONFIG_SERIAL_OMAP_DMA_UART2 up->use_dma = 1; up->uart_dma.rx_buf_size = CONFIG_SERIAL_OMAP_UART2_RXDMA_BUFSIZE; up->uart_dma.rx_timeout = CONFIG_SERIAL_OMAP_UART2_RXDMA_TIMEOUT; #endif } else if (pdev->id == (UART3+1)) { #ifdef CONFIG_SERIAL_OMAP_DMA_UART3 up->use_dma = 1; up->uart_dma.rx_buf_size = CONFIG_SERIAL_OMAP_UART3_RXDMA_BUFSIZE; up->uart_dma.rx_timeout = CONFIG_SERIAL_OMAP_UART3_RXDMA_TIMEOUT; #endif } if (up->use_dma) { spin_lock_init(&(up->uart_dma.tx_lock)); spin_lock_init(&(up->uart_dma.rx_lock)); up->uart_dma.tx_dma_channel = 0xFF; up->uart_dma.rx_dma_channel = 0xFF; } if (console_detect(str)) { printk(KERN_INFO "Invalid console paramter....\n"); } up->use_console = 0; fcr[pdev->id - 1] = 0; if (!strcmp(str, "ttyS0")) up->use_console = 1; else if (!strcmp(str, "ttyS1")) up->use_console = 1; else if (!strcmp(str, "ttyS2")) up->use_console = 1; else if (!strcmp(str, "ttyS3")) up->use_console = 1; else printk(KERN_INFO "!!!!!!!!! Unable to recongnize Console UART........\n"); ui[pdev->id - 1] = up; serial_omap_add_console_port(up); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto do_release_region; platform_set_drvdata(pdev, up); return 0; do_release_region: release_mem_region(mem->start, (mem->end - mem->start) + 1); return ret; }
static int __devinit k3v2_gpio_key_probe(struct platform_device* pdev) { struct k3v2_gpio_key *gpio_key = NULL; struct input_dev *input_dev = NULL; int err =0; unsigned int camera_focus_key; camera_focus_key = get_camera_focus_key(); if (NULL == pdev) { printk(KERN_ERR "[gpiokey]parameter error!\n"); err = -EINVAL; return err; } gpio_key = kzalloc(sizeof(struct k3v2_gpio_key), GFP_KERNEL); if (!gpio_key) { dev_err(&pdev->dev, "Failed to allocate struct k3v2_gpio_key!\n"); err = -ENOMEM; return err; } input_dev = input_allocate_device(); if (!input_dev) { dev_err(&pdev->dev, "Failed to allocate struct input_dev!\n"); err = -ENOMEM; goto err_alloc_input_device; } input_dev->name = pdev->name; input_dev->id.bustype = BUS_HOST; input_dev->dev.parent = &pdev->dev; input_set_drvdata(input_dev, gpio_key); set_bit(EV_KEY, input_dev->evbit); set_bit(EV_SYN, input_dev->evbit); set_bit(KEY_VOLUMEUP, input_dev->keybit); set_bit(KEY_VOLUMEDOWN, input_dev->keybit); set_bit(KEY_CAMERA_FOCUS, input_dev->keybit); set_bit(KEY_CAMERA, input_dev->keybit); input_dev->open = k3v2_gpio_key_open; input_dev->close = k3v2_gpio_key_close; gpio_key->input_dev = input_dev; /*initial work before we use it.*/ INIT_DELAYED_WORK(&(gpio_key->gpio_keyup_work), k3v2_gpio_keyup_work); INIT_DELAYED_WORK(&(gpio_key->gpio_keydown_work), k3v2_gpio_keydown_work); INIT_DELAYED_WORK(&(gpio_key->gpio_camerafocus_work), k3v2_gpio_camerafocus_work); INIT_DELAYED_WORK(&(gpio_key->gpio_camera_work), k3v2_gpio_camera_work); /*get volume-up-key irq.*/ gpio_key->volume_up_irq = platform_get_irq(pdev, 0); if (gpio_key->volume_up_irq < 0) { dev_err(&pdev->dev, "Failed to get gpio key press irq!\n"); err = gpio_key->volume_up_irq; goto err_get_irq; } /* * support failing irq that means volume-up-key is pressed, * and rising irq which means volume-up-key is released. */ err = request_irq(gpio_key->volume_up_irq, k3v2_gpio_key_irq_handler, IRQF_NO_SUSPEND | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, pdev->name, gpio_key); if (err) { dev_err(&pdev->dev, "Failed to request press interupt handler!\n"); goto err_request_irq; } /*get volume-down-key irq.*/ gpio_key->volume_down_irq = platform_get_irq(pdev, 1); if (gpio_key->volume_down_irq < 0) { dev_err(&pdev->dev, "Failed to get gpio key release irq!\n"); err = gpio_key->volume_down_irq; goto err_get_irq; } /* * support failing irq that means volume-down-key is pressed, * and rising irq which means volume-down-key is released. */ err = request_irq(gpio_key->volume_down_irq, k3v2_gpio_key_irq_handler, IRQF_NO_SUSPEND | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, pdev->name, gpio_key); if (err) { dev_err(&pdev->dev, "Failed to request release interupt handler!\n"); goto err_request_irq; } if(camera_focus_key) { /*get camera-focus-key irq.*/ gpio_key->camera_focus_irq = platform_get_irq(pdev, 2); if (gpio_key->camera_focus_irq < 0) { dev_err(&pdev->dev, "Failed to get gpio camera focus irq!\n"); err = gpio_key->camera_focus_irq; goto err_get_irq; } /* * support failing irq that means camera-focus-key is pressed, * and rising irq which means camera-focus-key is released. */ err = request_irq(gpio_key->camera_focus_irq, k3v2_gpio_key_irq_handler, IRQF_NO_SUSPEND | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, pdev->name, gpio_key); if (err) { dev_err(&pdev->dev, "Failed to request camera focus interupt handler!\n"); goto err_request_irq; } /*get camera-key irq.*/ gpio_key->camera_irq = platform_get_irq(pdev, 3); if (gpio_key->camera_irq < 0) { dev_err(&pdev->dev, "Failed to get gpio camera irq!\n"); err = gpio_key->camera_irq; goto err_get_irq; } /* * support failing irq that means camera-key is pressed, * and rising irq which means camera-key is released. */ err = request_irq(gpio_key->camera_irq, k3v2_gpio_key_irq_handler, IRQF_NO_SUSPEND | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, pdev->name, gpio_key); if (err) { dev_err(&pdev->dev, "Failed to request camera interupt handler!\n"); goto err_request_irq; } } err = input_register_device(gpio_key->input_dev); if (err) { dev_err(&pdev->dev, "Failed to register input device!\n"); goto err_register_device; } device_init_wakeup(&pdev->dev, TRUE); platform_set_drvdata(pdev, gpio_key); dev_info(&pdev->dev, "k3v2 gpio key driver probes successfully!\n"); return 0; err_register_device: free_irq(gpio_key->volume_up_irq, gpio_key); free_irq(gpio_key->volume_down_irq, gpio_key); free_irq(gpio_key->camera_focus_irq, gpio_key); free_irq(gpio_key->camera_irq, gpio_key); err_request_irq: err_get_irq: input_free_device(input_dev); err_alloc_input_device: kfree(gpio_key); gpio_key = NULL; pr_info(KERN_ERR "[gpiokey]K3v2 gpio key probe failed! ret = %d.\n", err); return err; }
static int bcl_probe(struct platform_device *pdev) { struct bcl_context *bcl = NULL; int ret = 0; enum bcl_device_mode bcl_mode = BCL_DEVICE_DISABLED; bcl = devm_kzalloc(&pdev->dev, sizeof(struct bcl_context), GFP_KERNEL); if (!bcl) { pr_err("Cannot allocate bcl_context\n"); return -ENOMEM; } /* For BCL */ /* Init default BCL params */ if (of_property_read_bool(pdev->dev.of_node, "qcom,bcl-enable")) bcl_mode = BCL_DEVICE_ENABLED; else bcl_mode = BCL_DEVICE_DISABLED; bcl->bcl_mode = BCL_DEVICE_DISABLED; bcl->dev = &pdev->dev; bcl->bcl_monitor_type = BCL_IAVAIL_MONITOR_TYPE; bcl->bcl_threshold_mode[BCL_LOW_THRESHOLD_TYPE] = BCL_IAVAIL_THRESHOLD_DISABLED; bcl->bcl_threshold_mode[BCL_HIGH_THRESHOLD_TYPE] = BCL_IAVAIL_THRESHOLD_DISABLED; bcl->bcl_threshold_value_ma[BCL_LOW_THRESHOLD_TYPE] = 0; bcl->bcl_threshold_value_ma[BCL_HIGH_THRESHOLD_TYPE] = 0; bcl->bcl_vbat_min = BATTERY_VOLTAGE_MIN; snprintf(bcl->bcl_type, BCL_NAME_LENGTH, "%s", bcl_type[BCL_IAVAIL_MONITOR_TYPE]); bcl->bcl_poll_interval_msec = BCL_POLL_INTERVAL; if (of_property_read_bool(pdev->dev.of_node, "qcom,bcl-no-bms")) bcl->bcl_no_bms = true; else bcl->bcl_no_bms = false; bcl_frequency_mask = get_mask_from_core_handle(pdev, "qcom,bcl-freq-control-list"); bcl_hotplug_mask = get_mask_from_core_handle(pdev, "qcom,bcl-hotplug-list"); bcl_soc_hotplug_mask = get_mask_from_core_handle(pdev, "qcom,bcl-soc-hotplug-list"); if (!bcl_hotplug_mask && !bcl_soc_hotplug_mask) bcl_hotplug_enabled = false; else bcl_hotplug_enabled = true; if (of_property_read_bool(pdev->dev.of_node, "qcom,bcl-framework-interface")) ret = probe_bcl_periph_prop(bcl); else ret = probe_btm_properties(bcl); if (ret == -EPROBE_DEFER) return ret; ret = create_bcl_sysfs(bcl); if (ret < 0) { pr_err("Cannot create bcl sysfs\n"); return ret; } cpumask_clear(bcl_cpu_online_mask); bcl_psy.name = bcl_psy_name; bcl_psy.type = POWER_SUPPLY_TYPE_BMS; bcl_psy.get_property = bcl_battery_get_property; bcl_psy.set_property = bcl_battery_set_property; bcl_psy.num_properties = 0; bcl_psy.external_power_changed = power_supply_callback; gbcl = bcl; platform_set_drvdata(pdev, bcl); INIT_DEFERRABLE_WORK(&bcl->bcl_iavail_work, bcl_iavail_work); INIT_WORK(&bcl_hotplug_work, bcl_handle_hotplug); if (bcl_hotplug_enabled) register_cpu_notifier(&bcl_cpu_notifier); if (bcl_mode == BCL_DEVICE_ENABLED) bcl_mode_set(bcl_mode); return 0; }
static int probe(struct platform_device *pdev) { struct spdm_data *data = 0; int ret = -EINVAL; data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; data->action = SPDM_DOWN; platform_set_drvdata(pdev, data); ret = populate_spdm_data(data, pdev); if (ret) goto bad_of; data->bus_scale_client_id = msm_bus_scale_register_client(data->pdata); if (!data->bus_scale_client_id) { ret = -EINVAL; goto no_bus_scaling; } data->cci_clk = clk_get(&pdev->dev, "cci_clk"); if (IS_ERR(data->cci_clk)) { ret = PTR_ERR(data->cci_clk); goto no_clock; } data->profile = devm_kzalloc(&pdev->dev, sizeof(*(data->profile)), GFP_KERNEL); if (!data->profile) { ret = -ENOMEM; goto no_profile; } data->profile->target = change_bw; data->profile->get_dev_status = get_dev_status; data->profile->get_cur_freq = get_cur_bw; data->profile->polling_ms = data->window; data->devfreq = devfreq_add_device(&pdev->dev, data->profile, "spdm_bw_hyp", data); if (IS_ERR(data->devfreq)) { ret = PTR_ERR(data->devfreq); goto no_spdm_device; } spdm_init_debugfs(&pdev->dev); spdm_ipc_log_ctxt = ipc_log_context_create(SPDM_IPC_LOG_PAGES, "devfreq_spdm", 0); if (IS_ERR_OR_NULL(spdm_ipc_log_ctxt)) { pr_err("%s: Failed to create IPC log context\n", __func__); spdm_ipc_log_ctxt = NULL; } return 0; no_spdm_device: devm_kfree(&pdev->dev, data->profile); no_profile: no_clock: msm_bus_scale_unregister_client(data->bus_scale_client_id); no_bus_scaling: devm_kfree(&pdev->dev, data->config_data.ports); bad_of: devm_kfree(&pdev->dev, data); platform_set_drvdata(pdev, NULL); return ret; }
struct sdhci_host *sdhci_pltfm_init(struct platform_device *pdev, const struct sdhci_pltfm_data *pdata) { struct sdhci_host *host; struct sdhci_pltfm_host *pltfm_host; struct device_node *np = pdev->dev.of_node; struct resource *iomem; int ret; iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!iomem) { ret = -ENOMEM; goto err; } if (resource_size(iomem) < 0x100) dev_err(&pdev->dev, "Invalid iomem size!\n"); /* Some PCI-based MFD need the parent here */ if (pdev->dev.parent != &platform_bus && !np) host = sdhci_alloc_host(pdev->dev.parent, sizeof(*pltfm_host)); else host = sdhci_alloc_host(&pdev->dev, sizeof(*pltfm_host)); if (IS_ERR(host)) { ret = PTR_ERR(host); goto err; } pltfm_host = sdhci_priv(host); host->hw_name = dev_name(&pdev->dev); if (pdata && pdata->ops) host->ops = pdata->ops; else host->ops = &sdhci_pltfm_ops; if (pdata) host->quirks = pdata->quirks; host->irq = platform_get_irq(pdev, 0); if (!request_mem_region(iomem->start, resource_size(iomem), mmc_hostname(host->mmc))) { dev_err(&pdev->dev, "cannot request region\n"); ret = -EBUSY; goto err_request; } host->ioaddr = ioremap(iomem->start, resource_size(iomem)); if (!host->ioaddr) { dev_err(&pdev->dev, "failed to remap registers\n"); ret = -ENOMEM; goto err_remap; } platform_set_drvdata(pdev, host); return host; err_remap: release_mem_region(iomem->start, resource_size(iomem)); err_request: sdhci_free_host(host); err: dev_err(&pdev->dev, "%s failed %d\n", __func__, ret); return ERR_PTR(ret); }
static int serial_omap_probe(struct platform_device *pdev) { struct uart_omap_port *up; struct resource *mem, *irq, *dma_tx, *dma_rx; struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data; int ret = -ENOSPC; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } if (!request_mem_region(mem->start, resource_size(mem), pdev->dev.driver->name)) { dev_err(&pdev->dev, "memory region already claimed\n"); return -EBUSY; } dma_rx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx"); if (!dma_rx) { ret = -EINVAL; goto err; } dma_tx = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx"); if (!dma_tx) { ret = -EINVAL; goto err; } up = kzalloc(sizeof(*up), GFP_KERNEL); if (up == NULL) { ret = -ENOMEM; goto do_release_region; } sprintf(up->name, "OMAP UART%d", pdev->id); up->pdev = pdev; up->port.dev = &pdev->dev; up->port.type = PORT_OMAP; up->port.iotype = UPIO_MEM; up->port.irq = irq->start; up->port.regshift = 2; up->port.fifosize = 64; up->port.ops = &serial_omap_pops; up->port.line = pdev->id; up->port.membase = omap_up_info->membase; up->port.mapbase = omap_up_info->mapbase; up->port.flags = omap_up_info->flags; up->port.irqflags = omap_up_info->irqflags; up->port.uartclk = omap_up_info->uartclk; up->uart_dma.uart_base = mem->start; if (omap_up_info->dma_enabled) { up->uart_dma.uart_dma_tx = dma_tx->start; up->uart_dma.uart_dma_rx = dma_rx->start; up->use_dma = 1; up->uart_dma.rx_buf_size = 4096; up->uart_dma.rx_timeout = 2; spin_lock_init(&(up->uart_dma.tx_lock)); spin_lock_init(&(up->uart_dma.rx_lock)); up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE; up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE; } ui[pdev->id] = up; serial_omap_add_console_port(up); ret = uart_add_one_port(&serial_omap_reg, &up->port); if (ret != 0) goto do_release_region; platform_set_drvdata(pdev, up); return 0; err: dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", pdev->id, __func__, ret); do_release_region: release_mem_region(mem->start, resource_size(mem)); return ret; }
static __devinit int wm831x_buckv_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *pdata = wm831x->dev->platform_data; int id; struct wm831x_dcdc *dcdc; struct resource *res; int ret, irq; if (pdata && pdata->wm831x_num) id = (pdata->wm831x_num * 10) + 1; else id = 0; id = pdev->id - id; dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); if (pdata == NULL || pdata->dcdc[id] == NULL) return -ENODEV; dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), GFP_KERNEL); if (dcdc == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } dcdc->wm831x = wm831x; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource\n"); ret = -EINVAL; goto err; } dcdc->base = res->start; snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); dcdc->desc.name = dcdc->name; dcdc->desc.id = id; dcdc->desc.type = REGULATOR_VOLTAGE; dcdc->desc.n_voltages = WM831X_BUCKV_MAX_SELECTOR + 1; dcdc->desc.ops = &wm831x_buckv_ops; dcdc->desc.owner = THIS_MODULE; ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_ON_CONFIG); if (ret < 0) { dev_err(wm831x->dev, "Failed to read ON VSEL: %d\n", ret); goto err; } dcdc->on_vsel = ret & WM831X_DC1_ON_VSEL_MASK; ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL); if (ret < 0) { dev_err(wm831x->dev, "Failed to read DVS VSEL: %d\n", ret); goto err; } dcdc->dvs_vsel = ret & WM831X_DC1_DVS_VSEL_MASK; if (pdata->dcdc[id]) wm831x_buckv_dvs_init(dcdc, pdata->dcdc[id]->driver_data); dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev, pdata->dcdc[id], dcdc, NULL); if (IS_ERR(dcdc->regulator)) { ret = PTR_ERR(dcdc->regulator); dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", id + 1, ret); goto err; } irq = platform_get_irq_byname(pdev, "UV"); ret = request_threaded_irq(irq, NULL, wm831x_dcdc_uv_irq, IRQF_TRIGGER_RISING, dcdc->name, dcdc); if (ret != 0) { dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", irq, ret); goto err_regulator; } irq = platform_get_irq_byname(pdev, "HC"); ret = request_threaded_irq(irq, NULL, wm831x_dcdc_oc_irq, IRQF_TRIGGER_RISING, dcdc->name, dcdc); if (ret != 0) { dev_err(&pdev->dev, "Failed to request HC IRQ %d: %d\n", irq, ret); goto err_uv; } platform_set_drvdata(pdev, dcdc); return 0; err_uv: free_irq(platform_get_irq_byname(pdev, "UV"), dcdc); err_regulator: regulator_unregister(dcdc->regulator); err: if (dcdc->dvs_gpio) gpio_free(dcdc->dvs_gpio); return ret; }
static int mdp_probe(struct platform_device *pdev) { struct platform_device *msm_fb_dev = NULL; struct msm_fb_data_type *mfd; struct msm_fb_panel_data *pdata = NULL; int rc; unsigned long flag; resource_size_t size ; if ((pdev->id == 0) && (pdev->num_resources > 0)) { mdp_pdata = pdev->dev.platform_data; size = resource_size(&pdev->resource[0]); msm_mdp_base = ioremap(pdev->resource[0].start, size); MSM_FB_INFO("MDP HW Base Address = 0x%x\n", (int)pdev->resource[0].start); if (unlikely(!msm_mdp_base)) return -ENOMEM; mdp_resource_initialized = 1; return 0; } if (!mdp_resource_initialized) return -EPERM; mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (pdev_list_cnt >= MSM_FB_MAX_DEV_LIST) return -ENOMEM; msm_fb_dev = platform_device_alloc("msm_fb", pdev->id); if (!msm_fb_dev) return -ENOMEM; ///////////////////////////////////////// // link to the latest pdev ///////////////////////////////////////// mfd->pdev = msm_fb_dev; ///////////////////////////////////////// // add panel data ///////////////////////////////////////// if (platform_device_add_data (msm_fb_dev, pdev->dev.platform_data, sizeof(struct msm_fb_panel_data))) { printk(KERN_ERR "mdp_probe: platform_device_add_data failed!\n"); rc = -ENOMEM; goto mdp_probe_err; } ///////////////////////////////////////// // data chain ///////////////////////////////////////// pdata = msm_fb_dev->dev.platform_data; pdata->on = mdp_on; pdata->off = mdp_off; pdata->next = pdev; switch (mfd->panel.type) { case EXT_MDDI_PANEL: case MDDI_PANEL: case EBI2_PANEL: INIT_WORK(&mfd->dma_update_worker, mdp_lcd_update_workqueue_handler); INIT_WORK(&mfd->vsync_resync_worker, mdp_vsync_resync_workqueue_handler); mfd->hw_refresh = FALSE; if (mfd->panel.type == EXT_MDDI_PANEL) mfd->refresh_timer_duration = (66 * HZ / 1000); // 15 fps -> 66 msec else mfd->refresh_timer_duration = (42 * HZ / 1000); // 24 fps -> 42 msec #ifdef CONFIG_FB_MSM_MDP22 mfd->dma_fnc = mdp_dma2_update; mfd->dma = &dma2_data; #else if (mfd->panel_info.pdest == DISPLAY_1) { mfd->dma_fnc = mdp_dma2_update; mfd->dma = &dma2_data; } else { mfd->dma_fnc = mdp_dma_s_update; mfd->dma = &dma_s_data; } #endif if (mdp_pdata) mfd->vsync_gpio = mdp_pdata->gpio; else mfd->vsync_gpio = -1; mdp_config_vsync(mfd); break; case LCDC_PANEL: pdata->on = mdp_lcdc_on; pdata->off = mdp_lcdc_off; mfd->hw_refresh = TRUE; mfd->cursor_update = mdp_hw_cursor_update; mfd->dma_fnc = mdp_lcdc_update; mfd->dma = &dma2_data; spin_lock_irqsave(&mdp_spin_lock, flag); mdp_intr_mask &= ~MDP_DMA_P_DONE; outp32(MDP_INTR_ENABLE, mdp_intr_mask); spin_unlock_irqrestore(&mdp_spin_lock, flag); break; case TV_PANEL: pdata->on = mdp_dma3_on; pdata->off = mdp_dma3_off; mfd->hw_refresh = TRUE; mfd->dma_fnc = mdp_dma3_update; mfd->dma = &dma3_data; break; default: printk(KERN_ERR "mdp_probe: unknown device type!\n"); rc = -ENODEV; goto mdp_probe_err; } ///////////////////////////////////////// // set driver data ///////////////////////////////////////// platform_set_drvdata(msm_fb_dev, mfd); rc = platform_device_add(msm_fb_dev); if (rc) { goto mdp_probe_err; } pdev_list[pdev_list_cnt++] = pdev; return 0; mdp_probe_err: platform_device_put(msm_fb_dev); return rc; }
static int rfkill_gpio_probe(struct platform_device *pdev) { struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data; struct rfkill_gpio_data *rfkill; struct gpio_desc *gpio; int ret; rfkill = devm_kzalloc(&pdev->dev, sizeof(*rfkill), GFP_KERNEL); if (!rfkill) return -ENOMEM; if (ACPI_HANDLE(&pdev->dev)) { ret = rfkill_gpio_acpi_probe(&pdev->dev, rfkill); if (ret) return ret; } else if (pdata) { rfkill->name = pdata->name; rfkill->type = pdata->type; } else { return -ENODEV; } rfkill->clk = devm_clk_get(&pdev->dev, NULL); gpio = devm_gpiod_get(&pdev->dev, "reset"); if (!IS_ERR(gpio)) { ret = gpiod_direction_output(gpio, 0); if (ret) return ret; rfkill->reset_gpio = gpio; } gpio = devm_gpiod_get(&pdev->dev, "shutdown"); if (!IS_ERR(gpio)) { ret = gpiod_direction_output(gpio, 0); if (ret) return ret; rfkill->shutdown_gpio = gpio; } /* Make sure at-least one of the GPIO is defined and that * a name is specified for this instance */ if ((!rfkill->reset_gpio && !rfkill->shutdown_gpio) || !rfkill->name) { dev_err(&pdev->dev, "invalid platform data\n"); return -EINVAL; } rfkill->rfkill_dev = rfkill_alloc(rfkill->name, &pdev->dev, rfkill->type, &rfkill_gpio_ops, rfkill); if (!rfkill->rfkill_dev) return -ENOMEM; ret = rfkill_register(rfkill->rfkill_dev); if (ret < 0) return ret; platform_set_drvdata(pdev, rfkill); dev_info(&pdev->dev, "%s device registered.\n", rfkill->name); return 0; }
/** * s3c_hwmon_probe - device probe entry. * @dev: The device being probed. */ static int __devinit s3c_hwmon_probe(struct platform_device *dev) { struct s3c_hwmon_pdata *pdata = dev->dev.platform_data; struct s3c_hwmon *hwmon; int ret = 0; int i; if (!pdata) { dev_err(&dev->dev, "no platform data supplied\n"); return -EINVAL; } hwmon = kzalloc(sizeof(struct s3c_hwmon), GFP_KERNEL); if (hwmon == NULL) { dev_err(&dev->dev, "no memory\n"); return -ENOMEM; } platform_set_drvdata(dev, hwmon); init_MUTEX(&hwmon->lock); /* Register with the core ADC driver. */ hwmon->client = s3c_adc_register(dev, NULL, NULL, 0); if (IS_ERR(hwmon->client)) { dev_err(&dev->dev, "cannot register adc\n"); ret = PTR_ERR(hwmon->client); goto err_mem; } /* add attributes for our adc devices. */ ret = s3c_hwmon_add_raw(&dev->dev); if (ret) goto err_registered; /* register with the hwmon core */ hwmon->hwmon_dev = hwmon_device_register(&dev->dev); if (IS_ERR(hwmon->hwmon_dev)) { dev_err(&dev->dev, "error registering with hwmon\n"); ret = PTR_ERR(hwmon->hwmon_dev); goto err_raw_attribute; } for (i = 0; i < ARRAY_SIZE(pdata->in); i++) { struct s3c_hwmon_chcfg *cfg = pdata->in[i]; if (!cfg) continue; if (cfg->mult >= 0x10000) dev_warn(&dev->dev, "channel %d multiplier too large\n", i); if (cfg->div == 0) { dev_err(&dev->dev, "channel %d divider zero\n", i); continue; } ret = s3c_hwmon_create_attr(&dev->dev, pdata->in[i], &hwmon->attrs[i], i); if (ret) { dev_err(&dev->dev, "error creating channel %d\n", i); for (i--; i >= 0; i--) s3c_hwmon_remove_attr(&dev->dev, &hwmon->attrs[i]); goto err_hwmon_register; } } dev_info(dev, "enabled hwmon driver\n"); return 0; err_hwmon_register: hwmon_device_unregister(hwmon->hwmon_dev); err_raw_attribute: s3c_hwmon_remove_raw(&dev->dev); err_registered: s3c_adc_release(hwmon->client); err_mem: kfree(hwmon); return ret; }
static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev) { struct sh_timer_config *cfg = pdev->dev.platform_data; struct resource *res; int irq, ret; ret = -ENXIO; memset(p, 0, sizeof(*p)); p->pdev = pdev; if (!cfg) { dev_err(&p->pdev->dev, "missing platform data\n"); goto err0; } platform_set_drvdata(pdev, p); res = platform_get_resource(p->pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&p->pdev->dev, "failed to get I/O memory\n"); goto err0; } irq = platform_get_irq(p->pdev, 0); if (irq < 0) { dev_err(&p->pdev->dev, "failed to get irq\n"); goto err0; } /* map memory, let mapbase point to our channel */ p->mapbase = ioremap_nocache(res->start, resource_size(res)); if (p->mapbase == NULL) { pr_err("sh_cmt: failed to remap I/O memory\n"); goto err0; } /* request irq using setup_irq() (too early for request_irq()) */ p->irqaction.name = cfg->name; p->irqaction.handler = sh_cmt_interrupt; p->irqaction.dev_id = p; p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL; ret = setup_irq(irq, &p->irqaction); if (ret) { pr_err("sh_cmt: failed to request irq %d\n", irq); goto err1; } /* get hold of clock */ p->clk = clk_get(&p->pdev->dev, cfg->clk); if (IS_ERR(p->clk)) { pr_err("sh_cmt: cannot get clock \"%s\"\n", cfg->clk); ret = PTR_ERR(p->clk); goto err2; } if (resource_size(res) == 6) { p->width = 16; p->overflow_bit = 0x80; p->clear_bits = ~0x80; } else { p->width = 32; p->overflow_bit = 0x8000; p->clear_bits = ~0xc000; } return sh_cmt_register(p, cfg->name, cfg->clockevent_rating, cfg->clocksource_rating); err2: remove_irq(irq, &p->irqaction); err1: iounmap(p->mapbase); err0: return ret; }
static int hisi_thermal_probe(struct platform_device *pdev) { struct hisi_thermal_data *data; struct resource *res; int i; int ret; data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; mutex_init(&data->thermal_lock); data->pdev = pdev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); data->regs = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(data->regs)) { dev_err(&pdev->dev, "failed to get io address\n"); return PTR_ERR(data->regs); } data->irq = platform_get_irq(pdev, 0); if (data->irq < 0) return data->irq; ret = devm_request_threaded_irq(&pdev->dev, data->irq, hisi_thermal_alarm_irq, hisi_thermal_alarm_irq_thread, 0, "hisi_thermal", data); if (ret < 0) { dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret); return ret; } platform_set_drvdata(pdev, data); data->clk = devm_clk_get(&pdev->dev, "thermal_clk"); if (IS_ERR(data->clk)) { ret = PTR_ERR(data->clk); if (ret != -EPROBE_DEFER) dev_err(&pdev->dev, "failed to get thermal clk: %d\n", ret); return ret; } /* enable clock for thermal */ ret = clk_prepare_enable(data->clk); if (ret) { dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret); return ret; } for (i = 0; i < HISI_MAX_SENSORS; ++i) { ret = hisi_thermal_register_sensor(pdev, data, &data->sensors[i], i); if (ret) { dev_err(&pdev->dev, "failed to register thermal sensor: %d\n", ret); goto err_get_sensor_data; } } hisi_thermal_enable_bind_irq_sensor(data); data->irq_enabled = true; for (i = 0; i < HISI_MAX_SENSORS; i++) hisi_thermal_toggle_sensor(&data->sensors[i], true); return 0; err_get_sensor_data: clk_disable_unprepare(data->clk); return ret; }