static int __init hs_probe(struct platform_device *pdev) { int result = 0; mic.hsmajor = 0; mic.headset_state = 0; mic.hsbtime.tv.sec = 0; mic.hsbtime.tv.nsec = 0; mic.headset_pd = NULL; mic.check_count = 0; #ifdef CONFIG_SWITCH result = hs_switchinit(&mic); if (result < 0) return result; #endif result = hs_inputdev(&mic); if (result < 0) goto err; result = register_chrdev(mic.hsmajor, "BrcmHeadset", &hs_fops); if(result < 0) goto err1; else if(result > 0 && (mic.hsmajor == 0)) /* this is for dynamic major */ mic.hsmajor = result; wake_lock_init(&mic.det_wake_lock, WAKE_LOCK_SUSPEND, "sec_jack_det"); INIT_DELAYED_WORK(&(mic.imsi_work), getIMSI_work_func); /* check if platform data is defined for a particular board variant */ if (pdev->dev.platform_data) { mic.headset_pd = pdev->dev.platform_data; KEY_PRESS_THRESHOLD = mic.headset_pd->key_press_threshold; KEY_3POLE_THRESHOLD = mic.headset_pd->key_3pole_threshold; KEY1_THRESHOLD_L = mic.headset_pd->key1_threshold_l; KEY1_THRESHOLD_U = mic.headset_pd->key1_threshold_u; KEY2_THRESHOLD_L = mic.headset_pd->key2_threshold_l; KEY2_THRESHOLD_U = mic.headset_pd->key2_threshold_u; KEY3_THRESHOLD_L = mic.headset_pd->key3_threshold_l; KEY3_THRESHOLD_U = mic.headset_pd->key3_threshold_u; if (mic.headset_pd->hsgpio == 0) mic.hsirq = mic.headset_pd->hsirq; else { setup_timer(&mic.timer, gpio_jack_timer, (unsigned long)&mic); // timer register. if (gpio_request(mic.headset_pd->hsgpio, "headset detect") < 0) { printk("%s: Could not reserve headset signal GPIO!\n", __func__); goto err2; } gpio_direction_input(mic.headset_pd->hsgpio); bcm_gpio_set_db_val(mic.headset_pd->hsgpio, 0x7); mic.hsirq = gpio_to_irq(mic.headset_pd->hsgpio); } mic.hsbirq = mic.headset_pd->hsbirq; } else { mic.hsirq = platform_get_irq(pdev, 0); mic.hsbirq = platform_get_irq(pdev, 1); } printk("%s: HS irq %d\n", __func__, mic.hsirq); printk("%s: HSB irq %d\n", __func__, mic.hsbirq); result = request_irq(mic.hsbirq, hs_buttonisr, IRQF_NO_SUSPEND, "BrcmHeadsetButton", (void *) NULL); mic.hsbst = DISABLE; if(result < 0) goto err2; result = request_irq(mic.hsirq, hs_isr,(IRQF_DISABLED | IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND), "BrcmHeadset", &mic); if(result < 0) { free_irq(mic.hsbirq, &mic); goto err2; } printk("%s: BrcmHeadset: module inserted >>>> . Major number is = %d\n", __func__, mic.hsmajor); /* Set the ANACR2 bit for mic power down */ board_sysconfig(SYSCFG_AUXMIC, SYSCFG_INIT); board_sysconfig(SYSCFG_HEADSET, SYSCFG_INIT); /*Fix the audio path is wrong when headset already plugged in the device then boot device case.*/ if (mic.headset_pd->hsgpio != 0) { mic.headset_pd->check_hs_state(&mic.headset_state); printk("%s: headset_state:%d\n", __func__, mic.headset_state); set_irq_type(mic.hsirq, (mic.headset_state) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING); schedule_work(&(mic.switch_data.work)); schedule_delayed_work(&(mic.imsi_work), GET_IMSI_REF_TIME); } return 0; err2: unregister_chrdev(mic.hsmajor,"BrcmHeadset"); if(mic.headset_pd->hsgpio) del_timer_sync(&mic.timer); err1: hs_unreginputdev(&mic); err: hs_unregsysfs(&mic); return result; }
/* * vpif_probe: This function creates device entries by register itself to the * V4L2 driver and initializes fields of each channel objects */ static __init int vpif_probe(struct platform_device *pdev) { struct vpif_subdev_info *subdevdata; struct vpif_display_config *config; int i, j = 0, k, q, m, err = 0; struct i2c_adapter *i2c_adap; struct common_obj *common; struct channel_obj *ch; struct video_device *vfd; struct resource *res; int subdev_count; vpif_dev = &pdev->dev; err = initialize_vpif(); if (err) { v4l2_err(vpif_dev->driver, "Error initializing vpif\n"); return err; } err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev); if (err) { v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n"); return err; } k = 0; while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, k))) { for (i = res->start; i <= res->end; i++) { if (request_irq(i, vpif_channel_isr, IRQF_DISABLED, "DM646x_Display", (void *)(&vpif_obj.dev[k]->channel_id))) { err = -EBUSY; goto vpif_int_err; } } k++; } for (i = 0; i < VPIF_DISPLAY_MAX_DEVICES; i++) { /* Get the pointer to the channel object */ ch = vpif_obj.dev[i]; /* Allocate memory for video device */ vfd = video_device_alloc(); if (vfd == NULL) { for (j = 0; j < i; j++) { ch = vpif_obj.dev[j]; video_device_release(ch->video_dev); } err = -ENOMEM; goto vpif_int_err; } /* Initialize field of video device */ *vfd = vpif_video_template; vfd->v4l2_dev = &vpif_obj.v4l2_dev; vfd->release = video_device_release; snprintf(vfd->name, sizeof(vfd->name), "DM646x_VPIFDisplay_DRIVER_V%d.%d.%d", (VPIF_DISPLAY_VERSION_CODE >> 16) & 0xff, (VPIF_DISPLAY_VERSION_CODE >> 8) & 0xff, (VPIF_DISPLAY_VERSION_CODE) & 0xff); /* Set video_dev to the video device */ ch->video_dev = vfd; } for (j = 0; j < VPIF_DISPLAY_MAX_DEVICES; j++) { ch = vpif_obj.dev[j]; /* Initialize field of the channel objects */ atomic_set(&ch->usrs, 0); for (k = 0; k < VPIF_NUMOBJECTS; k++) { ch->common[k].numbuffers = 0; common = &ch->common[k]; common->io_usrs = 0; common->started = 0; spin_lock_init(&common->irqlock); mutex_init(&common->lock); common->numbuffers = 0; common->set_addr = NULL; common->ytop_off = common->ybtm_off = 0; common->ctop_off = common->cbtm_off = 0; common->cur_frm = common->next_frm = NULL; memset(&common->fmt, 0, sizeof(common->fmt)); common->numbuffers = config_params.numbuffers[k]; } ch->initialized = 0; ch->channel_id = j; if (j < 2) ch->common[VPIF_VIDEO_INDEX].numbuffers = config_params.numbuffers[ch->channel_id]; else ch->common[VPIF_VIDEO_INDEX].numbuffers = 0; memset(&ch->vpifparams, 0, sizeof(ch->vpifparams)); /* Initialize prio member of channel object */ v4l2_prio_init(&ch->prio); ch->common[VPIF_VIDEO_INDEX].fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; /* register video device */ vpif_dbg(1, debug, "channel=%x,channel->video_dev=%x\n", (int)ch, (int)&ch->video_dev); err = video_register_device(ch->video_dev, VFL_TYPE_GRABBER, (j ? 3 : 2)); if (err < 0) goto probe_out; video_set_drvdata(ch->video_dev, ch); } i2c_adap = i2c_get_adapter(1); config = pdev->dev.platform_data; subdev_count = config->subdev_count; subdevdata = config->subdevinfo; vpif_obj.sd = kmalloc(sizeof(struct v4l2_subdev *) * subdev_count, GFP_KERNEL); if (vpif_obj.sd == NULL) { vpif_err("unable to allocate memory for subdevice pointers\n"); err = -ENOMEM; goto probe_out; } for (i = 0; i < subdev_count; i++) { vpif_obj.sd[i] = v4l2_i2c_new_subdev_board(&vpif_obj.v4l2_dev, i2c_adap, subdevdata[i].name, &subdevdata[i].board_info, NULL); if (!vpif_obj.sd[i]) { vpif_err("Error registering v4l2 subdevice\n"); goto probe_subdev_out; } if (vpif_obj.sd[i]) vpif_obj.sd[i]->grp_id = 1 << i; } return 0; probe_subdev_out: kfree(vpif_obj.sd); probe_out: for (k = 0; k < j; k++) { ch = vpif_obj.dev[k]; video_unregister_device(ch->video_dev); video_device_release(ch->video_dev); ch->video_dev = NULL; } vpif_int_err: v4l2_device_unregister(&vpif_obj.v4l2_dev); vpif_err("VPIF IRQ request failed\n"); for (q = k; k >= 0; k--) { for (m = i; m >= res->start; m--) free_irq(m, (void *)(&vpif_obj.dev[k]->channel_id)); res = platform_get_resource(pdev, IORESOURCE_IRQ, k-1); m = res->end; } return err; }
static int __devinit max14656_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device_node *dev_node = client->dev.of_node; struct max14656_chip *chip; int ret = 0; int rc = 0; pr_err("%s:\n", __func__); chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; /* chip->batt_psy = power_supply_get_by_name("battery"); if (!chip->batt_psy) { pr_err("%s : batt_psy is not yet ready\n", __func__); ret = -EPROBE_DEFER; goto error; } */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { pr_err("%s : i2c_check_functionality fail\n", __func__); return -EIO; } chip->client = client; /* need dts parser */ if (dev_node) { ret = max14656_parse_dt(dev_node, chip); if (ret) { pr_err("failed to parse dt\n"); goto error; } } #ifdef CONFIG_LGE_PM chip->chg_detect_done = 0; chip->chg_type = 0; chip->dcd_timeout = 0; #endif ret = gpio_request_one(chip->int_gpio, GPIOF_DIR_IN, "max14656_int"); if (ret) { pr_err("failed to request int_gpio\n"); goto error; } chip->irq = gpio_to_irq(chip->int_gpio); pr_debug("int_gpio irq#=%d.\n", chip->irq); i2c_set_clientdata(client, NULL); ret = max14656_hw_init(chip); if (ret) { pr_err("max14656_hwinit failed.ret=%d\n", ret); goto err_hw_init; } INIT_DELAYED_WORK(&chip->irq_work, max14656_irq_worker); if (chip->irq) { ret = request_irq(chip->irq, max14656_irq, IRQF_TRIGGER_FALLING, "max14656_irq", chip); if (ret) { pr_err("request_irq %d failed\n", chip->irq); goto err_req_irq; } enable_irq_wake(chip->irq); } schedule_delayed_work(&chip->irq_work, msecs_to_jiffies(2000)); #ifdef CONFIG_LGE_PM chip->detect_psy = max14656_ps; rc = power_supply_register(&chip->client->dev, &chip->detect_psy); if (rc < 0) { pr_err("[2222]batt failed to register rc = %d\n", rc); } #endif pr_info("%s : Done\n", __func__); return 0; err_req_irq: err_hw_init: if (chip->int_gpio) gpio_free(chip->int_gpio); error: kfree(chip); chip = NULL; pr_info("fail to probe\n"); return ret; }
int msm_camio_enable(struct platform_device *pdev) { int rc = 0; struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data; struct msm_camera_device_platform_data *camdev = sinfo->pdata; camio_dev = pdev; camio_ext = camdev->ioext; camio_clk = camdev->ioclk; camdev->camera_gpio_on(); msm_camera_vreg_enable(); msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK); msm_camio_clk_enable(CAMIO_VFE_CLK); msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK); msm_camio_clk_enable(CAMIO_CSI1_VFE_CLK); msm_camio_clk_enable(CAMIO_CSI_SRC_CLK); msm_camio_clk_enable(CAMIO_CSI0_CLK); msm_camio_clk_enable(CAMIO_CSI1_CLK); msm_camio_clk_enable(CAMIO_VFE_PCLK); msm_camio_clk_enable(CAMIO_CSI0_PCLK); msm_camio_clk_enable(CAMIO_CSI1_PCLK); csiio = request_mem_region(camio_ext.csiphy, camio_ext.csisz, pdev->name); if (!csiio) { rc = -EBUSY; goto common_fail; } csibase = ioremap(camio_ext.csiphy, camio_ext.csisz); if (!csibase) { rc = -ENOMEM; goto csi_busy; } rc = request_irq(camio_ext.csiirq, msm_io_csi_irq, IRQF_TRIGGER_RISING, "csi", 0); if (rc < 0) goto csi_irq_fail; return 0; csi_irq_fail: iounmap(csibase); csi_busy: release_mem_region(camio_ext.csiphy, camio_ext.csisz); common_fail: msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK); msm_camio_clk_disable(CAMIO_CSI0_VFE_CLK); msm_camio_clk_disable(CAMIO_CSI0_CLK); msm_camio_clk_disable(CAMIO_CSI1_VFE_CLK); msm_camio_clk_disable(CAMIO_CSI1_CLK); msm_camio_clk_disable(CAMIO_VFE_PCLK); msm_camio_clk_disable(CAMIO_CSI0_PCLK); msm_camio_clk_disable(CAMIO_CSI1_PCLK); /* Disable CAMIO_CSI1_VFE_CLK, CAMIO_CSI1_CLK, CAMIO_CSI1_PCLK for the secondary sensor */ msm_camera_vreg_disable(); camdev->camera_gpio_off(); return rc; }
static int __init coh901327_probe(struct platform_device *pdev) { int ret; u16 val; struct resource *res; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENOENT; parent = &pdev->dev; physize = resource_size(res); phybase = res->start; if (request_mem_region(phybase, physize, DRV_NAME) == NULL) { ret = -EBUSY; goto out; } virtbase = ioremap(phybase, physize); if (!virtbase) { ret = -ENOMEM; goto out_no_remap; } clk = clk_get(&pdev->dev, NULL); if (IS_ERR(clk)) { ret = PTR_ERR(clk); dev_err(&pdev->dev, "could not get clock\n"); goto out_no_clk; } ret = clk_enable(clk); if (ret) { dev_err(&pdev->dev, "could not enable clock\n"); goto out_no_clk_enable; } val = readw(virtbase + U300_WDOG_SR); switch (val) { case U300_WDOG_SR_STATUS_TIMED_OUT: dev_info(&pdev->dev, "watchdog timed out since last chip reset!\n"); coh901327_wdt.bootstatus |= WDIOF_CARDRESET; break; case U300_WDOG_SR_STATUS_NORMAL: dev_info(&pdev->dev, "in normal status, no timeouts have occurred.\n"); break; default: dev_info(&pdev->dev, "contains an illegal status code (%08x)\n", val); break; } val = readw(virtbase + U300_WDOG_D2R); switch (val) { case U300_WDOG_D2R_DISABLE_STATUS_DISABLED: dev_info(&pdev->dev, "currently disabled.\n"); break; case U300_WDOG_D2R_DISABLE_STATUS_ENABLED: dev_info(&pdev->dev, "currently enabled! (disabling it now)\n"); coh901327_disable(); break; default: dev_err(&pdev->dev, "contains an illegal enable/disable code (%08x)\n", val); break; } writew(U300_WDOG_SR_RESET_STATUS_RESET, virtbase + U300_WDOG_SR); irq = platform_get_irq(pdev, 0); if (request_irq(irq, coh901327_interrupt, 0, DRV_NAME " Bark", pdev)) { ret = -EIO; goto out_no_irq; } clk_disable(clk); if (margin < 1 || margin > 327) margin = 60; coh901327_wdt.timeout = margin; ret = watchdog_register_device(&coh901327_wdt); if (ret == 0) dev_info(&pdev->dev, "initialized. timer margin=%d sec\n", margin); else goto out_no_wdog; return 0; out_no_wdog: free_irq(irq, pdev); out_no_irq: clk_disable(clk); out_no_clk_enable: clk_put(clk); out_no_clk: iounmap(virtbase); out_no_remap: release_mem_region(phybase, SZ_4K); out: return ret; }
static int __devinit ag71xx_probe(struct platform_device *pdev) { struct net_device *dev; struct resource *res; struct ag71xx *ag; struct ag71xx_platform_data *pdata; int err; pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "no platform data specified\n"); err = -ENXIO; goto err_out; } if (pdata->mii_bus_dev == NULL) { dev_err(&pdev->dev, "no MII bus device specified\n"); err = -EINVAL; goto err_out; } dev = alloc_etherdev(sizeof(*ag)); if (!dev) { dev_err(&pdev->dev, "alloc_etherdev failed\n"); err = -ENOMEM; goto err_out; } SET_NETDEV_DEV(dev, &pdev->dev); ag = netdev_priv(dev); ag->pdev = pdev; ag->dev = dev; ag->msg_enable = netif_msg_init(ag71xx_msg_level, AG71XX_DEFAULT_MSG_ENABLE); spin_lock_init(&ag->lock); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mac_base"); if (!res) { dev_err(&pdev->dev, "no mac_base resource found\n"); err = -ENXIO; goto err_out; } ag->mac_base = ioremap_nocache(res->start, res->end - res->start + 1); if (!ag->mac_base) { dev_err(&pdev->dev, "unable to ioremap mac_base\n"); err = -ENOMEM; goto err_free_dev; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mii_ctrl"); if (!res) { dev_err(&pdev->dev, "no mii_ctrl resource found\n"); err = -ENXIO; goto err_unmap_base; } ag->mii_ctrl = ioremap_nocache(res->start, res->end - res->start + 1); if (!ag->mii_ctrl) { dev_err(&pdev->dev, "unable to ioremap mii_ctrl\n"); err = -ENOMEM; goto err_unmap_base; } dev->irq = platform_get_irq(pdev, 0); err = request_irq(dev->irq, ag71xx_interrupt, IRQF_DISABLED, dev->name, dev); if (err) { dev_err(&pdev->dev, "unable to request IRQ %d\n", dev->irq); goto err_unmap_mii_ctrl; } dev->base_addr = (unsigned long)ag->mac_base; dev->netdev_ops = &ag71xx_netdev_ops; dev->ethtool_ops = &ag71xx_ethtool_ops; INIT_WORK(&ag->restart_work, ag71xx_restart_work_func); init_timer(&ag->oom_timer); ag->oom_timer.data = (unsigned long) dev; ag->oom_timer.function = ag71xx_oom_timer_handler; memcpy(dev->dev_addr, pdata->mac_addr, ETH_ALEN); netif_napi_add(dev, &ag->napi, ag71xx_poll, AG71XX_NAPI_WEIGHT); err = register_netdev(dev); if (err) { dev_err(&pdev->dev, "unable to register net device\n"); goto err_free_irq; } printk(KERN_INFO "%s: Atheros AG71xx at 0x%08lx, irq %d\n", dev->name, dev->base_addr, dev->irq); ag71xx_dump_regs(ag); ag71xx_hw_init(ag); ag71xx_dump_regs(ag); err = ag71xx_phy_connect(ag); if (err) goto err_unregister_netdev; err = ag71xx_debugfs_init(ag); if (err) goto err_phy_disconnect; platform_set_drvdata(pdev, dev); return 0; err_phy_disconnect: ag71xx_phy_disconnect(ag); err_unregister_netdev: unregister_netdev(dev); err_free_irq: free_irq(dev->irq, dev); err_unmap_mii_ctrl: iounmap(ag->mii_ctrl); err_unmap_base: iounmap(ag->mac_base); err_free_dev: kfree(dev); err_out: platform_set_drvdata(pdev, NULL); return err; }
_mali_osk_irq_t *_mali_osk_irq_init( u32 irqnum, _mali_osk_irq_uhandler_t uhandler, _mali_osk_irq_bhandler_t bhandler, _mali_osk_irq_trigger_t trigger_func, _mali_osk_irq_ack_t ack_func, void *data, const char *description ) { mali_osk_irq_object_t *irq_object; irq_object = kmalloc(sizeof(mali_osk_irq_object_t), GFP_KERNEL); if (NULL == irq_object) return NULL; #if MALI_LICENSE_IS_GPL if (NULL == mali_wq) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36) mali_wq = alloc_workqueue("mali", WQ_UNBOUND, 0); #else mali_wq = create_workqueue("mali"); #endif if(NULL == mali_wq) { MALI_PRINT_ERROR(("Unable to create Mali workqueue\n")); kfree( irq_object ); return NULL; } } #endif /* workqueue API changed in 2.6.20, support both versions: */ #if defined(INIT_DELAYED_WORK) /* New syntax: INIT_WORK( struct work_struct *work, void (*function)(struct work_struct *)) */ INIT_WORK( &irq_object->work_queue_irq_handle, irq_handler_bottom_half); #else /* Old syntax: INIT_WORK( struct work_struct *work, void (*function)(void *), void *data) */ INIT_WORK( &irq_object->work_queue_irq_handle, irq_handler_bottom_half, irq_object); #endif /* defined(INIT_DELAYED_WORK) */ if (-1 == irqnum) { /* Probe for IRQ */ if ( (NULL != trigger_func) && (NULL != ack_func) ) { unsigned long probe_count = 3; _mali_osk_errcode_t err; int irq; MALI_DEBUG_PRINT(2, ("Probing for irq\n")); do { unsigned long mask; mask = probe_irq_on(); trigger_func(data); _mali_osk_time_ubusydelay(5); irq = probe_irq_off(mask); err = ack_func(data); } while (irq < 0 && (err == _MALI_OSK_ERR_OK) && probe_count--); if (irq < 0 || (_MALI_OSK_ERR_OK != err)) irqnum = -1; else irqnum = irq; } else irqnum = -1; /* no probe functions, fault */ if (-1 != irqnum) { /* found an irq */ MALI_DEBUG_PRINT(2, ("Found irq %d\n", irqnum)); } else { MALI_DEBUG_PRINT(2, ("Probe for irq failed\n")); } } irq_object->irqnum = irqnum; irq_object->uhandler = uhandler; irq_object->bhandler = bhandler; irq_object->data = data; /* Is this a real IRQ handler we need? */ if (!mali_benchmark && irqnum != _MALI_OSK_IRQ_NUMBER_FAKE && irqnum != _MALI_OSK_IRQ_NUMBER_PMM) { if (-1 == irqnum) { MALI_DEBUG_PRINT(2, ("No IRQ for core '%s' found during probe\n", description)); kfree(irq_object); return NULL; } if (0 != request_irq(irqnum, irq_handler_upper_half, IRQF_SHARED, description, irq_object)) { MALI_DEBUG_PRINT(2, ("Unable to install IRQ handler for core '%s'\n", description)); kfree(irq_object); return NULL; } } #if MALI_LICENSE_IS_GPL if ( _MALI_OSK_IRQ_NUMBER_PMM == irqnum ) { pmm_wq = create_singlethread_workqueue("mali-pmm-wq"); } #endif return irq_object; }
static int __devinit ds1553_rtc_probe(struct platform_device *pdev) { struct rtc_device *rtc; struct resource *res; unsigned int cen, sec; struct rtc_plat_data *pdata = NULL; void __iomem *ioaddr = NULL; int ret = 0; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) return -ENODEV; pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) { ret = -EBUSY; goto out; } pdata->baseaddr = res->start; ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE); if (!ioaddr) { ret = -ENOMEM; goto out; } pdata->ioaddr = ioaddr; pdata->irq = platform_get_irq(pdev, 0); /* turn RTC on if it was not on */ sec = readb(ioaddr + RTC_SECONDS); if (sec & RTC_STOP) { sec &= RTC_SECONDS_MASK; cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK; writeb(RTC_WRITE, ioaddr + RTC_CONTROL); writeb(sec, ioaddr + RTC_SECONDS); writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL); } if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_BLF) dev_warn(&pdev->dev, "voltage-low detected.\n"); if (pdata->irq > 0) { writeb(0, ioaddr + RTC_INTERRUPTS); if (request_irq(pdata->irq, ds1553_rtc_interrupt, IRQF_DISABLED, pdev->name, pdev) < 0) { dev_warn(&pdev->dev, "interrupt not available.\n"); pdata->irq = 0; } } rtc = rtc_device_register(pdev->name, &pdev->dev, &ds1553_rtc_ops, THIS_MODULE); if (IS_ERR(rtc)) { ret = PTR_ERR(rtc); goto out; } pdata->rtc = rtc; pdata->last_jiffies = jiffies; platform_set_drvdata(pdev, pdata); ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr); if (ret) goto out; return 0; out: if (pdata->rtc) rtc_device_unregister(pdata->rtc); if (pdata->irq > 0) free_irq(pdata->irq, pdev); if (ioaddr) iounmap(ioaddr); if (pdata->baseaddr) release_mem_region(pdata->baseaddr, RTC_REG_SIZE); kfree(pdata); return ret; }
static int __devinit pxa930_trkball_probe(struct platform_device *pdev) { struct pxa930_trkball *trkball; struct input_dev *input; struct resource *res; int irq, error; irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "failed to get trkball irq\n"); return -ENXIO; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "failed to get register memory\n"); return -ENXIO; } trkball = kzalloc(sizeof(struct pxa930_trkball), GFP_KERNEL); if (!trkball) return -ENOMEM; trkball->pdata = pdev->dev.platform_data; if (!trkball->pdata) { dev_err(&pdev->dev, "no platform data defined\n"); error = -EINVAL; goto failed; } trkball->mmio_base = ioremap_nocache(res->start, resource_size(res)); if (!trkball->mmio_base) { dev_err(&pdev->dev, "failed to ioremap registers\n"); error = -ENXIO; goto failed; } /* */ pxa930_trkball_disable(trkball); error = request_irq(irq, pxa930_trkball_interrupt, 0, pdev->name, trkball); if (error) { dev_err(&pdev->dev, "failed to request irq: %d\n", error); goto failed_free_io; } platform_set_drvdata(pdev, trkball); input = input_allocate_device(); if (!input) { dev_err(&pdev->dev, "failed to allocate input device\n"); error = -ENOMEM; goto failed_free_irq; } input->name = pdev->name; input->id.bustype = BUS_HOST; input->open = pxa930_trkball_open; input->close = pxa930_trkball_close; input->dev.parent = &pdev->dev; input_set_drvdata(input, trkball); trkball->input = input; input_set_capability(input, EV_REL, REL_X); input_set_capability(input, EV_REL, REL_Y); error = input_register_device(input); if (error) { dev_err(&pdev->dev, "unable to register input device\n"); goto failed_free_input; } return 0; failed_free_input: input_free_device(input); failed_free_irq: free_irq(irq, trkball); failed_free_io: iounmap(trkball->mmio_base); failed: kfree(trkball); return error; }
static int ibmveth_open(struct net_device *netdev) { struct ibmveth_adapter *adapter = netdev_priv(netdev); u64 mac_address = 0; int rxq_entries = 1; unsigned long lpar_rc; int rc; union ibmveth_buf_desc rxq_desc; int i; struct device *dev; netdev_dbg(netdev, "open starting\n"); napi_enable(&adapter->napi); for(i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) rxq_entries += adapter->rx_buff_pool[i].size; adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL); adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL); if (!adapter->buffer_list_addr || !adapter->filter_list_addr) { netdev_err(netdev, "unable to allocate filter or buffer list " "pages\n"); rc = -ENOMEM; goto err_out; } adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) * rxq_entries; adapter->rx_queue.queue_addr = kmalloc(adapter->rx_queue.queue_len, GFP_KERNEL); if (!adapter->rx_queue.queue_addr) { netdev_err(netdev, "unable to allocate rx queue pages\n"); rc = -ENOMEM; goto err_out; } dev = &adapter->vdev->dev; adapter->buffer_list_dma = dma_map_single(dev, adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL); adapter->filter_list_dma = dma_map_single(dev, adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL); adapter->rx_queue.queue_dma = dma_map_single(dev, adapter->rx_queue.queue_addr, adapter->rx_queue.queue_len, DMA_BIDIRECTIONAL); if ((dma_mapping_error(dev, adapter->buffer_list_dma)) || (dma_mapping_error(dev, adapter->filter_list_dma)) || (dma_mapping_error(dev, adapter->rx_queue.queue_dma))) { netdev_err(netdev, "unable to map filter or buffer list " "pages\n"); rc = -ENOMEM; goto err_out; } adapter->rx_queue.index = 0; adapter->rx_queue.num_slots = rxq_entries; adapter->rx_queue.toggle = 1; memcpy(&mac_address, netdev->dev_addr, netdev->addr_len); mac_address = mac_address >> 16; rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | adapter->rx_queue.queue_len; rxq_desc.fields.address = adapter->rx_queue.queue_dma; netdev_dbg(netdev, "buffer list @ 0x%p\n", adapter->buffer_list_addr); netdev_dbg(netdev, "filter list @ 0x%p\n", adapter->filter_list_addr); netdev_dbg(netdev, "receive q @ 0x%p\n", adapter->rx_queue.queue_addr); h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE); lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address); if (lpar_rc != H_SUCCESS) { netdev_err(netdev, "h_register_logical_lan failed with %ld\n", lpar_rc); netdev_err(netdev, "buffer TCE:0x%llx filter TCE:0x%llx rxq " "desc:0x%llx MAC:0x%llx\n", adapter->buffer_list_dma, adapter->filter_list_dma, rxq_desc.desc, mac_address); rc = -ENONET; goto err_out; } for (i = 0; i < IBMVETH_NUM_BUFF_POOLS; i++) { if (!adapter->rx_buff_pool[i].active) continue; if (ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[i])) { netdev_err(netdev, "unable to alloc pool\n"); adapter->rx_buff_pool[i].active = 0; rc = -ENOMEM; goto err_out; } } netdev_dbg(netdev, "registering irq 0x%x\n", netdev->irq); rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name, netdev); if (rc != 0) { netdev_err(netdev, "unable to request irq 0x%x, rc %d\n", netdev->irq, rc); do { rc = h_free_logical_lan(adapter->vdev->unit_address); } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY)); goto err_out; } adapter->bounce_buffer = kmalloc(netdev->mtu + IBMVETH_BUFF_OH, GFP_KERNEL); if (!adapter->bounce_buffer) { netdev_err(netdev, "unable to allocate bounce buffer\n"); rc = -ENOMEM; goto err_out_free_irq; } adapter->bounce_buffer_dma = dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer, netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL); if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) { netdev_err(netdev, "unable to map bounce buffer\n"); rc = -ENOMEM; goto err_out_free_irq; } netdev_dbg(netdev, "initial replenish cycle\n"); ibmveth_interrupt(netdev->irq, netdev); netif_start_queue(netdev); netdev_dbg(netdev, "open complete\n"); return 0; err_out_free_irq: free_irq(netdev->irq, netdev); err_out: ibmveth_cleanup(adapter); napi_disable(&adapter->napi); return rc; }
/* * This function is called when the module is loaded */ static int __init sample_init_module(void) { /* * Register device */ int ret; ret = register_chrdev(module_major, module_name, &sample_fops); if (ret < 0) { printk(KERN_INFO "%s: registering device %s with major %d failed with %d\n", __func__, module_name, module_major, module_major ); return(ret); } else { printk(KERN_INFO "%s: registering device %s with major %d\n", __func__, module_name, module_major ); /* * Reserve gpios */ if( gpio_request( TRIGGER, module_name ) ) // request pin D7 (trigger) { printk( KERN_INFO "%s: %s unable to get TRIG gpio\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_request( ECHO, module_name ) ) // request pin D8 (echo) { printk( KERN_INFO "%s: %s unable to get ECHO gpio\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_request( LED, module_name ) ) // request user LED GPIO { printk( KERN_INFO "%s: %s unable to get LED gpio\n", module_name, __func__ ); ret = -EBUSY; return(ret); } /* * Set gpios directions */ if( gpio_direction_output( TRIGGER, 0 ) < 0 ) // Set pin D7 (trigger) as output with default value 0 { printk( KERN_INFO "%s: %s unable to set TRIG gpio as output\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_direction_input( ECHO ) < 0 ) // Set pin D8 (echo) as input { printk( KERN_INFO "%s: %s unable to set ECHO gpio as input\n", module_name, __func__ ); ret = -EBUSY; return(ret); } if( gpio_direction_output( LED, 0 ) < 0 ) // Set LED gpio as output with default value 0 { printk( KERN_INFO "%s: %s unable to set LED gpio as output\n", module_name, __func__ ); ret = -EBUSY; return(ret); } // assign handler to ECHO pin IRQ if( request_irq( gpio_to_irq( ECHO ), // IRQ of pin D8 (irq_handler_t) echo_handler, // ISR (callback) IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , // sensitive to either edge module_name, NULL ) < 0 ) { printk( KERN_INFO "%s: %s unable to register gpio irq\n", module_name, __func__ ); ret = -EBUSY; return( ret ); } /* create the 2 needed workqueues */ t_wq = create_workqueue( "Trigger wq" ); if( t_wq ) { INIT_WORK( (struct work_struct *)&trigger_work, trigger_wq_function ); } led_wq = create_workqueue( "LED wq" ); if( led_wq ) { INIT_WORK( (struct work_struct *)&led_work, led_wq_function ); } } return(ret); }
static int b1pcmcia_add_card(struct capi_driver *driver, unsigned int port, unsigned irq, enum avmcardtype cardtype) { avmctrl_info *cinfo; avmcard *card; char *cardname; int retval; MOD_INC_USE_COUNT; card = (avmcard *) kmalloc(sizeof(avmcard), GFP_ATOMIC); if (!card) { printk(KERN_WARNING "%s: no memory.\n", driver->name); MOD_DEC_USE_COUNT; return -ENOMEM; } memset(card, 0, sizeof(avmcard)); cinfo = (avmctrl_info *) kmalloc(sizeof(avmctrl_info), GFP_ATOMIC); if (!cinfo) { printk(KERN_WARNING "%s: no memory.\n", driver->name); kfree(card); MOD_DEC_USE_COUNT; return -ENOMEM; } memset(cinfo, 0, sizeof(avmctrl_info)); card->ctrlinfo = cinfo; cinfo->card = card; switch (cardtype) { case avm_m1: sprintf(card->name, "m1-%x", port); break; case avm_m2: sprintf(card->name, "m2-%x", port); break; default: sprintf(card->name, "b1pcmcia-%x", port); break; } card->port = port; card->irq = irq; card->cardtype = cardtype; b1_reset(card->port); if ((retval = b1_detect(card->port, card->cardtype)) != 0) { printk(KERN_NOTICE "%s: NO card at 0x%x (%d)\n", driver->name, card->port, retval); kfree(card->ctrlinfo); kfree(card); MOD_DEC_USE_COUNT; return -EIO; } b1_reset(card->port); b1_getrevision(card); retval = request_irq(card->irq, b1pcmcia_interrupt, 0, card->name, card); if (retval) { printk(KERN_ERR "%s: unable to get IRQ %d.\n", driver->name, card->irq); kfree(card->ctrlinfo); kfree(card); MOD_DEC_USE_COUNT; return -EBUSY; } cinfo->capi_ctrl = di->attach_ctr(driver, card->name, cinfo); if (!cinfo->capi_ctrl) { printk(KERN_ERR "%s: attach controller failed.\n", driver->name); free_irq(card->irq, card); kfree(card->ctrlinfo); kfree(card); MOD_DEC_USE_COUNT; return -EBUSY; } switch (cardtype) { case avm_m1: cardname = "M1"; break; case avm_m2: cardname = "M2"; break; default : cardname = "B1 PCMCIA"; break; } printk(KERN_INFO "%s: AVM %s at i/o %#x, irq %d, revision %d\n", driver->name, cardname, card->port, card->irq, card->revision); return cinfo->capi_ctrl->cnr; }
static int fimg2d_probe(struct platform_device *pdev) { int ret = 0; struct resource *res; if (!to_fimg2d_plat(&pdev->dev)) { fimg2d_err("failed to get platform data\n"); return -ENOMEM; } /* global structure */ ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL); if (!ctrl) { fimg2d_err("failed to allocate memory for controller\n"); return -ENOMEM; } /* setup global ctrl */ ret = fimg2d_setup_controller(ctrl); if (ret) { fimg2d_err("failed to setup controller\n"); goto drv_free; } ctrl->dev = &pdev->dev; /* memory region */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { fimg2d_err("failed to get resource\n"); ret = -ENOENT; goto drv_free; } ctrl->mem = request_mem_region(res->start, resource_size(res), pdev->name); if (!ctrl->mem) { fimg2d_err("failed to request memory region\n"); ret = -ENOMEM; goto res_free; } /* ioremap */ ctrl->regs = ioremap(res->start, resource_size(res)); if (!ctrl->regs) { fimg2d_err("failed to ioremap for SFR\n"); ret = -ENOENT; goto mem_free; } fimg2d_info("base address: 0x%lx\n", (unsigned long)res->start); /* irq */ ctrl->irq = platform_get_irq(pdev, 0); if (!ctrl->irq) { fimg2d_err("failed to get irq resource\n"); ret = -ENOENT; goto reg_unmap; } fimg2d_info("irq: %d\n", ctrl->irq); ret = request_irq(ctrl->irq, fimg2d_irq, IRQF_DISABLED, pdev->name, ctrl); if (ret) { fimg2d_err("failed to request irq\n"); ret = -ENOENT; goto reg_unmap; } ret = fimg2d_clk_setup(ctrl); if (ret) { fimg2d_err("failed to setup clk\n"); ret = -ENOENT; goto irq_free; } #ifdef CONFIG_PM_RUNTIME pm_runtime_enable(ctrl->dev); fimg2d_info("enable runtime pm\n"); #else fimg2d_clk_on(ctrl); #endif exynos_sysmmu_set_fault_handler(ctrl->dev, fimg2d_sysmmu_fault_handler); fimg2d_info("register sysmmu page fault handler\n"); /* misc register */ ret = misc_register(&fimg2d_dev); if (ret) { fimg2d_err("failed to register misc driver\n"); goto clk_release; } #ifdef CONFIG_ARM_EXYNOS_IKS_CPUFREQ pm_qos_add_request(&exynos5_g2d_cpu_qos, PM_QOS_CPU_FREQ_MIN, 0); #endif #ifdef CONFIG_ARM_EXYNOS5410_BUS_DEVFREQ pm_qos_add_request(&exynos5_g2d_mif_qos, PM_QOS_BUS_THROUGHPUT, 0); #endif return 0; clk_release: #ifdef CONFIG_PM_RUNTIME pm_runtime_disable(ctrl->dev); #else fimg2d_clk_off(ctrl); #endif fimg2d_clk_release(ctrl); irq_free: free_irq(ctrl->irq, NULL); reg_unmap: iounmap(ctrl->regs); mem_free: kfree(ctrl->mem); res_free: release_resource(ctrl->mem); drv_free: #ifdef BLIT_WORKQUE if (ctrl->work_q) destroy_workqueue(ctrl->work_q); #endif mutex_destroy(&ctrl->drvlock); kfree(ctrl); return ret; }
static int gp2a_setup_irq(struct gp2a_data *gp2a) { int rc = -EIO; struct gp2a_platform_data *pdata = gp2a->pdata; u8 value; gp2a_dbgmsg("start\n"); rc = gpio_request(pdata->p_out, "gpio_proximity_out"); if (rc < 0) { pr_err("%s: gpio %d request failed (%d)\n", __func__, pdata->p_out, rc); return rc; } rc = gpio_direction_input(pdata->p_out); if (rc < 0) { pr_err("%s: failed to set gpio %d as input (%d)\n", __func__, pdata->p_out, rc); goto err_gpio_direction_input; } value = 0x18; gp2a_i2c_write(gp2a, REGS_CON, &value); rc = request_irq(pdata->irq, gp2a_irq_handler, IRQF_TRIGGER_FALLING, "proximity_int", gp2a); if (rc < 0) { pr_err("%s: request_irq(%d) failed for gpio %d (%d)\n", __func__, pdata->irq, pdata->p_out, rc); goto err_request_irq; } else{ pr_info("%s: request_irq(%d) success for gpio %d\n", __func__, pdata->irq, pdata->p_out); } /* start with interrupts disabled */ disable_irq(pdata->irq); gp2a->val_state = 1; gp2a->power_state &= PROXIMITY_ENABLED; gp2a_dbgmsg("success\n"); value = 0x08; gp2a_i2c_write(gp2a, REGS_GAIN, &value); value = nondetect; gp2a_i2c_write(gp2a, REGS_HYS, &value); value = 0x04; gp2a_i2c_write(gp2a, REGS_CYCLE, &value); value = 0x18; gp2a_i2c_write(gp2a, REGS_CON, &value); value = 0x02; gp2a_i2c_write(gp2a, REGS_OPMOD, &value); goto done; err_request_irq: err_gpio_direction_input: gpio_free(pdata->p_out); done: return rc; }
/* pdev is NULL for eisa */ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev) { struct request_queue *q; int j; /* * register block devices * Find disks and fill in structs * Get an interrupt, set the Q depth and get into /proc */ /* If this successful it should insure that we are the only */ /* instance of the driver */ if (register_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname)) { goto Enomem4; } hba[i]->access.set_intr_mask(hba[i], 0); if (request_irq(hba[i]->intr, do_ida_intr, IRQF_DISABLED|IRQF_SHARED, hba[i]->devname, hba[i])) { printk(KERN_ERR "cpqarray: Unable to get irq %d for %s\n", hba[i]->intr, hba[i]->devname); goto Enomem3; } for (j=0; j<NWD; j++) { ida_gendisk[i][j] = alloc_disk(1 << NWD_SHIFT); if (!ida_gendisk[i][j]) goto Enomem2; } hba[i]->cmd_pool = pci_alloc_consistent( hba[i]->pci_dev, NR_CMDS * sizeof(cmdlist_t), &(hba[i]->cmd_pool_dhandle)); hba[i]->cmd_pool_bits = kcalloc( (NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG, sizeof(unsigned long), GFP_KERNEL); if (!hba[i]->cmd_pool_bits || !hba[i]->cmd_pool) goto Enomem1; memset(hba[i]->cmd_pool, 0, NR_CMDS * sizeof(cmdlist_t)); printk(KERN_INFO "cpqarray: Finding drives on %s", hba[i]->devname); spin_lock_init(&hba[i]->lock); q = blk_init_queue(do_ida_request, &hba[i]->lock); if (!q) goto Enomem1; hba[i]->queue = q; q->queuedata = hba[i]; getgeometry(i); start_fwbk(i); ida_procinit(i); if (pdev) blk_queue_bounce_limit(q, hba[i]->pci_dev->dma_mask); /* This is a hardware imposed limit. */ blk_queue_max_hw_segments(q, SG_MAX); /* This is a driver limit and could be eliminated. */ blk_queue_max_phys_segments(q, SG_MAX); init_timer(&hba[i]->timer); hba[i]->timer.expires = jiffies + IDA_TIMER; hba[i]->timer.data = (unsigned long)hba[i]; hba[i]->timer.function = ida_timer; add_timer(&hba[i]->timer); /* Enable IRQ now that spinlock and rate limit timer are set up */ hba[i]->access.set_intr_mask(hba[i], FIFO_NOT_EMPTY); for(j=0; j<NWD; j++) { struct gendisk *disk = ida_gendisk[i][j]; drv_info_t *drv = &hba[i]->drv[j]; sprintf(disk->disk_name, "ida/c%dd%d", i, j); disk->major = COMPAQ_SMART2_MAJOR + i; disk->first_minor = j<<NWD_SHIFT; disk->fops = &ida_fops; if (j && !drv->nr_blks) continue; blk_queue_hardsect_size(hba[i]->queue, drv->blk_size); set_capacity(disk, drv->nr_blks); disk->queue = hba[i]->queue; disk->private_data = drv; add_disk(disk); } /* done ! */ return(i); Enomem1: nr_ctlr = i; kfree(hba[i]->cmd_pool_bits); if (hba[i]->cmd_pool) pci_free_consistent(hba[i]->pci_dev, NR_CMDS*sizeof(cmdlist_t), hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle); Enomem2: while (j--) { put_disk(ida_gendisk[i][j]); ida_gendisk[i][j] = NULL; } free_irq(hba[i]->intr, hba[i]); Enomem3: unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname); Enomem4: if (pdev) pci_set_drvdata(pdev, NULL); release_io_mem(hba[i]); free_hba(i); printk( KERN_ERR "cpqarray: out of memory"); return -1; }
static int __init init_tcic(void) { int i, sock, ret = 0; u_int mask, scan; if (platform_driver_register(&tcic_driver)) return -1; ; sock = 0; if (!request_region(tcic_base, 16, "tcic-2")) { ; platform_driver_unregister(&tcic_driver); return -ENODEV; } else { tcic_setw(TCIC_ADDR, 0); if (tcic_getw(TCIC_ADDR) == 0) { tcic_setw(TCIC_ADDR, 0xc3a5); if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2; } if (sock == 0) { /* See if resetting the controller does any good */ tcic_setb(TCIC_SCTRL, TCIC_SCTRL_RESET); tcic_setb(TCIC_SCTRL, 0); tcic_setw(TCIC_ADDR, 0); if (tcic_getw(TCIC_ADDR) == 0) { tcic_setw(TCIC_ADDR, 0xc3a5); if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2; } } } if (sock == 0) { ; release_region(tcic_base, 16); platform_driver_unregister(&tcic_driver); return -ENODEV; } sockets = 0; for (i = 0; i < sock; i++) { if ((i == ignore) || is_active(i)) continue; socket_table[sockets].psock = i; socket_table[sockets].id = get_tcic_id(); socket_table[sockets].socket.owner = THIS_MODULE; /* only 16-bit cards, memory windows must be size-aligned */ /* No PCI or CardBus support */ socket_table[sockets].socket.features = SS_CAP_PCCARD | SS_CAP_MEM_ALIGN; /* irq 14, 11, 10, 7, 6, 5, 4, 3 */ socket_table[sockets].socket.irq_mask = 0x4cf8; /* 4K minimum window size */ socket_table[sockets].socket.map_size = 0x1000; sockets++; } switch (socket_table[0].id) { case TCIC_ID_DB86082: ; case TCIC_ID_DB86082A: ; case TCIC_ID_DB86084: ; case TCIC_ID_DB86084A: ; case TCIC_ID_DB86072: ; case TCIC_ID_DB86184: ; case TCIC_ID_DB86082B: ; default: ; } /* Set up polling */ poll_timer.function = &tcic_timer; poll_timer.data = 0; init_timer(&poll_timer); /* Build interrupt mask */ ; ; if (irq_list_count == 0) mask = irq_mask; else for (i = mask = 0; i < irq_list_count; i++) mask |= (1<<irq_list[i]); /* irq 14, 11, 10, 7, 6, 5, 4, 3 */ mask &= 0x4cf8; /* Scan interrupts */ mask = irq_scan(mask); for (i=0;i<sockets;i++) socket_table[i].socket.irq_mask = mask; /* Check for only two interrupts available */ scan = (mask & (mask-1)); if (((scan & (scan-1)) == 0) && (poll_interval == 0)) poll_interval = HZ; if (poll_interval == 0) { /* Avoid irq 12 unless it is explicitly requested */ u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12)); for (i = 15; i > 0; i--) if ((cs_mask & (1 << i)) && (request_irq(i, tcic_interrupt, 0, "tcic", tcic_interrupt) == 0)) break; cs_irq = i; if (cs_irq == 0) poll_interval = HZ; } if (socket_table[0].socket.irq_mask & (1 << 11)) ; if (cs_irq != 0) ; else // printk("polled status, interval = %d ms\n", ; for (i = 0; i < sockets; i++) { tcic_setw(TCIC_ADDR+2, socket_table[i].psock << TCIC_SS_SHFT); socket_table[i].last_sstat = tcic_getb(TCIC_SSTAT); } /* jump start interrupt handler, if needed */ tcic_interrupt(0, NULL); platform_device_register(&tcic_device); for (i = 0; i < sockets; i++) { socket_table[i].socket.ops = &tcic_operations; socket_table[i].socket.resource_ops = &pccard_nonstatic_ops; socket_table[i].socket.dev.parent = &tcic_device.dev; ret = pcmcia_register_socket(&socket_table[i].socket); if (ret && i) pcmcia_unregister_socket(&socket_table[0].socket); } return ret; return 0; } /* init_tcic */
static int b1pci_probe(struct capicardparams *p, struct pci_dev *pdev) { avmcard *card; avmctrl_info *cinfo; int retval; card = b1_alloc_card(1); if (!card) { printk(KERN_WARNING "b1pci: no memory.\n"); retval = -ENOMEM; goto err; } cinfo = card->ctrlinfo; sprintf(card->name, "b1pci-%x", p->port); card->port = p->port; card->irq = p->irq; card->cardtype = avm_b1pci; if (!request_region(card->port, AVMB1_PORTLEN, card->name)) { printk(KERN_WARNING "b1pci: ports 0x%03x-0x%03x in use.\n", card->port, card->port + AVMB1_PORTLEN); retval = -EBUSY; goto err_free; } b1_reset(card->port); retval = b1_detect(card->port, card->cardtype); if (retval) { printk(KERN_NOTICE "b1pci: NO card at 0x%x (%d)\n", card->port, retval); retval = -ENODEV; goto err_release_region; } b1_reset(card->port); b1_getrevision(card); retval = request_irq(card->irq, b1_interrupt, SA_SHIRQ, card->name, card); if (retval) { printk(KERN_ERR "b1pci: unable to get IRQ %d.\n", card->irq); retval = -EBUSY; goto err_release_region; } cinfo->capi_ctrl.driver_name = "b1pci"; cinfo->capi_ctrl.driverdata = cinfo; cinfo->capi_ctrl.register_appl = b1_register_appl; cinfo->capi_ctrl.release_appl = b1_release_appl; cinfo->capi_ctrl.send_message = b1_send_message; cinfo->capi_ctrl.load_firmware = b1_load_firmware; cinfo->capi_ctrl.reset_ctr = b1_reset_ctr; cinfo->capi_ctrl.procinfo = b1pci_procinfo; cinfo->capi_ctrl.ctr_read_proc = b1ctl_read_proc; strcpy(cinfo->capi_ctrl.name, card->name); cinfo->capi_ctrl.owner = THIS_MODULE; retval = attach_capi_ctr(&cinfo->capi_ctrl); if (retval) { printk(KERN_ERR "b1pci: attach controller failed.\n"); goto err_free_irq; } if (card->revision >= 4) { printk(KERN_INFO "b1pci: AVM B1 PCI V4 at i/o %#x, irq %d, revision %d (no dma)\n", card->port, card->irq, card->revision); } else { printk(KERN_INFO "b1pci: AVM B1 PCI at i/o %#x, irq %d, revision %d\n", card->port, card->irq, card->revision); } pci_set_drvdata(pdev, card); return 0; err_free_irq: free_irq(card->irq, card); err_release_region: release_region(card->port, AVMB1_PORTLEN); err_free: b1_free_card(card); err: return retval; }
/* * Configure the SSC. */ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream); int id = dai->id; struct atmel_ssc_info *ssc_p = &ssc_info[id]; struct atmel_pcm_dma_params *dma_params; int dir, channels, bits; u32 tfmr, rfmr, tcmr, rcmr; int start_event; int ret; /* * Currently, there is only one set of dma params for * each direction. If more are added, this code will * have to be changed to select the proper set. */ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dir = 0; else dir = 1; dma_params = &ssc_dma_params[id][dir]; dma_params->ssc = ssc_p->ssc; dma_params->substream = substream; ssc_p->dma_params[dir] = dma_params; /* * The snd_soc_pcm_stream->dma_data field is only used to communicate * the appropriate DMA parameters to the pcm driver hw_params() * function. It should not be used for other purposes * as it is common to all substreams. */ snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_params); channels = params_channels(params); /* * Determine sample size in bits and the PDC increment. */ switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: bits = 8; dma_params->pdc_xfer_size = 1; break; case SNDRV_PCM_FORMAT_S16_LE: bits = 16; dma_params->pdc_xfer_size = 2; break; case SNDRV_PCM_FORMAT_S24_LE: bits = 24; dma_params->pdc_xfer_size = 4; break; case SNDRV_PCM_FORMAT_S32_LE: bits = 32; dma_params->pdc_xfer_size = 4; break; default: printk(KERN_WARNING "atmel_ssc_dai: unsupported PCM format"); return -EINVAL; } /* * The SSC only supports up to 16-bit samples in I2S format, due * to the size of the Frame Mode Register FSLEN field. */ if ((ssc_p->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_I2S && bits > 16) { printk(KERN_WARNING "atmel_ssc_dai: sample size %d " "is too large for I2S\n", bits); return -EINVAL; } /* * Compute SSC register settings. */ switch (ssc_p->daifmt & (SND_SOC_DAIFMT_FORMAT_MASK | SND_SOC_DAIFMT_MASTER_MASK)) { case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS: /* * I2S format, SSC provides BCLK and LRC clocks. * * The SSC transmit and receive clocks are generated * from the MCK divider, and the BCLK signal * is output on the SSC TK line. */ rcmr = SSC_BF(RCMR_PERIOD, ssc_p->rcmr_period) | SSC_BF(RCMR_STTDLY, START_DELAY) | SSC_BF(RCMR_START, SSC_START_FALLING_RF) | SSC_BF(RCMR_CKI, SSC_CKI_RISING) | SSC_BF(RCMR_CKO, SSC_CKO_NONE) | SSC_BF(RCMR_CKS, SSC_CKS_DIV); rfmr = SSC_BF(RFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(RFMR_FSOS, SSC_FSOS_NEGATIVE) | SSC_BF(RFMR_FSLEN, (bits - 1)) | SSC_BF(RFMR_DATNB, (channels - 1)) | SSC_BIT(RFMR_MSBF) | SSC_BF(RFMR_LOOP, 0) | SSC_BF(RFMR_DATLEN, (bits - 1)); tcmr = SSC_BF(TCMR_PERIOD, ssc_p->tcmr_period) | SSC_BF(TCMR_STTDLY, START_DELAY) | SSC_BF(TCMR_START, SSC_START_FALLING_RF) | SSC_BF(TCMR_CKI, SSC_CKI_FALLING) | SSC_BF(TCMR_CKO, SSC_CKO_CONTINUOUS) | SSC_BF(TCMR_CKS, SSC_CKS_DIV); tfmr = SSC_BF(TFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(TFMR_FSDEN, 0) | SSC_BF(TFMR_FSOS, SSC_FSOS_NEGATIVE) | SSC_BF(TFMR_FSLEN, (bits - 1)) | SSC_BF(TFMR_DATNB, (channels - 1)) | SSC_BIT(TFMR_MSBF) | SSC_BF(TFMR_DATDEF, 0) | SSC_BF(TFMR_DATLEN, (bits - 1)); break; case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBM_CFM: /* * I2S format, CODEC supplies BCLK and LRC clocks. * * The SSC transmit clock is obtained from the BCLK signal on * on the TK line, and the SSC receive clock is * generated from the transmit clock. * * For single channel data, one sample is transferred * on the falling edge of the LRC clock. * For two channel data, one sample is * transferred on both edges of the LRC clock. */ start_event = ((channels == 1) ? SSC_START_FALLING_RF : SSC_START_EDGE_RF); rcmr = SSC_BF(RCMR_PERIOD, 0) | SSC_BF(RCMR_STTDLY, START_DELAY) | SSC_BF(RCMR_START, start_event) | SSC_BF(RCMR_CKI, SSC_CKI_RISING) | SSC_BF(RCMR_CKO, SSC_CKO_NONE) | SSC_BF(RCMR_CKS, SSC_CKS_CLOCK); rfmr = SSC_BF(RFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(RFMR_FSOS, SSC_FSOS_NONE) | SSC_BF(RFMR_FSLEN, 0) | SSC_BF(RFMR_DATNB, 0) | SSC_BIT(RFMR_MSBF) | SSC_BF(RFMR_LOOP, 0) | SSC_BF(RFMR_DATLEN, (bits - 1)); tcmr = SSC_BF(TCMR_PERIOD, 0) | SSC_BF(TCMR_STTDLY, START_DELAY) | SSC_BF(TCMR_START, start_event) | SSC_BF(TCMR_CKI, SSC_CKI_FALLING) | SSC_BF(TCMR_CKO, SSC_CKO_NONE) | SSC_BF(TCMR_CKS, SSC_CKS_PIN); tfmr = SSC_BF(TFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(TFMR_FSDEN, 0) | SSC_BF(TFMR_FSOS, SSC_FSOS_NONE) | SSC_BF(TFMR_FSLEN, 0) | SSC_BF(TFMR_DATNB, 0) | SSC_BIT(TFMR_MSBF) | SSC_BF(TFMR_DATDEF, 0) | SSC_BF(TFMR_DATLEN, (bits - 1)); break; case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBS_CFS: /* * DSP/PCM Mode A format, SSC provides BCLK and LRC clocks. * * The SSC transmit and receive clocks are generated from the * MCK divider, and the BCLK signal is output * on the SSC TK line. */ rcmr = SSC_BF(RCMR_PERIOD, ssc_p->rcmr_period) | SSC_BF(RCMR_STTDLY, 1) | SSC_BF(RCMR_START, SSC_START_RISING_RF) | SSC_BF(RCMR_CKI, SSC_CKI_RISING) | SSC_BF(RCMR_CKO, SSC_CKO_NONE) | SSC_BF(RCMR_CKS, SSC_CKS_DIV); rfmr = SSC_BF(RFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(RFMR_FSOS, SSC_FSOS_POSITIVE) | SSC_BF(RFMR_FSLEN, 0) | SSC_BF(RFMR_DATNB, (channels - 1)) | SSC_BIT(RFMR_MSBF) | SSC_BF(RFMR_LOOP, 0) | SSC_BF(RFMR_DATLEN, (bits - 1)); tcmr = SSC_BF(TCMR_PERIOD, ssc_p->tcmr_period) | SSC_BF(TCMR_STTDLY, 1) | SSC_BF(TCMR_START, SSC_START_RISING_RF) | SSC_BF(TCMR_CKI, SSC_CKI_RISING) | SSC_BF(TCMR_CKO, SSC_CKO_CONTINUOUS) | SSC_BF(TCMR_CKS, SSC_CKS_DIV); tfmr = SSC_BF(TFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(TFMR_FSDEN, 0) | SSC_BF(TFMR_FSOS, SSC_FSOS_POSITIVE) | SSC_BF(TFMR_FSLEN, 0) | SSC_BF(TFMR_DATNB, (channels - 1)) | SSC_BIT(TFMR_MSBF) | SSC_BF(TFMR_DATDEF, 0) | SSC_BF(TFMR_DATLEN, (bits - 1)); break; case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBM_CFM: /* * DSP/PCM Mode A format, CODEC supplies BCLK and LRC clocks. * * The SSC transmit clock is obtained from the BCLK signal on * on the TK line, and the SSC receive clock is * generated from the transmit clock. * * Data is transferred on first BCLK after LRC pulse rising * edge.If stereo, the right channel data is contiguous with * the left channel data. */ rcmr = SSC_BF(RCMR_PERIOD, 0) | SSC_BF(RCMR_STTDLY, START_DELAY) | SSC_BF(RCMR_START, SSC_START_RISING_RF) | SSC_BF(RCMR_CKI, SSC_CKI_RISING) | SSC_BF(RCMR_CKO, SSC_CKO_NONE) | SSC_BF(RCMR_CKS, SSC_CKS_PIN); rfmr = SSC_BF(RFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(RFMR_FSOS, SSC_FSOS_NONE) | SSC_BF(RFMR_FSLEN, 0) | SSC_BF(RFMR_DATNB, (channels - 1)) | SSC_BIT(RFMR_MSBF) | SSC_BF(RFMR_LOOP, 0) | SSC_BF(RFMR_DATLEN, (bits - 1)); tcmr = SSC_BF(TCMR_PERIOD, 0) | SSC_BF(TCMR_STTDLY, START_DELAY) | SSC_BF(TCMR_START, SSC_START_RISING_RF) | SSC_BF(TCMR_CKI, SSC_CKI_FALLING) | SSC_BF(TCMR_CKO, SSC_CKO_NONE) | SSC_BF(TCMR_CKS, SSC_CKS_PIN); tfmr = SSC_BF(TFMR_FSEDGE, SSC_FSEDGE_POSITIVE) | SSC_BF(TFMR_FSDEN, 0) | SSC_BF(TFMR_FSOS, SSC_FSOS_NONE) | SSC_BF(TFMR_FSLEN, 0) | SSC_BF(TFMR_DATNB, (channels - 1)) | SSC_BIT(TFMR_MSBF) | SSC_BF(TFMR_DATDEF, 0) | SSC_BF(TFMR_DATLEN, (bits - 1)); break; default: printk(KERN_WARNING "atmel_ssc_dai: unsupported DAI format 0x%x\n", ssc_p->daifmt); return -EINVAL; } pr_debug("atmel_ssc_hw_params: " "RCMR=%08x RFMR=%08x TCMR=%08x TFMR=%08x\n", rcmr, rfmr, tcmr, tfmr); if (!ssc_p->initialized) { /* Enable PMC peripheral clock for this SSC */ pr_debug("atmel_ssc_dai: Starting clock\n"); clk_enable(ssc_p->ssc->clk); /* Reset the SSC and its PDC registers */ ssc_writel(ssc_p->ssc->regs, CR, SSC_BIT(CR_SWRST)); ssc_writel(ssc_p->ssc->regs, PDC_RPR, 0); ssc_writel(ssc_p->ssc->regs, PDC_RCR, 0); ssc_writel(ssc_p->ssc->regs, PDC_RNPR, 0); ssc_writel(ssc_p->ssc->regs, PDC_RNCR, 0); ssc_writel(ssc_p->ssc->regs, PDC_TPR, 0); ssc_writel(ssc_p->ssc->regs, PDC_TCR, 0); ssc_writel(ssc_p->ssc->regs, PDC_TNPR, 0); ssc_writel(ssc_p->ssc->regs, PDC_TNCR, 0); ret = request_irq(ssc_p->ssc->irq, atmel_ssc_interrupt, 0, ssc_p->name, ssc_p); if (ret < 0) { printk(KERN_WARNING "atmel_ssc_dai: request_irq failure\n"); pr_debug("Atmel_ssc_dai: Stoping clock\n"); clk_disable(ssc_p->ssc->clk); return ret; } ssc_p->initialized = 1; } /* set SSC clock mode register */ ssc_writel(ssc_p->ssc->regs, CMR, ssc_p->cmr_div); /* set receive clock mode and format */ ssc_writel(ssc_p->ssc->regs, RCMR, rcmr); ssc_writel(ssc_p->ssc->regs, RFMR, rfmr); /* set transmit clock mode and format */ ssc_writel(ssc_p->ssc->regs, TCMR, tcmr); ssc_writel(ssc_p->ssc->regs, TFMR, tfmr); pr_debug("atmel_ssc_dai,hw_params: SSC initialized\n"); return 0; }
struct pm_irq_chip * __devinit pm8xxx_irq_init(struct device *dev, const struct pm8xxx_irq_platform_data *pdata) { struct pm_irq_chip *chip; int devirq, rc; unsigned int pmirq; if (!pdata) { pr_err("No platform data\n"); return ERR_PTR(-EINVAL); } devirq = pdata->devirq; if (devirq < 0) { pr_err("missing devirq\n"); rc = devirq; return ERR_PTR(-EINVAL); } chip = kzalloc(sizeof(struct pm_irq_chip) + sizeof(u8) * pdata->irq_cdata.nirqs, GFP_KERNEL); if (!chip) { pr_err("Cannot alloc pm_irq_chip struct\n"); return ERR_PTR(-EINVAL); } chip->dev = dev; chip->devirq = devirq; chip->irq_base = pdata->irq_base; chip->num_irqs = pdata->irq_cdata.nirqs; chip->base_addr = pdata->irq_cdata.base_addr; chip->num_blocks = DIV_ROUND_UP(chip->num_irqs, 8); chip->num_masters = DIV_ROUND_UP(chip->num_blocks, 8); spin_lock_init(&chip->pm_irq_lock); for (pmirq = 0; pmirq < chip->num_irqs; pmirq++) { irq_set_chip_and_handler(chip->irq_base + pmirq, &pm8xxx_irq_chip, handle_level_irq); irq_set_chip_data(chip->irq_base + pmirq, chip); #ifdef CONFIG_ARM set_irq_flags(chip->irq_base + pmirq, IRQF_VALID); #else irq_set_noprobe(chip->irq_base + pmirq); #endif } if (devirq != 0) { rc = request_irq(devirq, pm8xxx_irq_handler, pdata->irq_trigger_flag, "pm8xxx_usr_irq", chip); if (rc) { pr_err("failed to request_irq for %d rc=%d\n", devirq, rc); } else { irq_set_irq_wake(devirq, 1); } } return chip; }
static int omap_irda_start(struct net_device *dev) { struct omap_irda *omap_ir = netdev_priv(dev); int err; omap_ir->speed = 9600; err = request_irq(dev->irq, omap_irda_irq, 0, dev->name, dev); if (err) goto err_irq; /* * The interrupt must remain disabled for now. */ disable_irq(dev->irq); /* Request DMA channels for IrDA hardware */ if (omap_request_dma(omap_ir->pdata->rx_channel, "IrDA Rx DMA", (void *)omap_irda_rx_dma_callback, dev, &(omap_ir->rx_dma_channel))) { printk(KERN_ERR "Failed to request IrDA Rx DMA\n"); goto err_irq; } if (omap_request_dma(omap_ir->pdata->tx_channel, "IrDA Tx DMA", (void *)omap_irda_tx_dma_callback, dev, &(omap_ir->tx_dma_channel))) { printk(KERN_ERR "Failed to request IrDA Tx DMA\n"); goto err_irq; } /* Allocate TX and RX buffers for DMA channels */ omap_ir->rx_buf_dma_virt = dma_alloc_coherent(NULL, IRDA_SKB_MAX_MTU, &(omap_ir->rx_buf_dma_phys), GFP_KERNEL); if (!omap_ir->rx_buf_dma_virt) { printk(KERN_ERR "Unable to allocate memory for rx_buf_dma\n"); goto err_irq; } omap_ir->tx_buf_dma_virt = dma_alloc_coherent(NULL, IRDA_SIR_MAX_FRAME, &(omap_ir->tx_buf_dma_phys), GFP_KERNEL); if (!omap_ir->tx_buf_dma_virt) { printk(KERN_ERR "Unable to allocate memory for tx_buf_dma\n"); goto err_mem1; } /* * Setup the serial port for the specified config. */ if (omap_ir->pdata->select_irda) omap_ir->pdata->select_irda(omap_ir->dev, IR_SEL); err = omap_irda_startup(dev); if (err) goto err_startup; omap_irda_set_speed(dev, omap_ir->speed = 9600); /* * Open a new IrLAP layer instance. */ omap_ir->irlap = irlap_open(dev, &omap_ir->qos, "omap_sir"); err = -ENOMEM; if (!omap_ir->irlap) goto err_irlap; /* Now enable the interrupt and start the queue */ omap_ir->open = 1; /* Start RX DMA */ omap_irda_start_rx_dma(omap_ir); enable_irq(dev->irq); netif_start_queue(dev); return 0; err_irlap: omap_ir->open = 0; omap_irda_shutdown(omap_ir); err_startup: dma_free_coherent(NULL, IRDA_SIR_MAX_FRAME, omap_ir->tx_buf_dma_virt, omap_ir->tx_buf_dma_phys); err_mem1: dma_free_coherent(NULL, IRDA_SKB_MAX_MTU, omap_ir->rx_buf_dma_virt, omap_ir->rx_buf_dma_phys); err_irq: free_irq(dev->irq, dev); return err; }
static int __devinit tsc2005_ts_init(struct tsc2005 *ts, struct tsc2005_platform_data *pdata) { struct input_dev *idev; int r; int x_max, y_max; init_timer(&ts->penup_timer); setup_timer(&ts->penup_timer, tsc2005_ts_penup_timer_handler, (unsigned long)ts); spin_lock_init(&ts->lock); mutex_init(&ts->mutex); ts->x_plate_ohm = pdata->ts_x_plate_ohm ? : 280; ts->hw_avg_max = pdata->ts_hw_avg; ts->stab_time = pdata->ts_stab_time; x_max = pdata->ts_x_max ? : 4096; ts->fudge_x = pdata->ts_x_fudge ? : 4; y_max = pdata->ts_y_max ? : 4096; ts->fudge_y = pdata->ts_y_fudge ? : 8; ts->p_max = pdata->ts_pressure_max ? : MAX_12BIT; ts->touch_pressure = pdata->ts_touch_pressure ? : ts->p_max; ts->fudge_p = pdata->ts_pressure_fudge ? : 2; ts->set_reset = pdata->set_reset; if (prescale) { x_max = x_size; y_max = y_size; } idev = input_allocate_device(); if (idev == NULL) { r = -ENOMEM; goto err1; } idev->name = "TSC2005 touchscreen"; snprintf(ts->phys, sizeof(ts->phys), "%s/input-ts", ts->spi->dev.bus_id); idev->phys = ts->phys; idev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY); idev->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | BIT_MASK(ABS_PRESSURE); idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); ts->idev = idev; tsc2005_ts_setup_spi_xfer(ts); input_set_abs_params(idev, ABS_X, 0, x_max, ts->fudge_x, 0); input_set_abs_params(idev, ABS_Y, 0, y_max, ts->fudge_y, 0); input_set_abs_params(idev, ABS_PRESSURE, 0, ts->p_max, ts->fudge_p, 0); tsc2005_start_scan(ts); r = request_irq(ts->spi->irq, tsc2005_ts_irq_handler, (((TSC2005_CFR2_INITVALUE & TSC2005_CFR2_IRQ_MASK) == TSC2005_CFR2_IRQ_PENDAV) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING) | IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "tsc2005", ts); if (r < 0) { dev_err(&ts->spi->dev, "unable to get DAV IRQ"); goto err2; } set_irq_wake(ts->spi->irq, 1); r = input_register_device(idev); if (r < 0) { dev_err(&ts->spi->dev, "can't register touchscreen device\n"); goto err3; } /* We can tolerate these failing */ r = device_create_file(&ts->spi->dev, &dev_attr_ts_ctrl_selftest); if (r < 0) dev_warn(&ts->spi->dev, "can't create sysfs file for %s: %d\n", dev_attr_ts_ctrl_selftest.attr.name, r); r = device_create_file(&ts->spi->dev, &dev_attr_pen_down); if (r < 0) dev_warn(&ts->spi->dev, "can't create sysfs file for %s: %d\n", dev_attr_pen_down.attr.name, r); r = device_create_file(&ts->spi->dev, &dev_attr_disable_ts); if (r < 0) dev_warn(&ts->spi->dev, "can't create sysfs file for %s: %d\n", dev_attr_disable_ts.attr.name, r); /* Finally, configure and start the optional EDD watchdog. */ ts->esd_timeout = pdata->esd_timeout; if (ts->esd_timeout && ts->set_reset) { unsigned long wdj; setup_timer(&ts->esd_timer, tsc2005_esd_timer_handler, (unsigned long)ts); INIT_WORK(&ts->esd_work, tsc2005_rst_handler); wdj = msecs_to_jiffies(ts->esd_timeout); ts->esd_timer.expires = round_jiffies(jiffies+wdj); add_timer(&ts->esd_timer); } return 0; err3: free_irq(ts->spi->irq, ts); err2: tsc2005_stop_scan(ts); input_free_device(idev); err1: return r; }
static int __devinit ds1305_probe(struct spi_device *spi) { struct ds1305 *ds1305; int status; u8 addr, value; struct ds1305_platform_data *pdata = spi->dev.platform_data; bool write_ctrl = false; /* Sanity check board setup data. This may be hooked up * in 3wire mode, but we don't care. Note that unless * there's an inverter in place, this needs SPI_CS_HIGH! */ if ((spi->bits_per_word && spi->bits_per_word != 8) || (spi->max_speed_hz > 2000000) || !(spi->mode & SPI_CPHA)) return -EINVAL; /* set up driver data */ ds1305 = kzalloc(sizeof *ds1305, GFP_KERNEL); if (!ds1305) return -ENOMEM; ds1305->spi = spi; spi_set_drvdata(spi, ds1305); /* read and cache control registers */ addr = DS1305_CONTROL; status = spi_write_then_read(spi, &addr, sizeof addr, ds1305->ctrl, sizeof ds1305->ctrl); if (status < 0) { dev_dbg(&spi->dev, "can't %s, %d\n", "read", status); goto fail0; } dev_dbg(&spi->dev, "ctrl %s: %02x %02x %02x\n", "read", ds1305->ctrl[0], ds1305->ctrl[1], ds1305->ctrl[2]); /* Sanity check register values ... partially compensating for the * fact that SPI has no device handshake. A pullup on MISO would * make these tests fail; but not all systems will have one. If * some register is neither 0x00 nor 0xff, a chip is likely there. */ if ((ds1305->ctrl[0] & 0x38) != 0 || (ds1305->ctrl[1] & 0xfc) != 0) { dev_dbg(&spi->dev, "RTC chip is not present\n"); status = -ENODEV; goto fail0; } if (ds1305->ctrl[2] == 0) dev_dbg(&spi->dev, "chip may not be present\n"); /* enable writes if needed ... if we were paranoid it would * make sense to enable them only when absolutely necessary. */ if (ds1305->ctrl[0] & DS1305_WP) { u8 buf[2]; ds1305->ctrl[0] &= ~DS1305_WP; buf[0] = DS1305_WRITE | DS1305_CONTROL; buf[1] = ds1305->ctrl[0]; status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0); dev_dbg(&spi->dev, "clear WP --> %d\n", status); if (status < 0) goto fail0; } /* on DS1305, maybe start oscillator; like most low power * oscillators, it may take a second to stabilize */ if (ds1305->ctrl[0] & DS1305_nEOSC) { ds1305->ctrl[0] &= ~DS1305_nEOSC; write_ctrl = true; dev_warn(&spi->dev, "SET TIME!\n"); } /* ack any pending IRQs */ if (ds1305->ctrl[1]) { ds1305->ctrl[1] = 0; write_ctrl = true; } /* this may need one-time (re)init */ if (pdata) { /* maybe enable trickle charge */ if (((ds1305->ctrl[2] & 0xf0) != DS1305_TRICKLE_MAGIC)) { ds1305->ctrl[2] = DS1305_TRICKLE_MAGIC | pdata->trickle; write_ctrl = true; } /* on DS1306, configure 1 Hz signal */ if (pdata->is_ds1306) { if (pdata->en_1hz) { if (!(ds1305->ctrl[0] & DS1306_1HZ)) { ds1305->ctrl[0] |= DS1306_1HZ; write_ctrl = true; } } else { if (ds1305->ctrl[0] & DS1306_1HZ) { ds1305->ctrl[0] &= ~DS1306_1HZ; write_ctrl = true; } } } } if (write_ctrl) { u8 buf[4]; buf[0] = DS1305_WRITE | DS1305_CONTROL; buf[1] = ds1305->ctrl[0]; buf[2] = ds1305->ctrl[1]; buf[3] = ds1305->ctrl[2]; status = spi_write_then_read(spi, buf, sizeof buf, NULL, 0); if (status < 0) { dev_dbg(&spi->dev, "can't %s, %d\n", "write", status); goto fail0; } dev_dbg(&spi->dev, "ctrl %s: %02x %02x %02x\n", "write", ds1305->ctrl[0], ds1305->ctrl[1], ds1305->ctrl[2]); } /* see if non-Linux software set up AM/PM mode */ addr = DS1305_HOUR; status = spi_write_then_read(spi, &addr, sizeof addr, &value, sizeof value); if (status < 0) { dev_dbg(&spi->dev, "read HOUR --> %d\n", status); goto fail0; } ds1305->hr12 = (DS1305_HR_12 & value) != 0; if (ds1305->hr12) dev_dbg(&spi->dev, "AM/PM\n"); /* register RTC ... from here on, ds1305->ctrl needs locking */ ds1305->rtc = rtc_device_register("ds1305", &spi->dev, &ds1305_ops, THIS_MODULE); if (IS_ERR(ds1305->rtc)) { status = PTR_ERR(ds1305->rtc); dev_dbg(&spi->dev, "register rtc --> %d\n", status); goto fail0; } /* Maybe set up alarm IRQ; be ready to handle it triggering right * away. NOTE that we don't share this. The signal is active low, * and we can't ack it before a SPI message delay. We temporarily * disable the IRQ until it's acked, which lets us work with more * IRQ trigger modes (not all IRQ controllers can do falling edge). */ if (spi->irq) { INIT_WORK(&ds1305->work, ds1305_work); status = request_irq(spi->irq, ds1305_irq, 0, dev_name(&ds1305->rtc->dev), ds1305); if (status < 0) { dev_dbg(&spi->dev, "request_irq %d --> %d\n", spi->irq, status); goto fail1; } device_set_wakeup_capable(&spi->dev, 1); } /* export NVRAM */ status = sysfs_create_bin_file(&spi->dev.kobj, &nvram); if (status < 0) { dev_dbg(&spi->dev, "register nvram --> %d\n", status); goto fail2; } return 0; fail2: free_irq(spi->irq, ds1305); fail1: rtc_device_unregister(ds1305->rtc); fail0: kfree(ds1305); return status; }
/* * si470x_i2c_probe - probe for the device */ static int __devinit si470x_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct si470x_device *radio; int retval = 0; unsigned char version_warning = 0; /* private data allocation and initialization */ radio = kzalloc(sizeof(struct si470x_device), GFP_KERNEL); if (!radio) { retval = -ENOMEM; goto err_initial; } INIT_WORK(&radio->radio_work, si470x_i2c_interrupt_work); radio->users = 0; radio->client = client; mutex_init(&radio->lock); /* video device allocation and initialization */ radio->videodev = video_device_alloc(); if (!radio->videodev) { retval = -ENOMEM; goto err_radio; } memcpy(radio->videodev, &si470x_viddev_template, sizeof(si470x_viddev_template)); video_set_drvdata(radio->videodev, radio); /* power up : need 110ms */ radio->registers[POWERCFG] = POWERCFG_ENABLE; if (si470x_set_register(radio, POWERCFG) < 0) { retval = -EIO; goto err_all; } msleep(110); /* get device and chip versions */ if (si470x_get_all_registers(radio) < 0) { retval = -EIO; goto err_video; } dev_info(&client->dev, "DeviceID=0x%4.4hx ChipID=0x%4.4hx\n", radio->registers[DEVICEID], radio->registers[CHIPID]); if ((radio->registers[CHIPID] & CHIPID_FIRMWARE) < RADIO_FW_VERSION) { dev_warn(&client->dev, "This driver is known to work with " "firmware version %hu,\n", RADIO_FW_VERSION); dev_warn(&client->dev, "but the device has firmware version %hu.\n", radio->registers[CHIPID] & CHIPID_FIRMWARE); version_warning = 1; } /* give out version warning */ if (version_warning == 1) { dev_warn(&client->dev, "If you have some trouble using this driver,\n"); dev_warn(&client->dev, "please report to V4L ML at " "[email protected]\n"); } /* set initial frequency */ si470x_set_freq(radio, 87.5 * FREQ_MUL); /* available in all regions */ /* rds buffer allocation */ radio->buf_size = rds_buf * 3; radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL); if (!radio->buffer) { retval = -EIO; goto err_video; } /* rds buffer configuration */ radio->wr_index = 0; radio->rd_index = 0; init_waitqueue_head(&radio->read_queue); retval = request_irq(client->irq, si470x_i2c_interrupt, IRQF_TRIGGER_FALLING, DRIVER_NAME, radio); if (retval) { dev_err(&client->dev, "Failed to register interrupt\n"); goto err_rds; } /* register video device */ retval = video_register_device(radio->videodev, VFL_TYPE_RADIO, radio_nr); if (retval) { dev_warn(&client->dev, "Could not register video device\n"); goto err_all; } i2c_set_clientdata(client, radio); return 0; err_all: free_irq(client->irq, radio); err_rds: kfree(radio->buffer); err_video: video_device_release(radio->videodev); err_radio: kfree(radio); err_initial: return retval; }
static int __devinit da8xx_rtc_probe(struct platform_device *pdev) { struct resource *res, *mem = NULL; struct rtc_device *rtc = NULL; int irq, ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { pr_debug("%s: No MEM resource in platform data.\n", pdev->name); ret = -ENOENT; goto err_out; } da8xx_rtc_pbase = res->start; da8xx_rtc_base_size = res->start - res->start + 1; mem = request_mem_region(res->start, da8xx_rtc_base_size, pdev->name); if (!mem) { pr_debug("%s: Can't reserve MEM resource.\n", pdev->name); ret = -EBUSY; goto err_out; } da8xx_rtc_base = ioremap(res->start, da8xx_rtc_base_size); if (da8xx_rtc_base == NULL) { pr_debug("%s: Can't ioremap MEM resource.\n", pdev->name); ret = -ENOMEM; goto err_out0; } rtc = rtc_device_register(pdev->name, &pdev->dev, &da8xx_rtc_ops, THIS_MODULE); if (IS_ERR(rtc)) { pr_debug("%s: Can't register device.\n", pdev->name); ret = PTR_ERR(rtc); goto err_out1; } platform_set_drvdata(pdev, rtc); irq = platform_get_irq(pdev, 0); if (irq <= 0) dev_warn(&pdev->dev, "No IRQ in platform data. Alarms disabled.\n"); else { ret = request_irq(irq, da8xx_rtc_intr, IRQF_DISABLED, pdev->name, pdev); if (ret) { pr_debug("%s: Failed to register handler for irq %d.\n", pdev->name, irq); ret = -EIO; goto err_out2; } da8xx_rtc_irq = irq; } da8xx_rtc_mmr_unlock(); if (!da8xx_rtc_is_enabled()) { pr_debug("%s: RTC disabled and can't be enabled.\n", pdev->name); ret = -EIO; goto err_out3; } #if 0 /* XXXX */ da8xx_rtc_sw_reset(); #endif da8xx_rtc_config(); da8xx_rtc_clear_alarm_intr(); da8xx_rtc_start(); dev_info(&pdev->dev, "TI DA8xx Real Time Clock driver.\n"); return 0; err_out3: if (da8xx_rtc_irq) free_irq(da8xx_rtc_irq, pdev); err_out2: platform_set_drvdata(pdev, NULL); rtc_device_unregister(rtc); err_out1: iounmap(da8xx_rtc_base); err_out0: release_mem_region(da8xx_rtc_pbase, da8xx_rtc_base_size); err_out: dev_err(&pdev->dev, "Unable to register RTC.\n"); return ret; }
static int rk2918_battery_probe(struct platform_device *pdev) { int ret; struct adc_client *client; struct rk2918_battery_data *data; struct rk2918_battery_platform_data *pdata = pdev->dev.platform_data; int irq_flag; int i = 0; dprint("func=%s, line=%d :\n", __func__, __LINE__); data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) { ret = -ENOMEM; goto err_data_alloc_failed; } gBatteryData = data; //clear io data->dc_det_pin = INVALID_GPIO; data->batt_low_pin = INVALID_GPIO; data->charge_set_pin = INVALID_GPIO; data->charge_ok_pin = INVALID_GPIO; if (pdata && pdata->io_init) { ret = pdata->io_init(); if (ret) goto err_free_gpio1; } //dc det if (pdata->dc_det_pin != INVALID_GPIO) { #ifndef DC_DET_WITH_USB_INT ret = gpio_request(pdata->dc_det_pin, NULL); if (ret) { printk("failed to request dc_det gpio\n"); goto err_free_gpio1; } #endif if(pdata->dc_det_level) gpio_pull_updown(pdata->dc_det_pin, 0);//important else gpio_pull_updown(pdata->dc_det_pin, GPIOPullUp);//important ret = gpio_direction_input(pdata->dc_det_pin); if (ret) { printk("failed to set gpio dc_det input\n"); goto err_free_gpio1; } data->dc_det_pin = pdata->dc_det_pin; data->dc_det_level = pdata->dc_det_level; } if (pdata->charge_cur_ctl != INVALID_GPIO) { ret = gpio_request(pdata->charge_cur_ctl, "DC_CURRENT_CONTROL"); if (ret < 0) { printk("failed to request charge current control gpio\n"); goto err_free_gpio2; } ret = gpio_direction_output(pdata->charge_cur_ctl, !pdata->charge_cur_ctl_level); if (ret < 0) { printk("rk29_battery: failed to set charge current control gpio\n"); goto err_free_gpio2; } gpio_pull_updown(pdata->charge_cur_ctl, !pdata->charge_cur_ctl_level); gpio_set_value(pdata->charge_cur_ctl, !pdata->charge_cur_ctl_level); data->charge_cur_ctl = pdata->charge_cur_ctl; data->charge_cur_ctl_level = pdata->charge_cur_ctl_level; } //charge set for usb charge if (pdata->charge_set_pin != INVALID_GPIO) { ret = gpio_request(pdata->charge_set_pin, NULL); if (ret) { printk("failed to request dc_det gpio\n"); goto err_free_gpio2; } data->charge_set_pin = pdata->charge_set_pin; data->charge_set_level = pdata->charge_set_level; gpio_direction_output(pdata->charge_set_pin, 1 - pdata->charge_set_level); } //charge_ok if (pdata->charge_ok_pin != INVALID_GPIO) { ret = gpio_request(pdata->charge_ok_pin, NULL); if (ret) { printk("failed to request charge_ok gpio\n"); goto err_free_gpio3; } gpio_pull_updown(pdata->charge_ok_pin, GPIOPullUp);//important ret = gpio_direction_input(pdata->charge_ok_pin); if (ret) { printk("failed to set gpio charge_ok input\n"); goto err_free_gpio3; } data->charge_ok_pin = pdata->charge_ok_pin; data->charge_ok_level = pdata->charge_ok_level; } client = adc_register(0, rk2918_battery_callback, NULL); if(!client) goto err_adc_register_failed; memset(gBatVoltageSamples, 0, sizeof(gBatVoltageSamples)); spin_lock_init(&data->lock); data->adc_val = adc_sync_read(client); data->client = client; data->battery.properties = rk2918_battery_props; data->battery.num_properties = ARRAY_SIZE(rk2918_battery_props); data->battery.get_property = rk2918_battery_get_property; data->battery.name = "battery"; data->battery.type = POWER_SUPPLY_TYPE_BATTERY; data->adc_bat_divider = 414; data->bat_max = BATT_MAX_VOL_VALUE; data->bat_min = BATT_ZERO_VOL_VALUE; DBG("bat_min = %d\n",data->bat_min); #ifdef RK29_USB_CHARGE_SUPPORT data->usb.properties = rk2918_usb_props; data->usb.num_properties = ARRAY_SIZE(rk2918_usb_props); data->usb.get_property = rk2918_usb_get_property; data->usb.name = "usb"; data->usb.type = POWER_SUPPLY_TYPE_USB; #endif data->ac.properties = rk2918_ac_props; data->ac.num_properties = ARRAY_SIZE(rk2918_ac_props); data->ac.get_property = rk2918_ac_get_property; data->ac.name = "ac"; data->ac.type = POWER_SUPPLY_TYPE_MAINS; rk2918_low_battery_check(); ret = power_supply_register(&pdev->dev, &data->ac); if (ret) { printk(KERN_INFO "fail to ac power_supply_register\n"); goto err_ac_failed; } #if 0 ret = power_supply_register(&pdev->dev, &data->usb); if (ret) { printk(KERN_INFO "fail to usb power_supply_register\n"); goto err_usb_failed; } #endif ret = power_supply_register(&pdev->dev, &data->battery); if (ret) { printk(KERN_INFO "fail to battery power_supply_register\n"); goto err_battery_failed; } platform_set_drvdata(pdev, data); // irq_flag = (pdata->charge_ok_level) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; // ret = request_irq(gpio_to_irq(pdata->charge_ok_pin), rk2918_battery_interrupt, irq_flag, "rk2918_battery", data); // if (ret) { // printk("failed to request irq\n"); // goto err_irq_failed; // } #ifndef DC_DET_WITH_USB_INT if (pdata->dc_det_pin != INVALID_GPIO) { irq_flag = (!gpio_get_value (pdata->dc_det_pin)) ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING; ret = request_irq(gpio_to_irq(pdata->dc_det_pin), rk2918_dc_wakeup, irq_flag, "rk2918_battery", data); if (ret) { printk("failed to request dc det irq\n"); goto err_dcirq_failed; } data->dc_det_irq = gpio_to_irq(pdata->dc_det_pin); //data->wq = create_rt_workqueue("rk2918_battery"); data->wq = create_workqueue("rk2918_battery"); INIT_DELAYED_WORK(&data->work, rk2918_battery_work); enable_irq_wake(gpio_to_irq(pdata->dc_det_pin)); } #endif setup_timer(&data->timer, rk2918_batscan_timer, (unsigned long)data); // changed to notify android of status.... data->timer.expires = jiffies + 5000; // 2000 add_timer(&data->timer); INIT_WORK(&data->timer_work, rk2918_battery_timer_work); rk29_battery_dbg_class = class_create(THIS_MODULE, "rk29_battery"); battery_dev = device_create(rk29_battery_dbg_class, NULL, MKDEV(0, 1), NULL, "battery"); ret = device_create_file(battery_dev, &dev_attr_rk29_battery_dbg); if (ret) { printk("create file sys failed!!! \n"); goto err_dcirq_failed; } for(i = 0; i<10; i++) { ret = device_create_file(&pdev->dev, &dev_attr_startget); if (ret) { printk("make a mistake in creating devices attr file, failed times: %d\n\n ", i+1); continue; } break; } printk(KERN_INFO "rk2918_battery: driver initialized\n"); return 0; err_dcirq_failed: free_irq(gpio_to_irq(pdata->dc_det_pin), data); err_irq_failed: free_irq(gpio_to_irq(pdata->charge_ok_pin), data); err_battery_failed: // power_supply_unregister(&data->usb); //err_usb_failed: err_ac_failed: power_supply_unregister(&data->ac); err_adc_register_failed: err_free_gpio3: gpio_free(pdata->charge_ok_pin); err_free_gpio2: gpio_free(pdata->charge_cur_ctl); err_free_gpio1: gpio_free(pdata->dc_det_pin); err_data_alloc_failed: kfree(data); printk("rk2918_battery: error!\n"); return ret; }
/* Allocate memory for one device */ static int nozomi_card_init(struct pci_dev *pdev, const struct pci_device_id *ent) { resource_size_t start; int ret; struct nozomi *dc = NULL; int ndev_idx; int i; dev_dbg(&pdev->dev, "Init, new card found\n"); for (ndev_idx = 0; ndev_idx < ARRAY_SIZE(ndevs); ndev_idx++) if (!ndevs[ndev_idx]) break; if (ndev_idx >= ARRAY_SIZE(ndevs)) { dev_err(&pdev->dev, "no free tty range for this card left\n"); ret = -EIO; goto err; } dc = kzalloc(sizeof(struct nozomi), GFP_KERNEL); if (unlikely(!dc)) { dev_err(&pdev->dev, "Could not allocate memory\n"); ret = -ENOMEM; goto err_free; } dc->pdev = pdev; ret = pci_enable_device(dc->pdev); if (ret) { dev_err(&pdev->dev, "Failed to enable PCI Device\n"); goto err_free; } ret = pci_request_regions(dc->pdev, NOZOMI_NAME); if (ret) { dev_err(&pdev->dev, "I/O address 0x%04x already in use\n", (int) /* nozomi_private.io_addr */ 0); goto err_disable_device; } start = pci_resource_start(dc->pdev, 0); if (start == 0) { dev_err(&pdev->dev, "No I/O address for card detected\n"); ret = -ENODEV; goto err_rel_regs; } /* Find out what card type it is */ nozomi_get_card_type(dc); dc->base_addr = ioremap_nocache(start, dc->card_type); if (!dc->base_addr) { dev_err(&pdev->dev, "Unable to map card MMIO\n"); ret = -ENODEV; goto err_rel_regs; } dc->send_buf = kmalloc(SEND_BUF_MAX, GFP_KERNEL); if (!dc->send_buf) { dev_err(&pdev->dev, "Could not allocate send buffer?\n"); ret = -ENOMEM; goto err_free_sbuf; } for (i = PORT_MDM; i < MAX_PORT; i++) { if (kfifo_alloc(&dc->port[i].fifo_ul, FIFO_BUFFER_SIZE_UL, GFP_KERNEL)) { dev_err(&pdev->dev, "Could not allocate kfifo buffer\n"); ret = -ENOMEM; goto err_free_kfifo; } } spin_lock_init(&dc->spin_mutex); nozomi_setup_private_data(dc); /* Disable all interrupts */ dc->last_ier = 0; writew(dc->last_ier, dc->reg_ier); ret = request_irq(pdev->irq, &interrupt_handler, IRQF_SHARED, NOZOMI_NAME, dc); if (unlikely(ret)) { dev_err(&pdev->dev, "can't request irq %d\n", pdev->irq); goto err_free_kfifo; } DBG1("base_addr: %p", dc->base_addr); make_sysfs_files(dc); dc->index_start = ndev_idx * MAX_PORT; ndevs[ndev_idx] = dc; pci_set_drvdata(pdev, dc); /* Enable RESET interrupt */ dc->last_ier = RESET; iowrite16(dc->last_ier, dc->reg_ier); dc->state = NOZOMI_STATE_ENABLED; for (i = 0; i < MAX_PORT; i++) { struct device *tty_dev; struct port *port = &dc->port[i]; port->dc = dc; tty_port_init(&port->port); port->port.ops = &noz_tty_port_ops; tty_dev = tty_port_register_device(&port->port, ntty_driver, dc->index_start + i, &pdev->dev); if (IS_ERR(tty_dev)) { ret = PTR_ERR(tty_dev); dev_err(&pdev->dev, "Could not allocate tty?\n"); tty_port_destroy(&port->port); goto err_free_tty; } } return 0; err_free_tty: for (i = 0; i < MAX_PORT; ++i) { tty_unregister_device(ntty_driver, dc->index_start + i); tty_port_destroy(&dc->port[i].port); } err_free_kfifo: for (i = 0; i < MAX_PORT; i++) kfifo_free(&dc->port[i].fifo_ul); err_free_sbuf: kfree(dc->send_buf); iounmap(dc->base_addr); err_rel_regs: pci_release_regions(pdev); err_disable_device: pci_disable_device(pdev); err_free: kfree(dc); err: return ret; }
static int mfc_probe(struct platform_device *pdev) { struct resource *res; size_t size; int ret; /* mfc clock enable should be here */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&pdev->dev, "failed to get memory region resource\n"); ret = -ENOENT; goto probe_out; } // 60K is required for mfc register (0x0 ~ 0xe008) size = (res->end - res->start) + 1; mfc_mem = request_mem_region(res->start, size, pdev->name); if (mfc_mem == NULL) { dev_err(&pdev->dev, "failed to get memory region\n"); ret = -ENOENT; goto probe_out; } mfc_sfr_base_vaddr = ioremap(mfc_mem->start, mfc_mem->end - mfc_mem->start + 1); if (mfc_sfr_base_vaddr == NULL) { dev_err(&pdev->dev, "failed to ioremap address region\n"); ret = -ENOENT; goto probe_out; } res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (res == NULL) { dev_err(&pdev->dev, "failed to get irq resource\n"); ret = -ENOENT; goto probe_out; } #if !defined(MFC_POLLING) ret = request_irq(res->start, mfc_irq, IRQF_DISABLED, pdev->name, pdev); if (ret != 0) { dev_err(&pdev->dev, "failed to install irq (%d)\n", ret); goto probe_out; } #endif mutex_init(&mfc_mutex); /* * buffer memory secure */ mfc_port0_base_paddr = s3c_get_media_memory_bank(S3C_MDEV_MFC, 0); mfc_port0_base_paddr = ALIGN_TO_128KB(mfc_port0_base_paddr); mfc_port0_base_vaddr = phys_to_virt(mfc_port0_base_paddr); if (mfc_port0_base_vaddr == NULL) { mfc_err("fail to mapping port0 buffer\n"); ret = -EPERM; goto probe_out; } mfc_port1_base_paddr = s3c_get_media_memory_bank(S3C_MDEV_MFC, 1); mfc_port1_base_paddr = ALIGN_TO_128KB(mfc_port1_base_paddr); mfc_port1_base_vaddr = phys_to_virt(mfc_port1_base_paddr); if (mfc_port1_base_vaddr == NULL) { mfc_err("fail to mapping port1 buffer\n"); ret = -EPERM; goto probe_out; } mfc_debug("mfc_port0_base_paddr = 0x%08x, mfc_port1_base_paddr = 0x%08x <<\n", (unsigned int)mfc_port0_base_paddr, (unsigned int)mfc_port1_base_paddr); mfc_debug("mfc_port0_base_vaddr = 0x%08x, mfc_port1_base_vaddr = 0x%08x <<\n", (unsigned int)mfc_port0_base_vaddr, (unsigned int)mfc_port1_base_vaddr); /* * MFC FW downloading */ if (mfc_load_firmware() < 0) { mfc_err("MFCINST_ERR_FW_INIT_FAIL\n"); ret = -EPERM; goto probe_out; } mfc_init_mem_inst_no(); mfc_init_buffer(); mfc_clk = clk_get(&pdev->dev, "mfc"); if (mfc_clk == NULL) { printk(KERN_ERR "failed to find mfc clock source\n"); return -ENOENT; } ret = misc_register(&mfc_miscdev); return 0; probe_out: dev_err(&pdev->dev, "not found (%d). \n", ret); return ret; }
static int mcs6000_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { int err = 0; struct mcs6000_ts_device *dev; DMSG("[sub]%s: start...\n", __FUNCTION__); ts_sub_pdata = client->dev.platform_data; #ifdef SLIDE_SUPPORT slider_state = 1; spin_lock_init(&mcs6000_slider_lock); #endif input_set_abs_params(mcs6000_ts_input, ABS_X, ts_sub_pdata->ts_x_min, ts_sub_pdata->ts_x_max, 0, 0); input_set_abs_params(mcs6000_ts_input, ABS_Y, ts_sub_pdata->ts_y_min, ts_sub_pdata->ts_y_max, 0, 0); #ifdef LG_FW_MULTI_TOUCH input_set_abs_params(mcs6000_ts_input, ABS_MT_POSITION_X, ts_sub_pdata->ts_x_min, ts_sub_pdata->ts_x_max, 0, 0); input_set_abs_params(mcs6000_ts_input, ABS_MT_POSITION_Y, ts_sub_pdata->ts_y_min, ts_sub_pdata->ts_y_max, 0, 0); #endif dev = &mcs6000_ts_dev; INIT_DELAYED_WORK(&dev->work, mcs6000_work); dev->power = ts_sub_pdata->power; dev->num_irq = ts_sub_pdata->irq; dev->intr_gpio = ts_sub_pdata->gpio_int; dev->hw_i2c = ts_sub_pdata->hw_i2c; dev->sda_gpio = ts_sub_pdata->sda; dev->scl_gpio = ts_sub_pdata->scl; dev->ce_gpio = ts_sub_pdata->ce; printk(KERN_DEBUG "Sub TS Power On. \n"); dev->power(ON); dev->input_dev = mcs6000_ts_input; DMSG("[sub]mcs6000 dev->num_irq is %d , dev->intr_gpio is %d\n", dev->num_irq,dev->intr_gpio); dev->client = client; i2c_set_clientdata(client, dev); if (!(err = i2c_check_functionality(client->adapter, I2C_FUNC_I2C))) { printk(KERN_ERR "[sub]%s: fucntionality check failed\n", __FUNCTION__); return err; } gpio_request(dev->intr_gpio, "mcs6000_ts_sub interrupt"); err = gpio_direction_input(dev->intr_gpio); if (err < 0) { printk(KERN_ERR "[sub]%s: gpio input direction fail\n", __FUNCTION__); return err; } // LGE_CHANGE [[email protected]] 2010-07-20, use request_irq for quick response /* TODO: You have try to change this driver's architecture using request_threaded_irq() * So, I will change this to request_threaded_irq() */ /* err = request_threaded_irq(dev->num_irq, NULL, mcs6000_ts_irq_handler, IRQF_TRIGGER_LOW | IRQF_ONESHOT, "mcs6000_ts", dev); */ err = request_irq(dev->num_irq, mcs6000_ts_irq_handler, IRQF_TRIGGER_FALLING, "mcs6000_ts_sub", dev); if (err < 0) { printk(KERN_ERR "[sub]%s: request_irq failed\n", __FUNCTION__); return err; } disable_irq(dev->num_irq); if (gpio_request(dev->ce_gpio, "sub_touch_ce")) printk("Failed to request SUB GPIO_TOUCH_EN!\n"); gpio_direction_output(dev->ce_gpio, 1); msleep(10); enable_irq(dev->num_irq); #ifdef CONFIG_HAS_EARLYSUSPEND ts_early_suspend.suspend = mcs6000_early_suspend; ts_early_suspend.resume = mcs6000_late_resume; ts_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN - 40; register_early_suspend(&ts_early_suspend); #endif #ifdef SLIDE_SUPPORT err = input_register_handler(&mcs6000_sld_input_handler); DMSG(KERN_INFO "[sub] slider input_register_handler: %d.\n", err); #endif mcs6000_firmware_info(); mcs6000_create_file(mcs6000_ts_input); DMSG(KERN_INFO "[sub]%s: ts driver probed\n", __FUNCTION__); #ifdef DISABLE_SUB_TOUCH mcs6000_ts_onoff(0); #endif return 0; }
static int __init snd_gusmax_probe(int dev) { static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1}; static int possible_dmas[] = {5, 6, 7, 1, 3, -1}; int xirq, xdma1, xdma2, err; snd_card_t *card; snd_gus_card_t *gus = NULL; cs4231_t *cs4231; struct snd_gusmax *maxcard; card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct snd_gusmax)); if (card == NULL) return -ENOMEM; card->private_free = snd_gusmax_free; maxcard = (struct snd_gusmax *)card->private_data; maxcard->card = card; maxcard->irq = -1; xirq = irq[dev]; if (xirq == SNDRV_AUTO_IRQ) { if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) { snd_card_free(card); snd_printk("unable to find a free IRQ\n"); return -EBUSY; } } xdma1 = dma1[dev]; if (xdma1 == SNDRV_AUTO_DMA) { if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) { snd_card_free(card); snd_printk("unable to find a free DMA1\n"); return -EBUSY; } } xdma2 = dma2[dev]; if (xdma2 == SNDRV_AUTO_DMA) { if ((xdma2 = snd_legacy_find_free_dma(possible_dmas)) < 0) { snd_card_free(card); snd_printk("unable to find a free DMA2\n"); return -EBUSY; } } if ((err = snd_gus_create(card, port[dev], -xirq, xdma1, xdma2, 0, channels[dev], pcm_channels[dev], 0, &gus)) < 0) { snd_card_free(card); return err; } if ((err = snd_gusmax_detect(gus)) < 0) { snd_card_free(card); return err; } maxcard->gus_status_reg = gus->gf1.reg_irqstat; maxcard->pcm_status_reg = gus->gf1.port + 0x10c + 2; snd_gusmax_init(dev, card, gus); if ((err = snd_gus_initialize(gus)) < 0) { snd_card_free(card); return err; } if (!gus->max_flag) { printk(KERN_ERR "GUS MAX soundcard was not detected at 0x%lx\n", gus->gf1.port); snd_card_free(card); return -ENODEV; } if (request_irq(xirq, snd_gusmax_interrupt, SA_INTERRUPT, "GUS MAX", (void *)maxcard)) { snd_card_free(card); printk(KERN_ERR "gusmax: unable to grab IRQ %d\n", xirq); return -EBUSY; } maxcard->irq = xirq; if ((err = snd_cs4231_create(card, gus->gf1.port + 0x10c, -1, xirq, xdma2 < 0 ? xdma1 : xdma2, xdma1, CS4231_HW_DETECT, CS4231_HWSHARE_IRQ | CS4231_HWSHARE_DMA1 | CS4231_HWSHARE_DMA2, &cs4231)) < 0) { snd_card_free(card); return err; } if ((err = snd_cs4231_pcm(cs4231, 0, NULL)) < 0) { snd_card_free(card); return err; } if ((err = snd_cs4231_mixer(cs4231)) < 0) { snd_card_free(card); return err; } if ((err = snd_cs4231_timer(cs4231, 2, NULL)) < 0) { snd_card_free(card); return err; } if (pcm_channels[dev] > 0) { if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0) { snd_card_free(card); return err; } } if ((err = snd_gusmax_mixer(cs4231)) < 0) { snd_card_free(card); return err; } if ((err = snd_gf1_rawmidi_new(gus, 0, NULL)) < 0) { snd_card_free(card); return err; } sprintf(card->longname + strlen(card->longname), " at 0x%lx, irq %i, dma %i", gus->gf1.port, xirq, xdma1); if (xdma2 >= 0) sprintf(card->longname + strlen(card->longname), "&%i", xdma2); if ((err = snd_card_register(card)) < 0) { snd_card_free(card); return err; } maxcard->gus = gus; maxcard->cs4231 = cs4231; snd_gusmax_cards[dev] = card; return 0; }
static int __devinit mmc_omap_probe(struct platform_device *pdev) { struct omap_mmc_platform_data *pdata = pdev->dev.platform_data; struct mmc_omap_host *host = NULL; struct resource *res; dma_cap_mask_t mask; unsigned sig; int i, ret = 0; int irq; if (pdata == NULL) { dev_err(&pdev->dev, "platform data missing\n"); return -ENXIO; } if (pdata->nr_slots == 0) { dev_err(&pdev->dev, "no slots\n"); return -ENXIO; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); irq = platform_get_irq(pdev, 0); if (res == NULL || irq < 0) return -ENXIO; res = request_mem_region(res->start, resource_size(res), pdev->name); if (res == NULL) return -EBUSY; host = kzalloc(sizeof(struct mmc_omap_host), GFP_KERNEL); if (host == NULL) { ret = -ENOMEM; goto err_free_mem_region; } INIT_WORK(&host->slot_release_work, mmc_omap_slot_release_work); INIT_WORK(&host->send_stop_work, mmc_omap_send_stop_work); INIT_WORK(&host->cmd_abort_work, mmc_omap_abort_command); setup_timer(&host->cmd_abort_timer, mmc_omap_cmd_timer, (unsigned long) host); spin_lock_init(&host->clk_lock); setup_timer(&host->clk_timer, mmc_omap_clk_timer, (unsigned long) host); spin_lock_init(&host->dma_lock); spin_lock_init(&host->slot_lock); init_waitqueue_head(&host->slot_wq); host->pdata = pdata; host->dev = &pdev->dev; platform_set_drvdata(pdev, host); host->id = pdev->id; host->mem_res = res; host->irq = irq; host->use_dma = 1; host->irq = irq; host->phys_base = host->mem_res->start; host->virt_base = ioremap(res->start, resource_size(res)); if (!host->virt_base) goto err_ioremap; host->iclk = clk_get(&pdev->dev, "ick"); if (IS_ERR(host->iclk)) { ret = PTR_ERR(host->iclk); goto err_free_mmc_host; } clk_enable(host->iclk); host->fclk = clk_get(&pdev->dev, "fck"); if (IS_ERR(host->fclk)) { ret = PTR_ERR(host->fclk); goto err_free_iclk; } dma_cap_zero(mask); dma_cap_set(DMA_SLAVE, mask); host->dma_tx_burst = -1; host->dma_rx_burst = -1; if (cpu_is_omap24xx()) sig = host->id == 0 ? OMAP24XX_DMA_MMC1_TX : OMAP24XX_DMA_MMC2_TX; else sig = host->id == 0 ? OMAP_DMA_MMC_TX : OMAP_DMA_MMC2_TX; host->dma_tx = dma_request_channel(mask, omap_dma_filter_fn, &sig); #if 0 if (!host->dma_tx) { dev_err(host->dev, "unable to obtain TX DMA engine channel %u\n", sig); goto err_dma; } #else if (!host->dma_tx) dev_warn(host->dev, "unable to obtain TX DMA engine channel %u\n", sig); #endif if (cpu_is_omap24xx()) sig = host->id == 0 ? OMAP24XX_DMA_MMC1_RX : OMAP24XX_DMA_MMC2_RX; else sig = host->id == 0 ? OMAP_DMA_MMC_RX : OMAP_DMA_MMC2_RX; host->dma_rx = dma_request_channel(mask, omap_dma_filter_fn, &sig); #if 0 if (!host->dma_rx) { dev_err(host->dev, "unable to obtain RX DMA engine channel %u\n", sig); goto err_dma; } #else if (!host->dma_rx) dev_warn(host->dev, "unable to obtain RX DMA engine channel %u\n", sig); #endif ret = request_irq(host->irq, mmc_omap_irq, 0, DRIVER_NAME, host); if (ret) goto err_free_dma; if (pdata->init != NULL) { ret = pdata->init(&pdev->dev); if (ret < 0) goto err_free_irq; } host->nr_slots = pdata->nr_slots; host->reg_shift = (cpu_is_omap7xx() ? 1 : 2); host->mmc_omap_wq = alloc_workqueue("mmc_omap", 0, 0); if (!host->mmc_omap_wq) goto err_plat_cleanup; for (i = 0; i < pdata->nr_slots; i++) { ret = mmc_omap_new_slot(host, i); if (ret < 0) { while (--i >= 0) mmc_omap_remove_slot(host->slots[i]); goto err_destroy_wq; } } return 0; err_destroy_wq: destroy_workqueue(host->mmc_omap_wq); err_plat_cleanup: if (pdata->cleanup) pdata->cleanup(&pdev->dev); err_free_irq: free_irq(host->irq, host); err_free_dma: if (host->dma_tx) dma_release_channel(host->dma_tx); if (host->dma_rx) dma_release_channel(host->dma_rx); clk_put(host->fclk); err_free_iclk: clk_disable(host->iclk); clk_put(host->iclk); err_free_mmc_host: iounmap(host->virt_base); err_ioremap: kfree(host); err_free_mem_region: release_mem_region(res->start, resource_size(res)); return ret; }