static int __devinit cyttsp4_spi_probe(struct spi_device *spi) { struct cyttsp4_spi *ts_spi; int rc = 0; struct device *dev = &spi->dev; const struct of_device_id *match; char const *adap_id; dev_dbg(dev, "%s: Probing ...\n", __func__); spi->bits_per_word = CY_SPI_BITS_PER_WORD; spi->mode = SPI_MODE_0; rc = spi_setup(spi); if (rc < 0) { dev_err(dev, "%s: SPI setup error %d\n", __func__, rc); return rc; } ts_spi = kzalloc(sizeof(*ts_spi), GFP_KERNEL); if (ts_spi == NULL) { dev_err(dev, "%s: Error, kzalloc\n", __func__); rc = -ENOMEM; goto error_alloc_data_failed; } match = of_match_device(of_match_ptr(cyttsp4_spi_of_match), dev); if (match) { rc = of_property_read_string(dev->of_node, "cy,adapter_id", &adap_id); if (rc) { dev_err(dev, "%s: OF error rc=%d\n", __func__, rc); goto error_free_data; } cyttsp4_devtree_register_devices(dev); } else { adap_id = dev_get_platdata(dev); } mutex_init(&ts_spi->lock); ts_spi->client = spi; ts_spi->id = (adap_id) ? adap_id : CYTTSP4_SPI_NAME; dev_set_drvdata(&spi->dev, ts_spi); dev_dbg(dev, "%s: add adap='%s' (CYTTSP4_SPI_NAME=%s)\n", __func__, ts_spi->id, CYTTSP4_SPI_NAME); pm_runtime_enable(&spi->dev); rc = cyttsp4_add_adapter(ts_spi->id, &ops, dev); if (rc) { dev_err(dev, "%s: Error on probe %s\n", __func__, CYTTSP4_SPI_NAME); goto add_adapter_err; } dev_info(dev, "%s: Successful prob %s\n", __func__, CYTTSP4_SPI_NAME); return 0; add_adapter_err: pm_runtime_disable(&spi->dev); dev_set_drvdata(&spi->dev, NULL); error_free_data: kfree(ts_spi); error_alloc_data_failed: return rc; }
static int __devinit fsa9485_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct fsa9485_usbsw *usbsw; int ret = 0; struct input_dev *input; struct device *switch_dev; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; input = input_allocate_device(); usbsw = kzalloc(sizeof(struct fsa9485_usbsw), GFP_KERNEL); if (!usbsw || !input) { dev_err(&client->dev, "failed to allocate driver data\n"); kfree(usbsw); return -ENOMEM; } usbsw->input = input; input->name = client->name; input->phys = "deskdock-key/input0"; input->dev.parent = &client->dev; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0001; /* Enable auto repeat feature of Linux input subsystem */ __set_bit(EV_REP, input->evbit); input_set_capability(input, EV_KEY, KEY_VOLUMEUP); input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN); input_set_capability(input, EV_KEY, KEY_PLAYPAUSE); input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG); input_set_capability(input, EV_KEY, KEY_NEXTSONG); ret = input_register_device(input); if (ret) { dev_err(&client->dev, "input_register_device %s: err %d\n", __func__, ret); input_free_device(input); kfree(usbsw); return ret; } usbsw->client = client; usbsw->pdata = client->dev.platform_data; if (!usbsw->pdata) goto fail1; i2c_set_clientdata(client, usbsw); mutex_init(&usbsw->mutex); local_usbsw = usbsw; if (usbsw->pdata->cfg_gpio) usbsw->pdata->cfg_gpio(); fsa9485_reg_init(usbsw); uart_connecting = 0; ret = sysfs_create_group(&client->dev.kobj, &fsa9485_group); if (ret) { dev_err(&client->dev, "failed to create fsa9485 attribute group\n"); goto fail2; } /* make sysfs node /sys/class/sec/switch/usb_state */ switch_dev = device_create(sec_class, NULL, 0, NULL, "switch"); if (IS_ERR(switch_dev)) { pr_err("[FSA9485] Failed to create device (switch_dev)!\n"); ret = PTR_ERR(switch_dev); goto fail2; } ret = device_create_file(switch_dev, &dev_attr_usb_state); if (ret < 0) { pr_err("[FSA9485] Failed to create file (usb_state)!\n"); goto err_create_file_state; } ret = device_create_file(switch_dev, &dev_attr_adc); if (ret < 0) { pr_err("[FSA9485] Failed to create file (adc)!\n"); goto err_create_file_adc; } ret = device_create_file(switch_dev, &dev_attr_reset_switch); if (ret < 0) { pr_err("[FSA9485] Failed to create file (reset_switch)!\n"); goto err_create_file_reset_switch; } dev_set_drvdata(switch_dev, usbsw); /* fsa9485 dock init*/ if (usbsw->pdata->dock_init) usbsw->pdata->dock_init(); /* fsa9485 reset */ if (usbsw->pdata->reset_cb) usbsw->pdata->reset_cb(); /* set fsa9485 init flag. */ if (usbsw->pdata->set_init_flag) usbsw->pdata->set_init_flag(); /* initial cable detection */ INIT_DELAYED_WORK(&usbsw->init_work, fsa9485_init_detect); schedule_delayed_work(&usbsw->init_work, msecs_to_jiffies(2700)); return 0; err_create_file_reset_switch: device_remove_file(switch_dev, &dev_attr_reset_switch); err_create_file_adc: device_remove_file(switch_dev, &dev_attr_adc); err_create_file_state: device_remove_file(switch_dev, &dev_attr_usb_state); fail2: if (client->irq) free_irq(client->irq, usbsw); fail1: input_unregister_device(input); mutex_destroy(&usbsw->mutex); kfree(usbsw); return ret; }
/* Function containing the "meat" of the probe mechanism - this is used by * the OpenFirmware probe as well as the standard platform device mechanism. * This is exported to allow polymorphic drivers to invoke it. * @param name - Name of the instance * @param pdev - Platform device structure * @param addressRange - Resource describing the hardware's I/O range * @param numChannels - Number of channels of output */ int labx_audio_meters_probe(const char *name, struct platform_device *pdev, struct resource *addressRange, u32 numChannels) { struct labx_audio_meters_pdev *audio_meters_pdev; uint32_t deviceIndex; int32_t ret; /* Create and populate a device structure */ audio_meters_pdev = (struct labx_audio_meters_pdev*) kzalloc(sizeof(struct labx_audio_meters_pdev), GFP_KERNEL); if(!audio_meters_pdev) return(-ENOMEM); /* Request and map the device's I/O memory region into uncacheable space */ audio_meters_pdev->physicalAddress = addressRange->start; audio_meters_pdev->addressRangeSize = ((addressRange->end - addressRange->start) + 1); snprintf(audio_meters_pdev->name, NAME_MAX_SIZE, "%s%d", name, instanceCount++); audio_meters_pdev->name[NAME_MAX_SIZE - 1] = '\0'; if(request_mem_region(audio_meters_pdev->physicalAddress, audio_meters_pdev->addressRangeSize, audio_meters_pdev->name) == NULL) { ret = -ENOMEM; goto free; } audio_meters_pdev->virtualAddress = (void*) ioremap_nocache(audio_meters_pdev->physicalAddress, audio_meters_pdev->addressRangeSize); if(!audio_meters_pdev->virtualAddress) { ret = -ENOMEM; goto release; } printk("AM virtualAddress = 0x%08X, phys = 0x%08X, size = 0x%08X\n", (uint32_t) audio_meters_pdev->virtualAddress, (uint32_t) audio_meters_pdev->physicalAddress, audio_meters_pdev->addressRangeSize); audio_meters_pdev->numChannels = numChannels; printk(" Audio Meters interface found at 0x%08X: %d channels\n", (uint32_t) audio_meters_pdev->physicalAddress, audio_meters_pdev->numChannels); audio_meters_pdev->miscdev.minor = MISC_DYNAMIC_MINOR; audio_meters_pdev->miscdev.name = audio_meters_pdev->name; audio_meters_pdev->miscdev.fops = &labx_audio_meters_fops; ret = misc_register(&audio_meters_pdev->miscdev); if (ret) { printk(KERN_WARNING DRIVER_NAME ": Unable to register misc device.\n"); goto unmap; } platform_set_drvdata(pdev, audio_meters_pdev); audio_meters_pdev->pdev = pdev; dev_set_drvdata(audio_meters_pdev->miscdev.this_device, audio_meters_pdev); /* Locate and occupy the first available device index for future navigation in * the call to labx_audio_meters_open() */ for (deviceIndex = 0; deviceIndex < MAX_AM_DEVICES; deviceIndex++) { if (NULL == devices[deviceIndex]) { devices[deviceIndex] = audio_meters_pdev; break; } } /* Ensure that we haven't been asked to probe for too many devices */ if(deviceIndex >= MAX_AM_DEVICES) { printk(KERN_WARNING DRIVER_NAME ": Maximum device count (%d) exceeded during probe\n", MAX_AM_DEVICES); goto unmap; } /* Return success */ return(0); unmap: iounmap(audio_meters_pdev->virtualAddress); release: release_mem_region(audio_meters_pdev->physicalAddress, audio_meters_pdev->addressRangeSize); free: kfree(audio_meters_pdev); return(ret); }
static int __devinit esp_jazz_probe(struct platform_device *dev) { struct scsi_host_template *tpnt = &scsi_esp_template; struct Scsi_Host *host; struct esp *esp; struct resource *res; int err; host = scsi_host_alloc(tpnt, sizeof(struct esp)); err = -ENOMEM; if (!host) goto fail; host->max_id = 8; esp = shost_priv(host); esp->host = host; esp->dev = dev; esp->ops = &jazz_esp_ops; res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!res) goto fail_unlink; esp->regs = (void __iomem *)res->start; if (!esp->regs) goto fail_unlink; res = platform_get_resource(dev, IORESOURCE_MEM, 1); if (!res) goto fail_unlink; esp->dma_regs = (void __iomem *)res->start; esp->command_block = dma_alloc_coherent(esp->dev, 16, &esp->command_block_dma, GFP_KERNEL); if (!esp->command_block) goto fail_unmap_regs; host->irq = platform_get_irq(dev, 0); err = request_irq(host->irq, scsi_esp_intr, IRQF_SHARED, "ESP", esp); if (err < 0) goto fail_unmap_command_block; esp->scsi_id = 7; esp->host->this_id = esp->scsi_id; esp->scsi_id_mask = (1 << esp->scsi_id); esp->cfreq = 40000000; dev_set_drvdata(&dev->dev, esp); err = scsi_esp_register(esp, &dev->dev); if (err) goto fail_free_irq; return 0; fail_free_irq: free_irq(host->irq, esp); fail_unmap_command_block: dma_free_coherent(esp->dev, 16, esp->command_block, esp->command_block_dma); fail_unmap_regs: fail_unlink: scsi_host_put(host); fail: return err; }
static int imx_drm_bind(struct device *dev) { struct drm_device *drm; int ret; drm = drm_dev_alloc(&imx_drm_driver, dev); if (IS_ERR(drm)) return PTR_ERR(drm); /* * enable drm irq mode. * - with irq_enabled = true, we can use the vblank feature. * * P.S. note that we wouldn't use drm irq handler but * just specific driver own one instead because * drm framework supports only one irq handler and * drivers can well take care of their interrupts */ drm->irq_enabled = true; /* * set max width and height as default value(4096x4096). * this value would be used to check framebuffer size limitation * at drm_mode_addfb(). */ drm->mode_config.min_width = 1; drm->mode_config.min_height = 1; drm->mode_config.max_width = 4096; drm->mode_config.max_height = 4096; drm->mode_config.funcs = &imx_drm_mode_config_funcs; drm->mode_config.helper_private = &imx_drm_mode_config_helpers; drm->mode_config.allow_fb_modifiers = true; drm_mode_config_init(drm); ret = drm_vblank_init(drm, MAX_CRTC); if (ret) goto err_kms; dev_set_drvdata(dev, drm); /* Now try and bind all our sub-components */ ret = component_bind_all(dev, drm); if (ret) goto err_kms; drm_mode_config_reset(drm); /* * All components are now initialised, so setup the fb helper. * The fb helper takes copies of key hardware information, so the * crtcs/connectors/encoders must not change after this point. */ if (legacyfb_depth != 16 && legacyfb_depth != 32) { dev_warn(dev, "Invalid legacyfb_depth. Defaulting to 16bpp\n"); legacyfb_depth = 16; } drm_kms_helper_poll_init(drm); ret = drm_dev_register(drm, 0); if (ret) goto err_poll_fini; drm_fbdev_generic_setup(drm, legacyfb_depth); return 0; err_poll_fini: drm_kms_helper_poll_fini(drm); component_unbind_all(drm->dev, drm); err_kms: drm_mode_config_cleanup(drm); drm_dev_put(drm); return ret; }
static struct usbhsh_device *usbhsh_device_attach(struct usbhsh_hpriv *hpriv, struct urb *urb) { struct usbhsh_device *udev = NULL; struct usbhsh_device *udev0 = usbhsh_device0(hpriv); struct usbhsh_device *pos; struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); struct device *dev = usbhsh_hcd_to_dev(hcd); struct usb_device *usbv = usbhsh_urb_to_usbv(urb); struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); unsigned long flags; u16 upphub, hubport; int i; /* * This function should be called only while urb is pointing to device0. * It will attach unused usbhsh_device to urb (usbv), * and initialize device0. * You can use usbhsh_device_get() to get "current" udev, * and usbhsh_usbv_to_udev() is for "attached" udev. */ if (0 != usb_pipedevice(urb->pipe)) { dev_err(dev, "%s fail: urb isn't pointing device0\n", __func__); return NULL; } /******************** spin lock ********************/ usbhs_lock(priv, flags); /* * find unused device */ usbhsh_for_each_udev(pos, hpriv, i) { if (usbhsh_udev_is_used(pos)) continue; udev = pos; break; } if (udev) { /* * usbhsh_usbv_to_udev() * usbhsh_udev_to_usbv() * will be enable */ dev_set_drvdata(&usbv->dev, udev); udev->usbv = usbv; } usbhs_unlock(priv, flags); /******************** spin unlock ******************/ if (!udev) { dev_err(dev, "no free usbhsh_device\n"); return NULL; } if (usbhsh_device_has_endpoint(udev)) { dev_warn(dev, "udev have old endpoint\n"); usbhsh_endpoint_detach_all(hpriv, udev); } if (usbhsh_device_has_endpoint(udev0)) { dev_warn(dev, "udev0 have old endpoint\n"); usbhsh_endpoint_detach_all(hpriv, udev0); } /* uep will be attached */ INIT_LIST_HEAD(&udev0->ep_list_head); INIT_LIST_HEAD(&udev->ep_list_head); /* * set device0 config */ usbhs_set_device_config(priv, 0, 0, 0, usbv->speed); /* * set new device config */ upphub = 0; hubport = 0; if (!usbhsh_connected_to_rhdev(hcd, udev)) { /* if udev is not connected to rhdev, it means parent is Hub */ struct usbhsh_device *parent = usbhsh_device_parent(udev); upphub = usbhsh_device_number(hpriv, parent); hubport = usbhsh_device_hubport(udev); dev_dbg(dev, "%s connecte to Hub [%d:%d](%p)\n", __func__, upphub, hubport, parent); } usbhs_set_device_config(priv, usbhsh_device_number(hpriv, udev), upphub, hubport, usbv->speed); dev_dbg(dev, "%s [%d](%p)\n", __func__, usbhsh_device_number(hpriv, udev), udev); return udev; }
static int qpnp_haptic_probe(struct spmi_device *spmi) { struct qpnp_hap *hap; struct resource *hap_resource; int rc, i; hap = devm_kzalloc(&spmi->dev, sizeof(*hap), GFP_KERNEL); if (!hap) return -ENOMEM; hap->spmi = spmi; hap_resource = spmi_get_resource(spmi, 0, IORESOURCE_MEM, 0); if (!hap_resource) { dev_err(&spmi->dev, "Unable to get haptic base address\n"); return -EINVAL; } hap->base = hap_resource->start; dev_set_drvdata(&spmi->dev, hap); rc = qpnp_hap_parse_dt(hap); if (rc) { dev_err(&spmi->dev, "DT parsing failed\n"); return rc; } rc = qpnp_hap_config(hap); if (rc) { dev_err(&spmi->dev, "hap config failed\n"); return rc; } mutex_init(&hap->lock); mutex_init(&hap->wf_lock); INIT_WORK(&hap->work, qpnp_hap_worker); hrtimer_init(&hap->hap_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hap->hap_timer.function = qpnp_hap_timer; hap->timed_dev.name = "vibrator"; hap->timed_dev.get_time = qpnp_hap_get_time; hap->timed_dev.enable = qpnp_hap_td_enable; rc = timed_output_dev_register(&hap->timed_dev); if (rc < 0) { dev_err(&spmi->dev, "timed_output registration failed\n"); goto timed_output_fail; } for (i = 0; i < ARRAY_SIZE(qpnp_hap_attrs); i++) { rc = sysfs_create_file(&hap->timed_dev.dev->kobj, &qpnp_hap_attrs[i].attr); if (rc < 0) { dev_err(&spmi->dev, "sysfs creation failed\n"); goto sysfs_fail; } } return 0; sysfs_fail: for (i--; i >= 0; i--) sysfs_remove_file(&hap->timed_dev.dev->kobj, &qpnp_hap_attrs[i].attr); timed_output_dev_unregister(&hap->timed_dev); timed_output_fail: cancel_work_sync(&hap->work); hrtimer_cancel(&hap->hap_timer); mutex_destroy(&hap->lock); mutex_destroy(&hap->wf_lock); return rc; }
static int tegra_bbc_proxy_probe(struct platform_device *pdev) { struct tegra_bbc_proxy_platform_data *pdata = pdev->dev.platform_data; struct tegra_bbc_proxy *bbc; struct edp_manager *mgr; struct device_attribute **attrs; struct device_attribute *attr; int ret = 0; /* check for platform data */ if (!pdata) { dev_err(&pdev->dev, "platform data not available\n"); return -ENODEV; } bbc = kzalloc(sizeof(struct tegra_bbc_proxy), GFP_KERNEL); if (!bbc) { dev_err(&pdev->dev, "failed to allocate memory\n"); return -ENOMEM; } if (pdata->modem_boot_edp_client && pdata->edp_manager_name) { mutex_init(&bbc->edp_lock); /* register bbc boot client */ bbc->edp_manager_name = pdata->edp_manager_name; mgr = edp_get_manager(pdata->edp_manager_name); if (!mgr) { dev_err(&pdev->dev, "can't get edp manager\n"); goto error; } bbc->modem_boot_edp_client = pdata->modem_boot_edp_client; ret = edp_register_client(mgr, bbc->modem_boot_edp_client); if (ret) { dev_err(&pdev->dev, "unable to register bbc boot edp client\n"); goto error; } /* request E0 */ ret = edp_update_client_request(bbc->modem_boot_edp_client, 0, NULL); if (ret) { dev_err(&pdev->dev, "unable to set e0 state\n"); goto edp_req_error; } bbc->edp_boot_client_registered = 1; bbc->i_breach_ppm = pdata->i_breach_ppm; bbc->i_thresh_3g_adjperiod = pdata->i_thresh_3g_adjperiod; bbc->i_thresh_lte_adjperiod = pdata->i_thresh_lte_adjperiod; attrs = edp_attributes; while ((attr = *attrs++)) { ret = device_create_file(&pdev->dev, attr); if (ret) { dev_err(&pdev->dev, "can't create sysfs file\n"); goto edp_req_error; } } bbc->edp_initialized = 1; bbc->ap_name = pdata->ap_name; } mutex_init(&bbc->iso_lock); bbc->isomgr_handle = tegra_isomgr_register(TEGRA_ISO_CLIENT_BBC_0, MAX_ISO_BW_REQ, NULL, NULL); if (!bbc->isomgr_handle) goto iso_error; tegra_set_latency_allowance(TEGRA_LA_BBCLLR, 640); /* statically margin for bbc bw */ ret = tegra_isomgr_set_margin(TEGRA_ISO_CLIENT_BBC_0, MAX_ISO_BW_REQ, true); if (ret) dev_err(&pdev->dev, "can't margin for bbc bw\n"); else bbc->margin = MAX_ISO_BW_REQ; /* thermal zones from bbc */ tegra_bbc_thermal_init(); attrs = mc_attributes; while ((attr = *attrs++)) { ret = device_create_file(&pdev->dev, attr); if (ret) { dev_err(&pdev->dev, "can't create sysfs file\n"); goto mc_error; } } bbc->sim0 = regulator_get(&pdev->dev, "vddio_sim0"); if (IS_ERR(bbc->sim0)) { dev_err(&pdev->dev, "vddio_sim0 regulator get failed\n"); bbc->sim0 = NULL; goto sim_error; } bbc->sim1 = regulator_get(&pdev->dev, "vddio_sim1"); if (IS_ERR(bbc->sim1)) { dev_err(&pdev->dev, "vddio_sim1 regulator get failed\n"); bbc->sim1 = NULL; goto sim_error; } attrs = sim_attributes; while ((attr = *attrs++)) { ret = device_create_file(&pdev->dev, attr); if (ret) { dev_err(&pdev->dev, "can't create sysfs file\n"); goto sim_error; } } bbc->rf1v7 = regulator_get(&pdev->dev, "vdd_1v7_rf"); if (IS_ERR(bbc->rf1v7)) { dev_info(&pdev->dev, "vdd_1v7_rf regulator not available\n"); bbc->rf1v7 = NULL; } bbc->rf2v65 = regulator_get(&pdev->dev, "vdd_2v65_rf"); if (IS_ERR(bbc->rf2v65)) { dev_info(&pdev->dev, "vdd_2v65_rf regulator not available\n"); bbc->rf2v65 = NULL; } if (bbc->rf1v7 && bbc->rf2v65) { attrs = rf_attributes; while ((attr = *attrs++)) { ret = device_create_file(&pdev->dev, attr); if (ret) { dev_err(&pdev->dev, "can't create sysfs file\n"); goto rf_error; } } } dev_set_drvdata(&pdev->dev, bbc); return 0; rf_error: regulator_put(bbc->rf1v7); regulator_put(bbc->rf2v65); sim_error: regulator_put(bbc->sim0); regulator_put(bbc->sim1); attrs = mc_attributes; while ((attr = *attrs++)) device_remove_file(&pdev->dev, attr); mc_error: tegra_isomgr_unregister(bbc->isomgr_handle); iso_error: if (bbc->edp_initialized) { attrs = edp_attributes; while ((attr = *attrs++)) device_remove_file(&pdev->dev, attr); } edp_req_error: if (bbc->edp_boot_client_registered) edp_unregister_client(bbc->modem_boot_edp_client); error: kfree(bbc); return ret; }
static int __devinit qpnp_vibrator_probe(struct spmi_device *spmi) { struct qpnp_vib *vib; const __be32 *temp_dt; struct resource *vib_resource; int rc; u8 val; vib = devm_kzalloc(&spmi->dev, sizeof(*vib), GFP_KERNEL); if (!vib) return -ENOMEM; vib->spmi = spmi; temp_dt = of_get_property(spmi->dev.of_node, "qcom,qpnp-vib-timeout-ms", NULL); if (temp_dt) vib->timeout = be32_to_cpu(*temp_dt); else vib->timeout = QPNP_VIB_DEFAULT_TIMEOUT; temp_dt = of_get_property(spmi->dev.of_node, "qcom,qpnp-vib-vtg-level-mV", NULL); if (temp_dt) vib->vtg_level = be32_to_cpu(*temp_dt); else vib->vtg_level = QPNP_VIB_DEFAULT_VTG_LVL; vib->vtg_level /= 100; vib_resource = spmi_get_resource(spmi, 0, IORESOURCE_MEM, 0); if (!vib_resource) { dev_err(&spmi->dev, "Unable to get vibrator base address\n"); return -EINVAL; } vib->base = vib_resource->start; rc = qpnp_vib_read_u8(vib, &val, QPNP_VIB_VTG_CTL(vib->base)); if (rc < 0) return rc; vib->reg_vtg_ctl = val; rc = qpnp_vib_read_u8(vib, &val, QPNP_VIB_EN_CTL(vib->base)); if (rc < 0) return rc; vib->reg_en_ctl = val; spin_lock_init(&vib->lock); INIT_WORK(&vib->work, qpnp_vib_update); hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vib->vib_timer.function = qpnp_vib_timer_func; vib->timed_dev.name = "vibrator"; vib->timed_dev.get_time = qpnp_vib_get_time; vib->timed_dev.enable = qpnp_vib_enable; dev_set_drvdata(&spmi->dev, vib); rc = timed_output_dev_register(&vib->timed_dev); if (rc < 0) return rc; rc = device_create_file(vib->timed_dev.dev, &dev_attr_voltage_level); if (rc < 0) { pr_err("[VIB] %s, create sysfs fail: voltage_level\n", __func__); } #ifdef CONFIG_VIB_TRIGGERS vib->enabler.name = "qpnp-vibrator"; vib->enabler.default_trigger = "vibrator"; vib->enabler.enable = qpnp_vib_trigger_enable; vib->enabler.trigger_data = vib; vib_trigger_enabler_register(&vib->enabler); #endif vib_dev = vib; return rc; }
static int INITSECTION cmos_do_probe(struct device *dev, struct resource *ports, int rtc_irq) { struct cmos_rtc_board_info *info = dev->platform_data; int retval = 0; unsigned char rtc_control; unsigned address_space; /* there can be only one ... */ if (cmos_rtc.dev) return -EBUSY; if (!ports) return -ENODEV; /* Claim I/O ports ASAP, minimizing conflict with legacy driver. * * REVISIT non-x86 systems may instead use memory space resources * (needing ioremap etc), not i/o space resources like this ... */ ports = request_region(ports->start, ports->end + 1 - ports->start, driver_name); if (!ports) { dev_dbg(dev, "i/o registers already in use\n"); return -EBUSY; } cmos_rtc.irq = rtc_irq; cmos_rtc.iomem = ports; /* Heuristic to deduce NVRAM size ... do what the legacy NVRAM * driver did, but don't reject unknown configs. Old hardware * won't address 128 bytes. Newer chips have multiple banks, * though they may not be listed in one I/O resource. */ #if defined(CONFIG_ATARI) address_space = 64; #elif defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__sparc__) address_space = 128; #else #warning Assuming 128 bytes of RTC+NVRAM address space, not 64 bytes. address_space = 128; #endif if (can_bank2 && ports->end > (ports->start + 1)) address_space = 256; /* For ACPI systems extension info comes from the FADT. On others, * board specific setup provides it as appropriate. Systems where * the alarm IRQ isn't automatically a wakeup IRQ (like ACPI, and * some almost-clones) can provide hooks to make that behave. * * Note that ACPI doesn't preclude putting these registers into * "extended" areas of the chip, including some that we won't yet * expect CMOS_READ and friends to handle. */ if (info) { if (info->rtc_day_alarm && info->rtc_day_alarm < 128) cmos_rtc.day_alrm = info->rtc_day_alarm; if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128) cmos_rtc.mon_alrm = info->rtc_mon_alarm; if (info->rtc_century && info->rtc_century < 128) cmos_rtc.century = info->rtc_century; if (info->wake_on && info->wake_off) { cmos_rtc.wake_on = info->wake_on; cmos_rtc.wake_off = info->wake_off; } } cmos_rtc.rtc = rtc_device_register(driver_name, dev, &cmos_rtc_ops, THIS_MODULE); if (IS_ERR(cmos_rtc.rtc)) { retval = PTR_ERR(cmos_rtc.rtc); goto cleanup0; } cmos_rtc.dev = dev; dev_set_drvdata(dev, &cmos_rtc); rename_region(ports, dev_name(&cmos_rtc.rtc->dev)); spin_lock_irq(&rtc_lock); /* force periodic irq to CMOS reset default of 1024Hz; * * REVISIT it's been reported that at least one x86_64 ALI mobo * doesn't use 32KHz here ... for portability we might need to * do something about other clock frequencies. */ cmos_rtc.rtc->irq_freq = 1024; hpet_set_periodic_freq(cmos_rtc.rtc->irq_freq); CMOS_WRITE(RTC_REF_CLCK_32KHZ | 0x06, RTC_FREQ_SELECT); /* disable irqs */ cmos_irq_disable(&cmos_rtc, RTC_PIE | RTC_AIE | RTC_UIE); rtc_control = CMOS_READ(RTC_CONTROL); spin_unlock_irq(&rtc_lock); /* FIXME teach the alarm code how to handle binary mode; * <asm-generic/rtc.h> doesn't know 12-hour mode either. */ if (is_valid_irq(rtc_irq) && (!(rtc_control & RTC_24H) || (rtc_control & (RTC_DM_BINARY)))) { dev_dbg(dev, "only 24-hr BCD mode supported\n"); retval = -ENXIO; goto cleanup1; } if (is_valid_irq(rtc_irq)) { irq_handler_t rtc_cmos_int_handler; if (is_hpet_enabled()) { int err; rtc_cmos_int_handler = hpet_rtc_interrupt; err = hpet_register_irq_handler(cmos_interrupt); if (err != 0) { printk(KERN_WARNING "hpet_register_irq_handler " " failed in rtc_init()."); goto cleanup1; } } else rtc_cmos_int_handler = cmos_interrupt; retval = request_irq(rtc_irq, rtc_cmos_int_handler, IRQF_DISABLED, dev_name(&cmos_rtc.rtc->dev), cmos_rtc.rtc); if (retval < 0) { dev_dbg(dev, "IRQ %d is already in use\n", rtc_irq); goto cleanup1; } } hpet_rtc_timer_init(); /* export at least the first block of NVRAM */ nvram.size = address_space - NVRAM_OFFSET; retval = sysfs_create_bin_file(&dev->kobj, &nvram); if (retval < 0) { dev_dbg(dev, "can't create nvram file? %d\n", retval); goto cleanup2; } pr_info("%s: %s%s, %zd bytes nvram%s\n", dev_name(&cmos_rtc.rtc->dev), !is_valid_irq(rtc_irq) ? "no alarms" : cmos_rtc.mon_alrm ? "alarms up to one year" : cmos_rtc.day_alrm ? "alarms up to one month" : "alarms up to one day", cmos_rtc.century ? ", y3k" : "", nvram.size, is_hpet_enabled() ? ", hpet irqs" : ""); return 0; cleanup2: if (is_valid_irq(rtc_irq)) free_irq(rtc_irq, cmos_rtc.rtc); cleanup1: cmos_rtc.dev = NULL; rtc_device_unregister(cmos_rtc.rtc); cleanup0: release_region(ports->start, ports->end + 1 - ports->start); return retval; }
/** Shared device initialization code */ static int __devinit xilinx_iic_setup( struct device *device, struct device_node *node, struct resource *r_mem, struct resource *r_irq, u32 ten_bit_addr, u32 gpo_width) { XIic_Config xiic_cfg; struct xiic_data *dev; char *scan_results; int error; /* Allocate the dev and zero it out. */ dev = kmalloc(sizeof(struct xiic_data), GFP_KERNEL); if (!dev) { dev_err(device, "Cannot allocate struct xiic_data\n"); error = -ENOMEM; goto out2; } memset(dev, 0, sizeof(struct xiic_data)); dev_set_drvdata(device, dev); dev->irq = r_irq->start; /* initialize fields to satisfy i2c */ dev->index = 0; init_completion(&dev->complete); memset(&xiic_cfg, 0, sizeof(XIic_Config)); xiic_cfg.DeviceId = 0; /* Change the addresses to be virtual; save the old ones to restore. */ dev->base = r_mem->start; xiic_cfg.BaseAddress = (u32) ioremap(r_mem->start, r_mem->end - r_mem->start + 1); dev->remapped = 1; down(&cfg_sem); xiic_cfg.Has10BitAddr = (int)ten_bit_addr; xiic_cfg.GpOutWidth = (u8)gpo_width; /* Tell the Xilinx code to bring this IIC interface up. */ if (XIic_CfgInitialize(&dev->Iic, &xiic_cfg, xiic_cfg.BaseAddress) != XST_SUCCESS) { up(&cfg_sem); dev_err(device, "could not initialize device.\n"); error = -ENODEV; goto out; } up(&cfg_sem); XIic_SetRecvHandler(&dev->Iic, (void *)dev, RecvHandler); XIic_SetSendHandler(&dev->Iic, (void *)dev, SendHandler); XIic_SetStatusHandler(&dev->Iic, (void *)dev, StatusHandler); /* Grab the IRQ */ error = request_irq(dev->irq, xiic_interrupt, 0, dev->adap.name, dev); if (error) { dev_err(device, "could not allocate interrupt %d.\n", dev->irq); goto out; } dev->reqirq = 1; if (XIic_Start(&dev->Iic) != XST_SUCCESS) { dev_err(device, "could not start device\n"); error = -ENODEV; goto out; } dev->started = 1; /* Now tell the core I2C code about our new device. */ strcpy(dev->adap.name, "xilinx-iic"); dev->adap.dev.of_node = node; dev->adap.algo = &xiic_algo; dev->adap.algo_data = NULL; dev->adap.timeout = XIIC_TIMEOUT; dev->adap.retries = XIIC_RETRY; error = i2c_add_adapter(&dev->adap); if (error) { dev_err(device, "could not add i2c adapter\n"); goto out; } dev->added = 1; printk("%s #%d at 0x%08X mapped to 0x%08X, irq=%d\n", dev->adap.name, dev->index, dev->base, (unsigned int)dev->Iic.BaseAddress, dev->irq); if (scan) { scan_results = xilinx_iic_do_scan(dev); if (scan_results) { printk(scan_results); kfree(scan_results); } } of_register_i2c_devices(&dev->adap, node); error = device_create_file(device, &dev_attr_scan); out: if (error) xilinx_iic_remove(device); out2: return error; }
static int __devinit sc26xx_probe(struct platform_device *dev) { struct resource *res; struct uart_sc26xx_port *up; unsigned int *sc26xx_data = dev->dev.platform_data; int err; res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; up = kzalloc(sizeof *up, GFP_KERNEL); if (unlikely(!up)) return -ENOMEM; up->port[0].line = 0; up->port[0].ops = &sc26xx_ops; up->port[0].type = PORT_SC26XX; up->port[0].uartclk = (29491200 / 16); /* arbitrary */ up->port[0].mapbase = res->start; up->port[0].membase = ioremap_nocache(up->port[0].mapbase, 0x40); up->port[0].iotype = UPIO_MEM; up->port[0].irq = platform_get_irq(dev, 0); up->port[0].dev = &dev->dev; sc26xx_init_masks(up, 0, sc26xx_data[0]); sc26xx_port = &up->port[0]; up->port[1].line = 1; up->port[1].ops = &sc26xx_ops; up->port[1].type = PORT_SC26XX; up->port[1].uartclk = (29491200 / 16); /* arbitrary */ up->port[1].mapbase = up->port[0].mapbase; up->port[1].membase = up->port[0].membase; up->port[1].iotype = UPIO_MEM; up->port[1].irq = up->port[0].irq; up->port[1].dev = &dev->dev; sc26xx_init_masks(up, 1, sc26xx_data[1]); err = uart_register_driver(&sc26xx_reg); if (err) goto out_free_port; sc26xx_reg.tty_driver->name_base = sc26xx_reg.minor; err = uart_add_one_port(&sc26xx_reg, &up->port[0]); if (err) goto out_unregister_driver; err = uart_add_one_port(&sc26xx_reg, &up->port[1]); if (err) goto out_remove_port0; err = request_irq(up->port[0].irq, sc26xx_interrupt, 0, "sc26xx", up); if (err) goto out_remove_ports; dev_set_drvdata(&dev->dev, up); return 0; out_remove_ports: uart_remove_one_port(&sc26xx_reg, &up->port[1]); out_remove_port0: uart_remove_one_port(&sc26xx_reg, &up->port[0]); out_unregister_driver: uart_unregister_driver(&sc26xx_reg); out_free_port: kfree(up); sc26xx_port = NULL; return err; }
static int __devinit sdhci_s3c_probe(struct platform_device *pdev) { struct s3c_sdhci_platdata *pdata = pdev->dev.platform_data; struct device *dev = &pdev->dev; struct sdhci_host *host; struct sdhci_s3c *sc; struct resource *res; int ret, irq, ptr, clks; if (!pdata) { 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; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(dev, "no memory specified\n"); return -ENOENT; } 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); } 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 = pdata->clocks[ptr]; if (name == NULL) continue; clk = clk_get(dev, name); if (IS_ERR(clk)) { dev_err(dev, "failed to get clock %s\n", name); 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; } sc->ioarea = request_mem_region(res->start, resource_size(res), mmc_hostname(host->mmc)); if (!sc->ioarea) { dev_err(dev, "failed to reserve register area\n"); ret = -ENXIO; goto err_req_regs; } host->ioaddr = ioremap_nocache(res->start, resource_size(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; #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; if (pdata->cd_type == S3C_SDHCI_CD_NONE) host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT) host->mmc->caps = MMC_CAP_NONREMOVABLE; if (pdata->host_caps) host->mmc->caps |= pdata->host_caps; /* if vmmc_name is in pdata */ if (pdata->vmmc_name) host->vmmc_name = pdata->vmmc_name; 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 (pdata->clk_type) { 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; /* for BCM WIFI */ if (pdata->pm_flags) host->mmc->pm_flags |= pdata->pm_flags; /* To turn on vmmc regulator only if sd card exists, GPIO pin for card detection should be initialized. Moved from sdhci_s3c_setup_card_detect_gpio() function */ if (pdata->cd_type == S3C_SDHCI_CD_GPIO && gpio_is_valid(pdata->ext_cd_gpio)) { if (gpio_request(pdata->ext_cd_gpio, "SDHCI EXT CD") == 0) { sc->ext_cd_gpio = pdata->ext_cd_gpio; sc->ext_cd_gpio_invert = pdata->ext_cd_gpio_invert; mmc_host_sd_set_present(host->mmc); if (sd_detection_cmd_dev == NULL && sc->ext_cd_gpio) { sd_detection_cmd_dev = device_create(sec_class, NULL, 0, NULL, "sdcard"); if (IS_ERR(sd_detection_cmd_dev)) pr_err("Fail to create sysfs dev\n"); if (device_create_file(sd_detection_cmd_dev, &dev_attr_status) < 0) pr_err("Fail to create sysfs file\n"); dev_set_drvdata(sd_detection_cmd_dev, sc); } #ifdef CONFIG_MIDAS_COMMON /* set TF_EN gpio as OUTPUT */ gpio_request(GPIO_TF_EN, "TF_EN"); gpio_direction_output(GPIO_TF_EN, 1); s3c_gpio_cfgpin(GPIO_TF_EN, S3C_GPIO_SFN(1)); s3c_gpio_setpull(GPIO_TF_EN, S3C_GPIO_PULL_NONE); #endif } else { dev_err(dev, "cannot request gpio for card detect\n"); } } ret = sdhci_add_host(host); if (ret) { dev_err(dev, "sdhci_add_host() failed\n"); goto err_add_host; } /* if it is set SDHCI_QUIRK_BROKEN_CARD_DETECTION before calling sdhci_add_host, in sdhci_add_host, MMC_CAP_NEEDS_POLL flag will be set. The flag S3C_SDHCI_CD_PERMANENT dose not need to detect a card by polling. */ if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT || \ pdata->cd_type == S3C_SDHCI_CD_GPIO) host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; /* 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); #ifdef CONFIG_MACH_PX if (pdata->ext_pdev) pdata->ext_pdev(pdev); #endif } 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_add_host: release_resource(sc->ioarea); kfree(sc->ioarea); err_req_regs: for (ptr = 0; ptr < MAX_BUS_CLK; 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 __init tahvo_usb_probe(struct platform_device *pdev) { struct tahvo_usb *tu; struct device *dev = &pdev->dev; int ret; ret = tahvo_get_status(); if (!ret) return -ENODEV; dev_dbg(dev, "probe\n"); /* Create driver data */ tu = kzalloc(sizeof(*tu), GFP_KERNEL); if (!tu) return -ENOMEM; tu->pt_dev = container_of(dev, struct platform_device, dev); #ifdef CONFIG_USB_OTG /* Default mode */ #ifdef CONFIG_CBUS_TAHVO_USB_HOST_BY_DEFAULT tu->tahvo_mode = TAHVO_MODE_HOST; #else tu->tahvo_mode = TAHVO_MODE_PERIPHERAL; #endif #endif INIT_WORK(&tu->irq_work, tahvo_usb_irq_work); mutex_init(&tu->serialize); /* Set initial state, so that we generate kevents only on * state changes */ tu->vbus_state = tahvo_read_reg(TAHVO_REG_IDSR) & 0x01; /* We cannot enable interrupt until omap_udc is initialized */ ret = tahvo_request_irq(TAHVO_INT_VBUSON, tahvo_usb_vbus_interrupt, (unsigned long) tu, "vbus_interrupt"); if (ret != 0) { kfree(tu); printk(KERN_ERR "Could not register Tahvo interrupt for VBUS\n"); return ret; } /* Attributes */ ret = device_create_file(dev, &dev_attr_vbus_state); #ifdef CONFIG_USB_OTG ret |= device_create_file(dev, &dev_attr_otg_mode); #endif if (ret) printk(KERN_ERR "attribute creation failed: %d\n", ret); /* Create OTG interface */ tahvo_usb_power_off(tu); tu->otg.state = OTG_STATE_UNDEFINED; tu->otg.label = DRIVER_NAME; tu->otg.set_host = tahvo_usb_set_host; tu->otg.set_peripheral = tahvo_usb_set_peripheral; tu->otg.set_power = tahvo_usb_set_power; tu->otg.set_suspend = tahvo_usb_set_suspend; tu->otg.start_srp = tahvo_usb_start_srp; tu->otg.start_hnp = tahvo_usb_start_hnp; ret = otg_set_transceiver(&tu->otg); if (ret < 0) { printk(KERN_ERR "Cannot register USB transceiver\n"); kfree(tu); tahvo_free_irq(TAHVO_INT_VBUSON); return ret; } dev_set_drvdata(dev, tu); /* Act upon current vbus state once at startup. A vbus state irq may or * may not be generated in addition to this. */ schedule_work(&tu->irq_work); return 0; }
static int pxa_irda_probe(struct platform_device *pdev) { struct net_device *dev; struct pxa_irda *si; unsigned int baudrate_mask; int err; if (!pdev->dev.platform_data) return -ENODEV; err = request_mem_region(__PREG(STUART), 0x24, "IrDA") ? 0 : -EBUSY; if (err) goto err_mem_1; err = request_mem_region(__PREG(FICP), 0x1c, "IrDA") ? 0 : -EBUSY; if (err) goto err_mem_2; dev = alloc_irdadev(sizeof(struct pxa_irda)); if (!dev) goto err_mem_3; SET_NETDEV_DEV(dev, &pdev->dev); si = netdev_priv(dev); si->dev = &pdev->dev; si->pdata = pdev->dev.platform_data; si->sir_clk = clk_get(&pdev->dev, "UARTCLK"); si->fir_clk = clk_get(&pdev->dev, "FICPCLK"); if (IS_ERR(si->sir_clk) || IS_ERR(si->fir_clk)) { err = PTR_ERR(IS_ERR(si->sir_clk) ? si->sir_clk : si->fir_clk); goto err_mem_4; } /* * Initialise the SIR buffers */ err = pxa_irda_init_iobuf(&si->rx_buff, 14384); if (err) goto err_mem_4; err = pxa_irda_init_iobuf(&si->tx_buff, 4000); if (err) goto err_mem_5; if (gpio_is_valid(si->pdata->gpio_pwdown)) { err = gpio_request(si->pdata->gpio_pwdown, "IrDA switch"); if (err) goto err_startup; err = gpio_direction_output(si->pdata->gpio_pwdown, !si->pdata->gpio_pwdown_inverted); if (err) { gpio_free(si->pdata->gpio_pwdown); goto err_startup; } } if (si->pdata->startup) { err = si->pdata->startup(si->dev); if (err) goto err_startup; } if (gpio_is_valid(si->pdata->gpio_pwdown) && si->pdata->startup) dev_warn(si->dev, "gpio_pwdown and startup() both defined!\n"); dev->netdev_ops = &pxa_irda_netdev_ops; irda_init_max_qos_capabilies(&si->qos); baudrate_mask = 0; if (si->pdata->transceiver_cap & IR_SIRMODE) baudrate_mask |= IR_9600|IR_19200|IR_38400|IR_57600|IR_115200; if (si->pdata->transceiver_cap & IR_FIRMODE) baudrate_mask |= IR_4000000 << 8; si->qos.baud_rate.bits &= baudrate_mask; si->qos.min_turn_time.bits = 7; /* 1ms or more */ irda_qos_bits_to_value(&si->qos); err = register_netdev(dev); if (err == 0) dev_set_drvdata(&pdev->dev, dev); if (err) { if (si->pdata->shutdown) si->pdata->shutdown(si->dev); err_startup: kfree(si->tx_buff.head); err_mem_5: kfree(si->rx_buff.head); err_mem_4: if (si->sir_clk && !IS_ERR(si->sir_clk)) clk_put(si->sir_clk); if (si->fir_clk && !IS_ERR(si->fir_clk)) clk_put(si->fir_clk); free_netdev(dev); err_mem_3: release_mem_region(__PREG(FICP), 0x1c); err_mem_2: release_mem_region(__PREG(STUART), 0x24); } err_mem_1: return err; }
static int ux500_msp_drv_probe(struct platform_device *pdev) { struct ux500_msp_i2s_drvdata *drvdata; struct msp_i2s_platform_data *pdata = pdev->dev.platform_data; struct device_node *np = pdev->dev.of_node; int ret = 0; if (!pdata && !np) { dev_err(&pdev->dev, "No platform data or Device Tree found\n"); return -ENODEV; } drvdata = devm_kzalloc(&pdev->dev, sizeof(struct ux500_msp_i2s_drvdata), GFP_KERNEL); if (!drvdata) return -ENOMEM; drvdata->fmt = 0; drvdata->slots = 1; drvdata->tx_mask = 0x01; drvdata->rx_mask = 0x01; drvdata->slot_width = 16; drvdata->master_clk = MSP_INPUT_FREQ_APB; drvdata->reg_vape = devm_regulator_get(&pdev->dev, "v-ape"); if (IS_ERR(drvdata->reg_vape)) { ret = (int)PTR_ERR(drvdata->reg_vape); dev_err(&pdev->dev, "%s: ERROR: Failed to get Vape supply (%d)!\n", __func__, ret); return ret; } prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, (char *)pdev->name, 50); drvdata->pclk = devm_clk_get(&pdev->dev, "apb_pclk"); if (IS_ERR(drvdata->pclk)) { ret = (int)PTR_ERR(drvdata->pclk); dev_err(&pdev->dev, "%s: ERROR: devm_clk_get of pclk failed (%d)!\n", __func__, ret); return ret; } drvdata->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(drvdata->clk)) { ret = (int)PTR_ERR(drvdata->clk); dev_err(&pdev->dev, "%s: ERROR: devm_clk_get failed (%d)!\n", __func__, ret); return ret; } ret = ux500_msp_i2s_init_msp(pdev, &drvdata->msp, pdev->dev.platform_data); if (!drvdata->msp) { dev_err(&pdev->dev, "%s: ERROR: Failed to init MSP-struct (%d)!", __func__, ret); return ret; } dev_set_drvdata(&pdev->dev, drvdata); ret = snd_soc_register_component(&pdev->dev, &ux500_msp_component, &ux500_msp_dai_drv, 1); if (ret < 0) { dev_err(&pdev->dev, "Error: %s: Failed to register MSP%d!\n", __func__, drvdata->msp->id); return ret; } ret = ux500_pcm_register_platform(pdev); if (ret < 0) { dev_err(&pdev->dev, "Error: %s: Failed to register PCM platform device!\n", __func__); goto err_reg_plat; } return 0; err_reg_plat: snd_soc_unregister_component(&pdev->dev); return ret; }
/* **************************************************************************** * - Device operation such as; * probe, init/exit, remove **************************************************************************** */ static int __devinit lm3561_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct lm3561_platform_data *pdata = client->dev.platform_data; struct lm3561_drv_data *data; int result; dev_info(&client->dev, "%s\n", __func__); if (!pdata) { dev_err(&data->client->dev, "%s(): failed during init", __func__); return -EINVAL; } if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) { dev_err(&data->client->dev, "%s(): failed during i2c_check_functionality", __func__); return -EIO; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (!data) { dev_err(&data->client->dev, "%s(): failed during kzalloc", __func__); return -ENOMEM; } dev_set_drvdata(&client->dev, data); data->client = client; result = pdata->hw_enable(); if (result) { dev_err(&client->dev, "%s: Failed to HW Enable.\n", __func__); goto err_setup; } data->led_nums = 1; data->torch_current_shift = 0; data->flash_current_shift = 0; if (pdata->current_limit >= 1500000) { data->reg_flash_duration_limit = LM3561_FLASH_DURATION_CL_1500MA; } else if (pdata->current_limit >= 1000000) { data->reg_flash_duration_limit = LM3561_FLASH_DURATION_CL_1000MA; } else { /* current_limit > 1500000uA || current_limit < 1000000uA */ dev_err(&data->client->dev, "%s(): current_limit(%luuA) is invalid\n", __func__, pdata->current_limit); result = -EINVAL; goto err_chip_init; } result = lm3561_chip_init(data, pdata); if (result) { dev_err(&data->client->dev, "%s(): chip init failed", __func__); goto err_chip_init; } result = lm3561_create_sysfs_interfaces(&client->dev); if (result) { dev_err(&data->client->dev, "%s(): create sysfs failed", __func__); goto err_chip_init; } dev_info(&data->client->dev, "%s: loaded\n", __func__); return 0; err_chip_init: pdata->hw_disable(); err_setup: dev_set_drvdata(&client->dev, NULL); kfree(data); dev_err(&client->dev, "%s: failed with code %d.\n", __func__, result); return result; }
static int gp2a_opt_probe( struct platform_device* pdev ) { struct gp2a_data *gp2a; int irq; int i; int ret; /* allocate driver_data */ gp2a = kzalloc(sizeof(struct gp2a_data),GFP_KERNEL); if(!gp2a) { pr_err("kzalloc error\n"); return -ENOMEM; } gprintk("in %s \n",__func__); /* init i2c */ opt_i2c_init(); if(opt_i2c_client == NULL) { pr_err("opt_probe failed : i2c_client is NULL\n"); return -ENODEV; } /* hrtimer Settings */ hrtimer_init(&gp2a->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); gp2a->timer.function = gp2a_timer_func; /* Input device Settings */ if(USE_INPUT_DEVICE) { gp2a->input_dev = input_allocate_device(); if (gp2a->input_dev == NULL) { pr_err("Failed to allocate input device\n"); return -ENOMEM; } gp2a->input_dev->name = "proximity"; set_bit(EV_SYN,gp2a->input_dev->evbit); set_bit(EV_ABS,gp2a->input_dev->evbit); input_set_abs_params(gp2a->input_dev, ABS_DISTANCE, 0, 1, 0, 0); ret = input_register_device(gp2a->input_dev); if (ret) { pr_err("Unable to register %s input device\n", gp2a->input_dev->name); input_free_device(gp2a->input_dev); kfree(gp2a); return -1; } } /* WORK QUEUE Settings */ gp2a_wq = create_singlethread_workqueue("gp2a_wq"); if (!gp2a_wq) return -ENOMEM; INIT_WORK(&gp2a->work_prox, gp2a_work_func_prox); INIT_WORK(&gp2a->work_light, gp2a_work_func_light); gprintk("Workqueue Settings complete\n"); /* misc device Settings */ ret = misc_register(&proximity_device); if(ret) { pr_err(KERN_ERR "misc_register failed \n"); } /* wake lock init */ wake_lock_init(&prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); /* set platdata */ platform_set_drvdata(pdev, gp2a); /* set sysfs for light sensor */ lightsensor_class = class_create(THIS_MODULE, "lightsensor"); if (IS_ERR(lightsensor_class)) pr_err("Failed to create class(lightsensor)!\n"); switch_cmd_dev = device_create_drvdata(lightsensor_class, NULL, 0, NULL, "switch_cmd"); if (IS_ERR(switch_cmd_dev)) pr_err("Failed to create device(switch_cmd_dev)!\n"); if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_cmd) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_cmd.attr.name); if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_state) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_state.attr.name); dev_set_drvdata(switch_cmd_dev,gp2a); /* ktime init */ timeA = ktime_set(0,0); timeB = ktime_set(0,0); /* POWER On */ gpio_set_value(GPIO_LUM_PWM,GPIO_LEVEL_HIGH); mdelay(100); /* GP2A Regs INIT SETTINGS */ for(i=1;i<5;i++) { opt_i2c_write((u8)(i),&gp2a_original_image[i]); } mdelay(2); /* INT Settings */ irq = IRQ_GP2A_INT; gp2a->irq = -1; ret = request_irq(irq, gp2a_irq_handler, 0, "gp2a_int", gp2a); if (ret) { pr_err("unable to request irq %d\n", irq); return ret; } gp2a->irq = irq; gprintk("INT Settings complete\n"); /* maintain power-down mode before using sensor */ gp2a_off(gp2a,ALL); return 0; }
static int hall_device_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; static struct hall_device_chip *chip; SENSOR_LOG_INFO("prob start\n"); chip = kzalloc(sizeof(struct hall_device_chip), GFP_KERNEL); if (!chip) { ret = -ENOMEM; goto malloc_failed; } chip->client = client; i2c_set_clientdata(client, chip); hall_device_chip_data_init(chip); hall_device_parse_dt(chip); INIT_DELAYED_WORK(&chip->flush_work, hall_device_flush_work_func); SENSOR_LOG_INFO("hall_device_int_s is %d",chip->irq_s.irq_pin); SENSOR_LOG_INFO("hall_device_int_n is %d",chip->irq_n.irq_pin); mutex_init(&chip->lock); hall_device_class = class_create(THIS_MODULE, "hall_device"); chip->hall_device_dev = device_create(hall_device_class, NULL, hall_device_dev_t, &hall_device_driver ,"hall_device"); if (IS_ERR(chip->hall_device_dev)) { ret = PTR_ERR(chip->hall_device_dev); goto create_hall_device_dev_failed; } dev_set_drvdata(chip->hall_device_dev, chip); ret = gpio_request(chip->irq_s.irq_pin, "hall_device_irq_s"); if (ret) { SENSOR_LOG_INFO("gpio %d is busy and then to free it\n",chip->irq_s.irq_pin); gpio_free(chip->irq_s.irq_pin); ret = gpio_request(chip->irq_s.irq_pin, "hall_device_irq_s"); if (ret) { SENSOR_LOG_INFO("gpio %d is busy and then to free it\n",chip->irq_s.irq_pin); return ret; } } gpio_direction_input(chip->irq_s.irq_pin); gpio_set_value(chip->irq_s.irq_pin, 1); chip->irq_s.irq_num = gpio_to_irq(chip->irq_s.irq_pin); INIT_WORK(&chip->irq_work_s, hall_device_irq_work_s); ret = request_threaded_irq(chip->irq_s.irq_num, NULL, &hall_device_irq_s, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "hall_device_irq_s", chip); if (ret) { SENSOR_LOG_ERROR("Failed to request irq %d\n", chip->irq_s.irq_num); goto irq_s_register_fail; } ret = gpio_request(chip->irq_n.irq_pin, "hall_device_irq_n"); if (ret) { SENSOR_LOG_INFO("gpio %d is busy and then to free it\n",chip->irq_n.irq_pin); gpio_free(chip->irq_n.irq_pin); ret = gpio_request(chip->irq_n.irq_pin, "hall_device_irq_n"); if (ret) { SENSOR_LOG_INFO("gpio %d is busy and then to free it\n",chip->irq_n.irq_pin); return ret; } } gpio_direction_input(chip->irq_n.irq_pin); gpio_set_value(chip->irq_n.irq_pin, 1); chip->irq_n.irq_num = gpio_to_irq(chip->irq_n.irq_pin); INIT_WORK(&chip->irq_work_n, hall_device_irq_work_n); ret = request_threaded_irq(chip->irq_n.irq_num , NULL, &hall_device_irq_n, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "hall_device_irq_n", chip); if (ret) { SENSOR_LOG_ERROR("Failed to request irq %d\n", chip->irq_n.irq_num ); goto irq_n_register_fail; } chip->idev = input_allocate_device(); if (!chip->idev) { SENSOR_LOG_ERROR("no memory for idev\n"); ret = -ENODEV; goto input_alloc_failed; } chip->idev->name = "hall_device"; chip->idev->id.bustype = BUS_I2C; set_bit(EV_REL, chip->idev->evbit); set_bit(REL_RX, chip->idev->relbit); //HALL S set_bit(REL_RY, chip->idev->relbit); //HALL N ret = input_register_device(chip->idev); if (ret) { input_free_device(chip->idev); SENSOR_LOG_ERROR("cant register input '%s'\n",chip->idev->name); goto input_register_failed; } create_sysfs_interfaces(chip->hall_device_dev); hall_device_irq_enable(&(chip->irq_s), false, true); hall_device_irq_enable(&(chip->irq_n), false, true); wake_lock_init(&chip->wakeup_wakelock.lock, WAKE_LOCK_SUSPEND, chip->wakeup_wakelock.name); hrtimer_init(&chip->unlock_wakelock_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); chip->unlock_wakelock_timer.function = hall_device_unlock_wakelock_work_func; SENSOR_LOG_INFO("prob success\n"); return 0; input_register_failed: input_free_device(chip->idev); input_alloc_failed: malloc_failed: irq_n_register_fail: irq_s_register_fail: create_hall_device_dev_failed: chip->hall_device_dev = NULL; class_destroy(hall_device_class); SENSOR_LOG_INFO("prob failed\n"); return -1; }
static int kirkwood_i2s_dev_probe(struct platform_device *pdev) { struct kirkwood_asoc_platform_data *data = pdev->dev.platform_data; struct snd_soc_dai_driver *soc_dai = kirkwood_i2s_dai; struct kirkwood_dma_data *priv; struct resource *mem; struct device_node *np = pdev->dev.of_node; int err; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) { dev_err(&pdev->dev, "allocation failed\n"); return -ENOMEM; } dev_set_drvdata(&pdev->dev, priv); mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); priv->io = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(priv->io)) return PTR_ERR(priv->io); priv->irq = platform_get_irq(pdev, 0); if (priv->irq <= 0) { dev_err(&pdev->dev, "platform_get_irq failed\n"); return -ENXIO; } if (np) { priv->burst = 128; /* might be 32 or 128 */ } else if (data) { priv->burst = data->burst; } else { dev_err(&pdev->dev, "no DT nor platform data ?!\n"); return -EINVAL; } priv->clk = devm_clk_get(&pdev->dev, np ? "internal" : NULL); if (IS_ERR(priv->clk)) { dev_err(&pdev->dev, "no clock\n"); return PTR_ERR(priv->clk); } err = clk_prepare_enable(priv->clk); if (err < 0) return err; priv->extclk = devm_clk_get(&pdev->dev, "extclk"); if (IS_ERR(priv->extclk)) { if (PTR_ERR(priv->extclk) == -EPROBE_DEFER) return -EPROBE_DEFER; } else { if (clk_is_match(priv->extclk, priv->clk)) { devm_clk_put(&pdev->dev, priv->extclk); priv->extclk = ERR_PTR(-EINVAL); } else { dev_info(&pdev->dev, "found external clock\n"); clk_prepare_enable(priv->extclk); soc_dai = kirkwood_i2s_dai_extclk; } } /* Some sensible defaults - this reflects the powerup values */ priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24; priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24; /* Select the burst size */ if (priv->burst == 32) { priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32; priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32; } else { priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128; priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128; } err = snd_soc_register_component(&pdev->dev, &kirkwood_i2s_component, soc_dai, 2); if (err) { dev_err(&pdev->dev, "snd_soc_register_component failed\n"); goto err_component; } err = snd_soc_register_platform(&pdev->dev, &kirkwood_soc_platform); if (err) { dev_err(&pdev->dev, "snd_soc_register_platform failed\n"); goto err_platform; } kirkwood_i2s_init(priv); return 0; err_platform: snd_soc_unregister_component(&pdev->dev); err_component: if (!IS_ERR(priv->extclk)) clk_disable_unprepare(priv->extclk); clk_disable_unprepare(priv->clk); return err; }
static int rockchip_i2s_probe(struct platform_device *pdev) { struct rk_i2s_dev *i2s; struct resource *res; void __iomem *regs; int ret; i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL); if (!i2s) { dev_err(&pdev->dev, "Can't allocate rk_i2s_dev\n"); return -ENOMEM; } /* try to prepare related clocks */ i2s->hclk = devm_clk_get(&pdev->dev, "i2s_hclk"); if (IS_ERR(i2s->hclk)) { dev_err(&pdev->dev, "Can't retrieve i2s bus clock\n"); return PTR_ERR(i2s->hclk); } ret = clk_prepare_enable(i2s->hclk); if (ret) { dev_err(i2s->dev, "hclock enable failed %d\n", ret); return ret; } i2s->mclk = devm_clk_get(&pdev->dev, "i2s_clk"); if (IS_ERR(i2s->mclk)) { dev_err(&pdev->dev, "Can't retrieve i2s master clock\n"); return PTR_ERR(i2s->mclk); } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); regs = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(regs)) return PTR_ERR(regs); i2s->regmap = devm_regmap_init_mmio(&pdev->dev, regs, &rockchip_i2s_regmap_config); if (IS_ERR(i2s->regmap)) { dev_err(&pdev->dev, "Failed to initialise managed register map\n"); return PTR_ERR(i2s->regmap); } i2s->playback_dma_data.addr = res->start + I2S_TXDR; i2s->playback_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; i2s->playback_dma_data.maxburst = 4; i2s->capture_dma_data.addr = res->start + I2S_RXDR; i2s->capture_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; i2s->capture_dma_data.maxburst = 4; i2s->dev = &pdev->dev; dev_set_drvdata(&pdev->dev, i2s); pm_runtime_enable(&pdev->dev); if (!pm_runtime_enabled(&pdev->dev)) { ret = i2s_runtime_resume(&pdev->dev); if (ret) goto err_pm_disable; } ret = devm_snd_soc_register_component(&pdev->dev, &rockchip_i2s_component, &rockchip_i2s_dai, 1); if (ret) { dev_err(&pdev->dev, "Could not register DAI\n"); goto err_suspend; } ret = snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); if (ret) { dev_err(&pdev->dev, "Could not register PCM\n"); goto err_pcm_register; } return 0; err_pcm_register: snd_dmaengine_pcm_unregister(&pdev->dev); err_suspend: if (!pm_runtime_status_suspended(&pdev->dev)) i2s_runtime_suspend(&pdev->dev); err_pm_disable: pm_runtime_disable(&pdev->dev); return ret; }
static int omap_hdmi_audio_probe(struct platform_device *pdev) { struct omap_hdmi_audio_pdata *ha = pdev->dev.platform_data; struct device *dev = &pdev->dev; struct hdmi_audio_data *ad; struct snd_soc_dai_driver *dai_drv; struct snd_soc_card *card; int ret; if (!ha) { dev_err(dev, "No platform data\n"); return -EINVAL; } ad = devm_kzalloc(dev, sizeof(*ad), GFP_KERNEL); if (!ad) return -ENOMEM; ad->dssdev = ha->dev; ad->ops = ha->ops; ad->dma_data.addr = ha->audio_dma_addr; ad->dma_data.filter_data = "audio_tx"; ad->dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; mutex_init(&ad->current_stream_lock); switch (ha->dss_version) { case OMAPDSS_VER_OMAP4430_ES1: case OMAPDSS_VER_OMAP4430_ES2: case OMAPDSS_VER_OMAP4: dai_drv = &omap4_hdmi_dai; break; case OMAPDSS_VER_OMAP5: dai_drv = &omap5_hdmi_dai; break; default: return -EINVAL; } ret = snd_soc_register_component(ad->dssdev, &omap_hdmi_component, dai_drv, 1); if (ret) return ret; ret = omap_pcm_platform_register(ad->dssdev); if (ret) return ret; card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL); if (!card) return -ENOMEM; card->name = devm_kasprintf(dev, GFP_KERNEL, "HDMI %s", dev_name(ad->dssdev)); card->owner = THIS_MODULE; card->dai_link = devm_kzalloc(dev, sizeof(*(card->dai_link)), GFP_KERNEL); card->dai_link->name = card->name; card->dai_link->stream_name = card->name; card->dai_link->cpu_dai_name = dev_name(ad->dssdev); card->dai_link->platform_name = dev_name(ad->dssdev); card->dai_link->codec_name = "snd-soc-dummy"; card->dai_link->codec_dai_name = "snd-soc-dummy-dai"; card->num_links = 1; card->dev = dev; ret = snd_soc_register_card(card); if (ret) { dev_err(dev, "snd_soc_register_card failed (%d)\n", ret); snd_soc_unregister_component(ad->dssdev); return ret; } ad->card = card; snd_soc_card_set_drvdata(card, ad); dev_set_drvdata(dev, ad); return 0; }
static int d7s_probe(struct platform_device *op) { struct device_node *opts; int err = -EINVAL; struct d7s *p; u8 regs; if (d7s_device) goto out; p = devm_kzalloc(&op->dev, sizeof(*p), GFP_KERNEL); err = -ENOMEM; if (!p) goto out; p->regs = of_ioremap(&op->resource[0], 0, sizeof(u8), "d7s"); if (!p->regs) { printk(KERN_ERR PFX "Cannot map chip registers\n"); goto out_free; } err = misc_register(&d7s_miscdev); if (err) { printk(KERN_ERR PFX "Unable to acquire miscdevice minor %i\n", D7S_MINOR); goto out_iounmap; } /* OBP option "d7s-flipped?" is honored as default for the * device, and reset default when detached */ regs = readb(p->regs); opts = of_find_node_by_path("/options"); if (opts && of_get_property(opts, "d7s-flipped?", NULL)) p->flipped = true; if (p->flipped) regs |= D7S_FLIP; else regs &= ~D7S_FLIP; writeb(regs, p->regs); printk(KERN_INFO PFX "7-Segment Display%s at [%s:0x%llx] %s\n", op->dev.of_node->full_name, (regs & D7S_FLIP) ? " (FLIPPED)" : "", op->resource[0].start, sol_compat ? "in sol_compat mode" : ""); dev_set_drvdata(&op->dev, p); d7s_device = p; err = 0; out: return err; out_iounmap: of_iounmap(&op->resource[0], p->regs, sizeof(u8)); out_free: goto out; }
static int cg14_probe(struct platform_device *op) { struct device_node *dp = op->dev.of_node; struct fb_info *info; struct cg14_par *par; int is_8mb, linebytes, i, err; info = framebuffer_alloc(sizeof(struct cg14_par), &op->dev); err = -ENOMEM; if (!info) goto out_err; par = info->par; spin_lock_init(&par->lock); sbusfb_fill_var(&info->var, dp, 8); info->var.red.length = 8; info->var.green.length = 8; info->var.blue.length = 8; linebytes = of_getintprop_default(dp, "linebytes", info->var.xres); info->fix.smem_len = PAGE_ALIGN(linebytes * info->var.yres); if (!strcmp(dp->parent->name, "sbus") || !strcmp(dp->parent->name, "sbi")) { info->fix.smem_start = op->resource[0].start; par->iospace = op->resource[0].flags & IORESOURCE_BITS; } else { info->fix.smem_start = op->resource[1].start; par->iospace = op->resource[0].flags & IORESOURCE_BITS; } par->regs = of_ioremap(&op->resource[0], 0, sizeof(struct cg14_regs), "cg14 regs"); par->clut = of_ioremap(&op->resource[0], CG14_CLUT1, sizeof(struct cg14_clut), "cg14 clut"); par->cursor = of_ioremap(&op->resource[0], CG14_CURSORREGS, sizeof(struct cg14_cursor), "cg14 cursor"); info->screen_base = of_ioremap(&op->resource[1], 0, info->fix.smem_len, "cg14 ram"); if (!par->regs || !par->clut || !par->cursor || !info->screen_base) goto out_unmap_regs; is_8mb = (((op->resource[1].end - op->resource[1].start) + 1) == (8 * 1024 * 1024)); BUILD_BUG_ON(sizeof(par->mmap_map) != sizeof(__cg14_mmap_map)); memcpy(&par->mmap_map, &__cg14_mmap_map, sizeof(par->mmap_map)); for (i = 0; i < CG14_MMAP_ENTRIES; i++) { struct sbus_mmap_map *map = &par->mmap_map[i]; if (!map->size) break; if (map->poff & 0x80000000) map->poff = (map->poff & 0x7fffffff) + (op->resource[0].start - op->resource[1].start); if (is_8mb && map->size >= 0x100000 && map->size <= 0x400000) map->size *= 2; } par->mode = MDI_8_PIX; par->ramsize = (is_8mb ? 0x800000 : 0x400000); info->flags = FBINFO_DEFAULT | FBINFO_HWACCEL_YPAN; info->fbops = &cg14_ops; __cg14_reset(par); if (fb_alloc_cmap(&info->cmap, 256, 0)) goto out_unmap_regs; fb_set_cmap(&info->cmap, info); cg14_init_fix(info, linebytes, dp); err = register_framebuffer(info); if (err < 0) goto out_dealloc_cmap; dev_set_drvdata(&op->dev, info); printk(KERN_INFO "%s: cgfourteen at %lx:%lx, %dMB\n", dp->full_name, par->iospace, info->fix.smem_start, par->ramsize >> 20); return 0; out_dealloc_cmap: fb_dealloc_cmap(&info->cmap); out_unmap_regs: cg14_unmap_regs(op, info, par); framebuffer_release(info); out_err: return err; }
static int cypress_touchkey_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; struct input_dev *input_dev; struct cypress_touchkey_devdata *devdata; u8 data[3]; int err; int cnt; #if defined(TOUCH_UPDATE) int ret; int retry = 10; #endif if (!dev->platform_data) { dev_err(dev, "%s: Platform data is NULL\n", __func__); return -EINVAL; } devdata = kzalloc(sizeof(*devdata), GFP_KERNEL); if (devdata == NULL) { dev_err(dev, "%s: failed to create our state\n", __func__); return -ENODEV; } devdata->client = client; i2c_set_clientdata(client, devdata); devdata->pdata = client->dev.platform_data; if (!devdata->pdata->keycode) { dev_err(dev, "%s: Invalid platform data\n", __func__); err = -EINVAL; goto err_null_keycodes; } strlcpy(devdata->client->name, DEVICE_NAME, I2C_NAME_SIZE); input_dev = input_allocate_device(); if (!input_dev) { err = -ENOMEM; goto err_input_alloc_dev; } devdata->input_dev = input_dev; dev_set_drvdata(&input_dev->dev, devdata); input_dev->name = DEVICE_NAME; input_dev->id.bustype = BUS_HOST; for (cnt = 0; cnt < devdata->pdata->keycode_cnt; cnt++) input_set_capability(input_dev, EV_KEY, devdata->pdata->keycode[cnt]); err = input_register_device(input_dev); if (err) goto err_input_reg_dev; devdata->is_powering_on = true; devdata->pdata->touchkey_onoff(TOUCHKEY_ON); err = i2c_master_recv(client, data, sizeof(data)); if (err < sizeof(data)) { if (err >= 0) err = -EIO; dev_err(dev, "%s: error reading hardware version\n", __func__); goto err_read; } dev_info(dev, "%s: hardware rev1 = %#02x, rev2 = %#02x\n", __func__, data[1], data[2]); devdata->backlight_on = BACKLIGHT_ON; devdata->backlight_off = BACKLIGHT_OFF; devdata->has_legacy_keycode = 1; #if 0 err = i2c_touchkey_write_byte(devdata, devdata->backlight_on); if (err) { dev_err(dev, "%s: touch keypad backlight on failed\n", __func__); goto err_backlight_on; } #endif if (request_threaded_irq(client->irq, touchkey_interrupt_handler, touchkey_interrupt_thread, IRQF_TRIGGER_FALLING, DEVICE_NAME, devdata)) { dev_err(dev, "%s: Can't allocate irq.\n", __func__); goto err_req_irq; } #ifdef CONFIG_HAS_EARLYSUSPEND devdata->early_suspend.suspend = cypress_touchkey_early_suspend; devdata->early_suspend.resume = cypress_touchkey_early_resume; #endif register_early_suspend(&devdata->early_suspend); devdata->is_powering_on = false; #if defined(TOUCH_UPDATE) ret = misc_register(&touchkey_update_device); if (ret) { printk("%s misc_register fail\n", __FUNCTION__); goto err_misc_reg; } dev_set_drvdata(touchkey_update_device.this_device, devdata); if (device_create_file (touchkey_update_device.this_device, &dev_attr_touch_version) < 0) { printk("%s device_create_file fail dev_attr_touch_version\n", __FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touch_version.attr.name); } if (device_create_file (touchkey_update_device.this_device, &dev_attr_touch_update) < 0) { printk("%s device_create_file fail dev_attr_touch_update\n", __FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touch_update.attr.name); } if (device_create_file (touchkey_update_device.this_device, &dev_attr_brightness) < 0) { printk("%s device_create_file fail dev_attr_touch_update\n", __FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_brightness.attr.name); } if (device_create_file (touchkey_update_device.this_device, &dev_attr_enable_disable) < 0) { printk("%s device_create_file fail dev_attr_touch_update\n", __FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_enable_disable.attr.name); } touchkey_wq = create_singlethread_workqueue(DEVICE_NAME); if (!touchkey_wq) goto err_create_wq; while (retry--) { if (get_touchkey_firmware(data) == 0) //melfas need delay for multiple read break; } printk("%s F/W version: 0x%x, Module version:0x%x\n", __FUNCTION__, data[1], data[2]); #endif return 0; err_create_wq: #if defined(TOUCH_UPDATE) misc_deregister(&touchkey_update_device); #endif err_misc_reg: err_req_irq: err_backlight_on: err_read: devdata->pdata->touchkey_onoff(TOUCHKEY_OFF); input_unregister_device(input_dev); goto err_input_alloc_dev; err_input_reg_dev: input_free_device(input_dev); err_input_alloc_dev: err_null_keycodes: kfree(devdata); return err; }