static int balong_sim_probe(struct platform_device *pdev) { struct balong_sim_plat_data *plat = NULL; int err; dev_dbg(&pdev->dev, "balong_sim_probe\n"); plat = pdev->dev.platform_data; if (!strcmp(SIM1 , plat->name)) { sim1_plat_data = pdev->dev.platform_data; if (!get_hw_config_int("sim/sim1_detection_gpio", &(sim1_plat_data->sim_detection_gpio), NULL)) { pr_err("Get sim/sim1_detection_gpio failed\n"); return -EINVAL; } /*if there are no sim gpio detection on hw platform, simX_detection_gpio should be 0xffffffff*/ if(NO_SIM_GPIO == sim1_plat_data->sim_detection_gpio) { pr_info("balong_sim_probe, this hw platform doesn't support sim1 gpio detection! \n"); set_sim_en_int(plat->name, 1); return 0; } if (!get_hw_config_int("sim/sim1_present_electrical_lvl", &(g_sim1_present_electrical_lvl), NULL)) { pr_err("Get sim/sim1_detection_gpio failed\n"); return -EINVAL; } pr_info("balong_sim_probe SIM1 dev name [%s], sim1_detection_gpio [%d], sim1_present_electrical_lvl [%d]\n", plat->name, sim1_plat_data->sim_detection_gpio, g_sim1_present_electrical_lvl); } if (!strcmp(SIM2 , plat->name)) { sim2_plat_data = pdev->dev.platform_data; if (!get_hw_config_int("sim/sim2_detection_gpio", &(sim2_plat_data->sim_detection_gpio), NULL)) { pr_err("Get sim/sim2_detection_gpio failed\n"); return -EINVAL; } /*if there are no sim gpio detection on hw platform, simX_detection_gpio should be 0xffffffff*/ if(NO_SIM_GPIO == sim2_plat_data->sim_detection_gpio) { pr_info("balong_sim_probe, this hw platform doesn't support sim2 gpio detection! \n"); set_sim_en_int(plat->name, 1); return 0; } if (!get_hw_config_int("sim/sim2_present_electrical_lvl", &(g_sim2_present_electrical_lvl), NULL)) { pr_err("Get sim/sim2_detection_gpio failed\n"); return -EINVAL; } pr_info("balong_sim_probe SIM2 dev name [%s], sim2_detection_gpio [%d], sim2_present_electrical_lvl [%d]\n", plat->name, sim2_plat_data->sim_detection_gpio, g_sim2_present_electrical_lvl); } err = gpio_request_one(plat->sim_detection_gpio, GPIOF_IN, plat->name); if (err) { dev_warn(&pdev->dev, "no sim-detect pin available!\n"); return err; } /*Initialize sim status when booting*/ if (!strcmp(SIM1 , plat->name)) { plat->sim_status = get_sim_status(plat->sim_detection_gpio, g_sim1_present_electrical_lvl); } if (!strcmp(SIM2 , plat->name)) { plat->sim_status = get_sim_status(plat->sim_detection_gpio, g_sim2_present_electrical_lvl); } pr_info("balong_sim_probe sim_status [%d]\n", plat->sim_status); /*Temp: set sim_en_int of register SIMCARD_EN*/ /*TODO:需要找到软件哪里设置了sim_en_int位*/ set_sim_en_int(plat->name, plat->sim_status); /*以下代码只执行一次,SIM1和SIM2共用一个任务队列*/ if (!workqueue) { /* Initialize works */ workqueue = create_singlethread_workqueue("balong_sim_workqueue"); if (!workqueue) { dev_err(&pdev->dev, "Create workqueue failed\n"); err = -1; goto err_init_workqueue; } else { pr_info("balong_sim_probe, Initialization of workqueue succeed\n"); } } /*request SIM irq*/ if (!strcmp(SIM1 , plat->name)) { INIT_WORK(&sim1_irq_work, balong_sim1_set_status); err = request_irq(gpio_to_irq(plat->sim_detection_gpio), sim1_detection_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, pdev->name, pdev); if (err) { dev_warn(&pdev->dev, "request gpio irq error\n"); goto no_sim_detect_irq; } #ifdef SIM_HPD pr_info(" SIM1 sim_hpd_out_f [%d]\n", plat->sim_hpd_out_f); pr_info(" SIM1 sim_hpd_in_f [%d]\n", plat->sim_hpd_in_f); /*SIM HPD out irq request*/ err = request_irq(plat->sim_hpd_out_f, sim1_hpd_out_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, pdev->name, pdev); if (err) { dev_warn(&pdev->dev, "request sim_hpd_out_f irq error\n"); goto no_sim_hpd_out_irq; } /*SIM HPD in irq request*/ err = request_irq(plat->sim_hpd_in_f, sim1_hpd_in_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, pdev->name, pdev); if (err) { dev_warn(&pdev->dev, "request sim_hpd_in_f irq error\n"); goto no_sim_hpd_in_irq; } #endif /* sysfs entries for IO control */ err = device_create_file(&(pdev->dev), &dev_attr_sim1_status); if (err) { dev_err(&pdev->dev, "Failed to create sysfs entry\n"); goto err_create_device_file; } } if (!strcmp(SIM2 , plat->name)) { INIT_WORK(&sim2_irq_work, balong_sim2_set_status); err = request_irq(gpio_to_irq(plat->sim_detection_gpio), sim2_detection_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, pdev->name, pdev); if (err) { dev_warn(&pdev->dev, "request gpio irq error\n"); goto no_sim_detect_irq; } #ifdef SIM_HPD pr_info(" SIM2 sim_hpd_out_f [%d]\n", plat->sim_hpd_out_f); pr_info(" SIM2 sim_hpd_in_f [%d]\n", plat->sim_hpd_in_f); /*SIM HPD out irq request*/ err = request_irq(plat->sim_hpd_out_f, sim2_hpd_out_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, pdev->name, pdev); if (err) { dev_warn(&pdev->dev, "request sim_hpd_out_f irq error\n"); goto no_sim_hpd_out_irq; } /*SIM HPD in irq request*/ err = request_irq(plat->sim_hpd_in_f, sim2_hpd_in_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, pdev->name, pdev); if (err) { dev_warn(&pdev->dev, "request sim_hpd_in_f irq error\n"); goto no_sim_hpd_in_irq; } #endif /* sysfs entries for IO control */ err = device_create_file(&(pdev->dev), &dev_attr_sim2_status); if (err) { dev_err(&pdev->dev, "Failed to create sysfs entry\n"); goto err_create_device_file; } } return 0; err_create_device_file: #ifdef SIM_HPD if (!strcmp(SIM1 , plat->name)) free_irq(plat->sim_hpd_in_f, sim1_hpd_in_irq_handler); if (!strcmp(SIM2 , plat->name)) free_irq(plat->sim_hpd_in_f, sim2_hpd_in_irq_handler); no_sim_hpd_in_irq: if (!strcmp(SIM1 , plat->name)) free_irq(plat->sim_hpd_out_f, sim1_hpd_out_irq_handler); if (!strcmp(SIM2 , plat->name)) free_irq(plat->sim_hpd_out_f, sim2_hpd_out_irq_handler); no_sim_hpd_out_irq: #endif if (!strcmp(SIM1 , plat->name)) free_irq(gpio_to_irq(plat->sim_detection_gpio), sim1_detection_irq_handler); if (!strcmp(SIM2 , plat->name)) free_irq(gpio_to_irq(plat->sim_detection_gpio), sim2_detection_irq_handler); no_sim_detect_irq: destroy_workqueue(workqueue); workqueue = NULL; err_init_workqueue: gpio_free(plat->sim_detection_gpio); return err; }
static int mdnie_probe(struct platform_device *pdev) { #if defined(CONFIG_FB_MDNIE_PWM) struct platform_mdnie_data *pdata = pdev->dev.platform_data; #endif struct mdnie_info *mdnie; int ret = 0; mdnie_class = class_create(THIS_MODULE, dev_name(&pdev->dev)); if (IS_ERR_OR_NULL(mdnie_class)) { pr_err("failed to create mdnie class\n"); ret = -EINVAL; goto error0; } mdnie_class->dev_attrs = mdnie_attributes; mdnie = kzalloc(sizeof(struct mdnie_info), GFP_KERNEL); if (!mdnie) { pr_err("failed to allocate mdnie\n"); ret = -ENOMEM; goto error1; } mdnie->dev = device_create(mdnie_class, &pdev->dev, 0, &mdnie, "mdnie"); if (IS_ERR_OR_NULL(mdnie->dev)) { pr_err("failed to create mdnie device\n"); ret = -EINVAL; goto error2; } #if defined(CONFIG_FB_MDNIE_PWM) if (!pdata) { pr_err("no platform data specified\n"); ret = -EINVAL; goto error3; } mdnie->bd = backlight_device_register("panel", mdnie->dev, mdnie, &mdnie_backlight_ops, NULL); mdnie->bd->props.max_brightness = MAX_BRIGHTNESS_LEVEL; mdnie->bd->props.brightness = DEFAULT_BRIGHTNESS; mdnie->bd_enable = TRUE; mdnie->lcd_pd = pdata->lcd_pd; ret = device_create_file(&mdnie->bd->dev, &dev_attr_auto_brightness); if (ret < 0) dev_err(&mdnie->bd->dev, "failed to add sysfs entries, %d\n", __LINE__); #endif mdnie->scenario = UI_MODE; mdnie->mode = STANDARD; mdnie->enable = TRUE; mdnie->tuning = FALSE; mdnie->accessibility = ACCESSIBILITY_OFF; mdnie->cabc = CABC_OFF; #if defined(CONFIG_FB_MDNIE_PWM) mdnie->power_lut_idx = LUT_LEVEL_MANUAL_AND_INDOOR; mdnie->auto_brightness = 0; #endif mutex_init(&mdnie->lock); mutex_init(&mdnie->dev_lock); platform_set_drvdata(pdev, mdnie); dev_set_drvdata(mdnie->dev, mdnie); #ifdef CONFIG_HAS_EARLYSUSPEND #if defined(CONFIG_FB_MDNIE_PWM) mdnie->early_suspend.suspend = mdnie_early_suspend; #endif mdnie->early_suspend.resume = mdnie_late_resume; mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; register_early_suspend(&mdnie->early_suspend); #endif #if defined(CONFIG_FB_MDNIE_PWM) dev_info(mdnie->dev, "lcdtype: %d\n", pdata->display_type); if (pdata->display_type >= ARRAY_SIZE(backlight_table)) pdata->display_type = 0; mdnie->backlight = &backlight_table[pdata->display_type]; #endif #if defined(CONFIG_FB_S5P_S6F1202A) if (pdata->display_type == 0) memcpy(tuning_table, tuning_table_hydis, sizeof(tuning_table)); else if (pdata->display_type == 1) memcpy(tuning_table, tuning_table_sec, sizeof(tuning_table)); else if (pdata->display_type == 2) memcpy(tuning_table, tuning_table_boe, sizeof(tuning_table)); #endif g_mdnie = mdnie; mdnie_update(mdnie); dev_info(mdnie->dev, "registered successfully\n"); #ifdef CONFIG_FB_S5P_MDNIE_CONTROL mdniemod_create_sysfs(); #endif return 0; #if defined(CONFIG_FB_MDNIE_PWM) error3: device_destroy(mdnie_class, mdnie->dev->devt); #endif error2: kfree(mdnie); error1: class_destroy(mdnie_class); error0: return ret; }
int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt) { int ret; skt->cs_state = dead_socket; setup_timer(&skt->poll_timer, soc_common_pcmcia_poll_event, (unsigned long)skt); skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD; ret = request_resource(&iomem_resource, &skt->res_skt); if (ret) goto out_err_1; ret = request_resource(&skt->res_skt, &skt->res_io); if (ret) goto out_err_2; ret = request_resource(&skt->res_skt, &skt->res_mem); if (ret) goto out_err_3; ret = request_resource(&skt->res_skt, &skt->res_attr); if (ret) goto out_err_4; skt->virt_io = ioremap(skt->res_io.start, 0x10000); if (skt->virt_io == NULL) { ret = -ENOMEM; goto out_err_5; } /* * We initialize default socket timing here, because * we are not guaranteed to see a SetIOMap operation at * runtime. */ skt->ops->set_timing(skt); ret = soc_pcmcia_hw_init(skt); if (ret) goto out_err_6; skt->socket.ops = &soc_common_pcmcia_operations; skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD; skt->socket.resource_ops = &pccard_static_ops; skt->socket.irq_mask = 0; skt->socket.map_size = PAGE_SIZE; skt->socket.io_offset = (unsigned long)skt->virt_io; skt->status = soc_common_pcmcia_skt_state(skt); #ifdef CONFIG_CPU_FREQ if (skt->ops->frequency_change) { skt->cpufreq_nb.notifier_call = soc_common_pcmcia_cpufreq_nb; ret = cpufreq_register_notifier(&skt->cpufreq_nb, CPUFREQ_TRANSITION_NOTIFIER); if (ret < 0) dev_err(skt->socket.dev.parent, "unable to register CPU frequency change notifier for PCMCIA (%d)\n", ret); } #endif ret = pcmcia_register_socket(&skt->socket); if (ret) goto out_err_7; ret = device_create_file(&skt->socket.dev, &dev_attr_status); if (ret) goto out_err_8; return ret; out_err_8: del_timer_sync(&skt->poll_timer); pcmcia_unregister_socket(&skt->socket); out_err_7: soc_pcmcia_hw_shutdown(skt); out_err_6: iounmap(skt->virt_io); out_err_5: release_resource(&skt->res_attr); out_err_4: release_resource(&skt->res_mem); out_err_3: release_resource(&skt->res_io); out_err_2: release_resource(&skt->res_skt); out_err_1: return ret; }
static int asus_oled_probe(struct usb_interface *interface, const struct usb_device_id *id) { struct usb_device *udev = interface_to_usbdev(interface); struct asus_oled_dev *odev = NULL; int retval = -ENOMEM; uint16_t dev_width = 0; enum oled_pack_mode pack_mode = PACK_MODE_LAST; const struct oled_dev_desc_str *dev_desc = oled_dev_desc_table; const char *desc = NULL; if (!id) { /* Even possible? Just to make sure...*/ dev_err(&interface->dev, "No usb_device_id provided!\n"); return -ENODEV; } for (; dev_desc->idVendor; dev_desc++) { if (dev_desc->idVendor == id->idVendor && dev_desc->idProduct == id->idProduct) { dev_width = dev_desc->devWidth; desc = dev_desc->devDesc; pack_mode = dev_desc->packMode; break; } } if (!desc || dev_width < 1 || pack_mode == PACK_MODE_LAST) { dev_err(&interface->dev, "Missing or incomplete device description!\n"); return -ENODEV; } odev = kzalloc(sizeof(struct asus_oled_dev), GFP_KERNEL); if (odev == NULL) { dev_err(&interface->dev, "Out of memory\n"); return -ENOMEM; } odev->udev = usb_get_dev(udev); odev->pic_mode = ASUS_OLED_STATIC; odev->dev_width = dev_width; odev->pack_mode = pack_mode; odev->height = 0; odev->width = 0; odev->x_shift = 0; odev->y_shift = 0; odev->buf_offs = 0; odev->buf_size = 0; odev->last_val = 0; odev->buf = NULL; odev->enabled = 1; odev->dev = NULL; usb_set_intfdata(interface, odev); retval = device_create_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(enabled)); if (retval) goto err_files; retval = device_create_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(picture)); if (retval) goto err_files; odev->dev = device_create(oled_class, &interface->dev, MKDEV(0, 0), NULL, "oled_%d", ++oled_num); if (IS_ERR(odev->dev)) { retval = PTR_ERR(odev->dev); goto err_files; } dev_set_drvdata(odev->dev, odev); retval = device_create_file(odev->dev, &dev_attr_enabled); if (retval) goto err_class_enabled; retval = device_create_file(odev->dev, &dev_attr_picture); if (retval) goto err_class_picture; dev_info(&interface->dev, "Attached Asus OLED device: %s [width %u, pack_mode %d]\n", desc, odev->dev_width, odev->pack_mode); if (start_off) enable_oled(odev, 0); return 0; err_class_picture: device_remove_file(odev->dev, &dev_attr_picture); err_class_enabled: device_remove_file(odev->dev, &dev_attr_enabled); device_unregister(odev->dev); err_files: device_remove_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(enabled)); device_remove_file(&interface->dev, &ASUS_OLED_DEVICE_ATTR(picture)); usb_set_intfdata(interface, NULL); usb_put_dev(odev->udev); kfree(odev); return retval; }
static void *mlx5_ib_add(struct mlx5_core_dev *mdev) { struct mlx5_ib_dev *dev; int err; int i; /* don't create IB instance over Eth ports, no RoCE yet! */ if (MLX5_CAP_GEN(mdev, port_type) == MLX5_CAP_PORT_TYPE_ETH) return NULL; printk_once(KERN_INFO "%s", mlx5_version); dev = (struct mlx5_ib_dev *)ib_alloc_device(sizeof(*dev)); if (!dev) return NULL; dev->mdev = mdev; err = get_port_caps(dev); if (err) goto err_dealloc; if (mlx5_use_mad_ifc(dev)) get_ext_port_caps(dev); MLX5_INIT_DOORBELL_LOCK(&dev->uar_lock); strlcpy(dev->ib_dev.name, "mlx5_%d", IB_DEVICE_NAME_MAX); dev->ib_dev.owner = THIS_MODULE; dev->ib_dev.node_type = RDMA_NODE_IB_CA; dev->ib_dev.local_dma_lkey = 0 /* not supported for now */; dev->num_ports = MLX5_CAP_GEN(mdev, num_ports); dev->ib_dev.phys_port_cnt = dev->num_ports; dev->ib_dev.num_comp_vectors = dev->mdev->priv.eq_table.num_comp_vectors; dev->ib_dev.dma_device = &mdev->pdev->dev; dev->ib_dev.uverbs_abi_ver = MLX5_IB_UVERBS_ABI_VERSION; dev->ib_dev.uverbs_cmd_mask = (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) | (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) | (1ull << IB_USER_VERBS_CMD_QUERY_PORT) | (1ull << IB_USER_VERBS_CMD_ALLOC_PD) | (1ull << IB_USER_VERBS_CMD_DEALLOC_PD) | (1ull << IB_USER_VERBS_CMD_REG_MR) | (1ull << IB_USER_VERBS_CMD_DEREG_MR) | (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) | (1ull << IB_USER_VERBS_CMD_CREATE_CQ) | (1ull << IB_USER_VERBS_CMD_RESIZE_CQ) | (1ull << IB_USER_VERBS_CMD_DESTROY_CQ) | (1ull << IB_USER_VERBS_CMD_CREATE_QP) | (1ull << IB_USER_VERBS_CMD_MODIFY_QP) | (1ull << IB_USER_VERBS_CMD_QUERY_QP) | (1ull << IB_USER_VERBS_CMD_DESTROY_QP) | (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) | (1ull << IB_USER_VERBS_CMD_DETACH_MCAST) | (1ull << IB_USER_VERBS_CMD_CREATE_SRQ) | (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ) | (1ull << IB_USER_VERBS_CMD_QUERY_SRQ) | (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ) | (1ull << IB_USER_VERBS_CMD_CREATE_XSRQ) | (1ull << IB_USER_VERBS_CMD_OPEN_QP); dev->ib_dev.uverbs_ex_cmd_mask = (1ull << IB_USER_VERBS_EX_CMD_QUERY_DEVICE); dev->ib_dev.query_device = mlx5_ib_query_device; dev->ib_dev.query_port = mlx5_ib_query_port; dev->ib_dev.query_gid = mlx5_ib_query_gid; dev->ib_dev.query_pkey = mlx5_ib_query_pkey; dev->ib_dev.modify_device = mlx5_ib_modify_device; dev->ib_dev.modify_port = mlx5_ib_modify_port; dev->ib_dev.alloc_ucontext = mlx5_ib_alloc_ucontext; dev->ib_dev.dealloc_ucontext = mlx5_ib_dealloc_ucontext; dev->ib_dev.mmap = mlx5_ib_mmap; dev->ib_dev.alloc_pd = mlx5_ib_alloc_pd; dev->ib_dev.dealloc_pd = mlx5_ib_dealloc_pd; dev->ib_dev.create_ah = mlx5_ib_create_ah; dev->ib_dev.query_ah = mlx5_ib_query_ah; dev->ib_dev.destroy_ah = mlx5_ib_destroy_ah; dev->ib_dev.create_srq = mlx5_ib_create_srq; dev->ib_dev.modify_srq = mlx5_ib_modify_srq; dev->ib_dev.query_srq = mlx5_ib_query_srq; dev->ib_dev.destroy_srq = mlx5_ib_destroy_srq; dev->ib_dev.post_srq_recv = mlx5_ib_post_srq_recv; dev->ib_dev.create_qp = mlx5_ib_create_qp; dev->ib_dev.modify_qp = mlx5_ib_modify_qp; dev->ib_dev.query_qp = mlx5_ib_query_qp; dev->ib_dev.destroy_qp = mlx5_ib_destroy_qp; dev->ib_dev.post_send = mlx5_ib_post_send; dev->ib_dev.post_recv = mlx5_ib_post_recv; dev->ib_dev.create_cq = mlx5_ib_create_cq; dev->ib_dev.modify_cq = mlx5_ib_modify_cq; dev->ib_dev.resize_cq = mlx5_ib_resize_cq; dev->ib_dev.destroy_cq = mlx5_ib_destroy_cq; dev->ib_dev.poll_cq = mlx5_ib_poll_cq; dev->ib_dev.req_notify_cq = mlx5_ib_arm_cq; dev->ib_dev.get_dma_mr = mlx5_ib_get_dma_mr; dev->ib_dev.reg_user_mr = mlx5_ib_reg_user_mr; dev->ib_dev.dereg_mr = mlx5_ib_dereg_mr; dev->ib_dev.attach_mcast = mlx5_ib_mcg_attach; dev->ib_dev.detach_mcast = mlx5_ib_mcg_detach; dev->ib_dev.process_mad = mlx5_ib_process_mad; dev->ib_dev.alloc_mr = mlx5_ib_alloc_mr; dev->ib_dev.map_mr_sg = mlx5_ib_map_mr_sg; dev->ib_dev.check_mr_status = mlx5_ib_check_mr_status; dev->ib_dev.get_port_immutable = mlx5_port_immutable; mlx5_ib_internal_fill_odp_caps(dev); if (MLX5_CAP_GEN(mdev, xrc)) { dev->ib_dev.alloc_xrcd = mlx5_ib_alloc_xrcd; dev->ib_dev.dealloc_xrcd = mlx5_ib_dealloc_xrcd; dev->ib_dev.uverbs_cmd_mask |= (1ull << IB_USER_VERBS_CMD_OPEN_XRCD) | (1ull << IB_USER_VERBS_CMD_CLOSE_XRCD); } err = init_node_data(dev); if (err) goto err_dealloc; mutex_init(&dev->cap_mask_mutex); err = create_dev_resources(&dev->devr); if (err) goto err_dealloc; err = mlx5_ib_odp_init_one(dev); if (err) goto err_rsrc; err = ib_register_device(&dev->ib_dev, NULL); if (err) goto err_odp; err = create_umr_res(dev); if (err) goto err_dev; for (i = 0; i < ARRAY_SIZE(mlx5_class_attributes); i++) { err = device_create_file(&dev->ib_dev.dev, mlx5_class_attributes[i]); if (err) goto err_umrc; } dev->ib_active = true; return dev; err_umrc: destroy_umrc_res(dev); err_dev: ib_unregister_device(&dev->ib_dev); err_odp: mlx5_ib_odp_remove_one(dev); err_rsrc: destroy_dev_resources(&dev->devr); err_dealloc: ib_dealloc_device((struct ib_device *)dev); return NULL; }
static int gpio_event_probe(struct platform_device *pdev) { int err; struct gpio_event *ip; struct gpio_event_platform_data *event_info; int dev_count = 1; int i; int registered = 0; event_info = pdev->dev.platform_data; if (event_info == NULL) { pr_err("gpio_event_probe: No pdata\n"); return -ENODEV; } if ((!event_info->name && !event_info->names[0]) || !event_info->info || !event_info->info_count) { pr_err("gpio_event_probe: Incomplete pdata\n"); return -ENODEV; } if (!event_info->name) while (event_info->names[dev_count]) dev_count++; ip = kzalloc(sizeof(*ip) + sizeof(ip->state[0]) * event_info->info_count + sizeof(*ip->input_devs) + sizeof(ip->input_devs->dev[0]) * dev_count, GFP_KERNEL); if (ip == NULL) { err = -ENOMEM; pr_err("gpio_event_probe: Failed to allocate private data\n"); goto err_kp_alloc_failed; } ip->input_devs = (void*)&ip->state[event_info->info_count]; platform_set_drvdata(pdev, ip); for (i = 0; i < dev_count; i++) { struct input_dev *input_dev = input_allocate_device(); if (input_dev == NULL) { err = -ENOMEM; pr_err("gpio_event_probe: " "Failed to allocate input device\n"); goto err_input_dev_alloc_failed; } input_set_drvdata(input_dev, ip); input_dev->name = event_info->name ? event_info->name : event_info->names[i]; input_dev->event = gpio_input_event; ip->input_devs->dev[i] = input_dev; } ip->input_devs->count = dev_count; ip->info = event_info; if (event_info->power) { #ifdef CONFIG_HAS_EARLYSUSPEND ip->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; ip->early_suspend.suspend = gpio_event_suspend; ip->early_suspend.resume = gpio_event_resume; register_early_suspend(&ip->early_suspend); #endif ip->info->power(ip->info, 1); } err = gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_INIT); if (err) goto err_call_all_func_failed; for (i = 0; i < dev_count; i++) { err = input_register_device(ip->input_devs->dev[i]); if (err) { pr_err("gpio_event_probe: Unable to register %s " "input device\n", ip->input_devs->dev[i]->name); goto err_input_register_device_failed; } registered++; } #if defined(CONFIG_MACH_KYLE) || defined(CONFIG_MACH_AMAZING) err = device_create_file(&(pdev->dev), &dev_attr_wakeup_keys); #endif return 0; err_input_register_device_failed: gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT); err_call_all_func_failed: if (event_info->power) { #ifdef CONFIG_HAS_EARLYSUSPEND unregister_early_suspend(&ip->early_suspend); #endif ip->info->power(ip->info, 0); } for (i = 0; i < registered; i++) input_unregister_device(ip->input_devs->dev[i]); for (i = dev_count - 1; i >= registered; i--) { input_free_device(ip->input_devs->dev[i]); err_input_dev_alloc_failed: ; } kfree(ip); err_kp_alloc_failed: return err; }
static int __devinit lp8556_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lp8556_platform_data *pdata; struct lp8556_data *led_data; int error; pr_info("%s\n", __func__); if (client->dev.of_node) pdata = lp8556_of_init(client); else pdata = client->dev.platform_data; if (pdata == NULL) { pr_err("%s: platform data required\n", __func__); return -ENODEV; } else if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: I2C_FUNC_I2C not supported\n", __func__); return -ENODEV; } led_data = kzalloc(sizeof(struct lp8556_data), GFP_KERNEL); if (led_data == NULL) { error = -ENOMEM; goto err_alloc_data_failed; } led_data->client = client; led_data->led_dev.name = LCD_BACKLIGHT; led_data->led_dev.brightness_set = lp8556_brightness_set; led_data->pdata = pdata; i2c_set_clientdata(client, led_data); INIT_WORK(&led_data->work, lp8556_brightness_work); led_data->regulator = regulator_get(&client->dev, LP8556_REGULATOR_NAME); if (IS_ERR(led_data->regulator)) pr_err("%s: regulator_get(\"%s\"): -1\n", __func__, LP8556_REGULATOR_NAME); else { error = regulator_set_voltage(led_data->regulator, LP8556_VDD_MIN_VOLTAGE, LP8556_VDD_MAX_VOLTAGE); if (error != 0) pr_err("%s: regulator_set_voltage(%d:%d):%d\n", __func__, LP8556_VDD_MIN_VOLTAGE, LP8556_VDD_MAX_VOLTAGE, error); error = regulator_enable(led_data->regulator); if (error != 0) pr_err("%s: regulator_enable(\"%s\"):%d\n", __func__, LP8556_REGULATOR_NAME, error); } error = lp8556_gpio_init(pdata); if (error) { pr_err("%s: gpio_init failure\n", __func__); goto err_gpio_init; } error = gpio_export_link(&led_data->client->dev, "reset", led_data->pdata->enable_gpio); if (error < 0) { pr_err("%s: failed to export link %s for gpio %d, err = %d\n", __func__, "reset", led_data->pdata->enable_gpio, error); goto err_gpio_export_link; } lp8556_enable(led_data, true); error = lp8556_init_registers(led_data); if (error < 0) { pr_err("%s: Register Initialization failed: %d\n", __func__, error); error = -ENODEV; goto err_reg_init_failed; } atomic_set(&led_data->enabled, 1); error = led_classdev_register((struct device *) &client->dev, &led_data->led_dev); if (error < 0) { pr_err("%s: Register led class failed: %d\n", __func__, error); error = -ENODEV; goto err_classdev_failed; } led_data->bl_dev = backlight_device_register(LCD_BACKLIGHT, &client->dev, led_data, &lp8556_bl_ops, NULL); if (IS_ERR(led_data->bl_dev)) { error = PTR_ERR(led_data->bl_dev); pr_err("%s: backlight_device_register: %d\n", __func__, error); goto err_bl_device_register; } led_data->bl_dev->props.max_brightness = LP8556_MAX_BRIGHTNESS; led_data->led_dev.brightness = led_data->pdata->power_up_brightness; led_data->bl_dev->props.brightness = led_data->led_dev.brightness; #ifdef CONFIG_HAS_EARLYSUSPEND led_data->early_suspender.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; led_data->early_suspender.suspend = lp8556_early_suspend; led_data->early_suspender.resume = lp8556_late_resume, register_early_suspend(&led_data->early_suspender); #endif #ifdef DEBUG error = device_create_file(led_data->led_dev.dev, &dev_attr_registers); if (error < 0) pr_err("%s: File device creation failed: %d\n", __func__, error); #endif pr_debug("Backlight driver initialized\n"); return 0; err_bl_device_register: led_classdev_unregister(&led_data->led_dev); err_classdev_failed: err_reg_init_failed: lp8556_enable(led_data, false); err_gpio_export_link: gpio_free(led_data->pdata->enable_gpio); err_gpio_init: if (!IS_ERR(led_data->regulator)) { regulator_disable(led_data->regulator); regulator_put(led_data->regulator); } kfree(led_data); i2c_set_clientdata(client, NULL); err_alloc_data_failed: return error; }
static int s3cfb_probe(struct platform_device *pdev) { struct s3c_platform_fb *pdata; struct resource *res; int ret = 0; /* initialzing global structure */ ctrl = kzalloc(sizeof(struct s3cfb_global), GFP_KERNEL); if (!ctrl) { dev_err(ctrl->dev, "failed to allocate for global fb structure\n"); goto err_global; } ctrl->dev = &pdev->dev; s3cfb_set_lcd_info(ctrl); /* gpio */ pdata = to_fb_plat(&pdev->dev); if (pdata->cfg_gpio) pdata->cfg_gpio(pdev); /* clock */ ctrl->clock = clk_get(&pdev->dev, pdata->clk_name); if (IS_ERR(ctrl->clock)) { dev_err(ctrl->dev, "failed to get fimd clock source\n"); ret = -EINVAL; goto err_clk; } clk_enable(ctrl->clock); /* io memory */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(ctrl->dev, "failed to get io memory region\n"); ret = -EINVAL; goto err_io; } /* request mem region */ res = request_mem_region(res->start, res->end - res->start + 1, pdev->name); if (!res) { dev_err(ctrl->dev, "failed to request io memory region\n"); ret = -EINVAL; goto err_io; } /* ioremap for register block */ ctrl->regs = ioremap(res->start, res->end - res->start + 1); if (!ctrl->regs) { dev_err(ctrl->dev, "failed to remap io region\n"); ret = -EINVAL; goto err_io; } /* irq */ ctrl->irq = platform_get_irq(pdev, 0); if (request_irq(ctrl->irq, s3cfb_irq_frame, IRQF_DISABLED, pdev->name, ctrl)) { dev_err(ctrl->dev, "request_irq failed\n"); ret = -EINVAL; goto err_irq; } #ifdef CONFIG_FB_S3C_V2_TRACE_UNDERRUN if (request_irq(platform_get_irq(pdev, 1), s3cfb_irq_fifo, IRQF_DISABLED, pdev->name, ctrl)) { dev_err(ctrl->dev, "request_irq failed\n"); ret = -EINVAL; goto err_irq; } s3cfb_set_fifo_interrupt(ctrl, 1); dev_info(ctrl->dev, "fifo underrun trace\n"); #endif /* init global */ s3cfb_init_global(); s3cfb_display_on(ctrl); /* panel control */ if (pdata->backlight_on) pdata->backlight_on(pdev); if (pdata->lcd_on) pdata->lcd_on(pdev); if (ctrl->lcd->init_ldi) ctrl->lcd->init_ldi(); /* prepare memory */ if (s3cfb_alloc_framebuffer()) goto err_alloc; if (s3cfb_register_framebuffer()) goto err_alloc; s3cfb_set_clock(ctrl); s3cfb_enable_window(pdata->default_win); ret = device_create_file(&(pdev->dev), &dev_attr_win_power); if (ret < 0) dev_err(ctrl->dev, "failed to add sysfs entries\n"); dev_info(ctrl->dev, "registered successfully\n"); return 0; err_alloc: free_irq(ctrl->irq, ctrl); err_irq: iounmap(ctrl->regs); err_io: clk_disable(ctrl->clock); err_clk: clk_put(ctrl->clock); err_global: return ret; }
static int ehci_rkhsic_probe(struct platform_device *pdev) { struct usb_hcd *hcd; struct ehci_hcd *ehci; struct resource *res; struct device *dev = &pdev->dev; struct rkehci_platform_data *pldata; int ret; int retval = 0; static u64 usb_dmamask = 0xffffffffUL; struct device_node *node = pdev->dev.of_node; struct rkehci_pdata_id *p; const struct of_device_id *match = of_match_device(of_match_ptr(rk_hsic_of_match), &pdev->dev); dev_dbg(&pdev->dev, "ehci_rkhsic proble\n"); if (match) { p = (struct rkehci_pdata_id *)match->data; } else { dev_err(dev, "ehci_rkhsic match failed\n"); return -EINVAL; } dev->platform_data = p->pdata; pldata = dev->platform_data; pldata->dev = dev; if (!node) { dev_err(dev, "device node not found\n"); return -EINVAL; } dev->dma_mask = &usb_dmamask; retval = device_create_file(dev, &dev_attr_ehci_rkhsic_power); retval = device_create_file(dev, &dev_attr_hsic_debug_ehci); hcd = usb_create_hcd(&rk_hsic_driver, &pdev->dev, dev_name(&pdev->dev)); if (!hcd) { dev_err(&pdev->dev, "Unable to create HCD\n"); return -ENOMEM; } if (pldata->hw_init) pldata->hw_init(); if (pldata->clock_init) { pldata->clock_init(pldata); pldata->clock_enable(pldata, 1); } if (pldata->soft_reset) pldata->soft_reset(pldata, RST_POR);; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "Unable to get memory resource\n"); ret = -ENODEV; goto put_hcd; } hcd->rsrc_start = res->start; hcd->rsrc_len = resource_size(res); hcd->regs = devm_ioremap_resource(dev, res); if (!hcd->regs) { dev_err(&pdev->dev, "ioremap failed\n"); ret = -ENOMEM; goto put_hcd; } hcd->irq = platform_get_irq(pdev, 0); if (hcd->irq < 0) { dev_err(&pdev->dev, "Unable to get IRQ resource\n"); ret = hcd->irq; goto put_hcd; } ehci = hcd_to_ehci(hcd); ehci->caps = hcd->regs; ehci->regs = hcd->regs + 0x10; printk("%s %p %p\n", __func__, ehci->caps, ehci->regs); dbg_hcs_params(ehci, "reset"); dbg_hcc_params(ehci, "reset"); ehci->hcs_params = readl(&ehci->caps->hcs_params); ret = usb_add_hcd(hcd, hcd->irq, IRQF_DISABLED | IRQF_SHARED); if (ret) { dev_err(&pdev->dev, "Failed to add USB HCD\n"); goto put_hcd; } g_hsic_ehci = ehci; ehci_rkhsic_port_power(ehci, 1); writel_relaxed(1, hcd->regs + 0xb0); writel_relaxed(0x1d4d, hcd->regs + 0x90); writel_relaxed(0x4, hcd->regs + 0xa0); dsb(); printk("%s ok\n", __func__); return 0; put_hcd: if (pldata->clock_enable) pldata->clock_enable(pldata, 0); usb_put_hcd(hcd); return ret; }
static inline int create_ehci_sys_file(struct ehci_hcd *ehci) { return device_create_file(ehci_to_hcd(ehci)->self.controller, &dev_attr_ehci_power); }
static int s5p_fimd_lite_probe(struct s5p_fimd_ext_device *fx_dev) { struct clk *sclk = NULL; struct resource *res; struct s5p_fimd_lite *fimd_lite; int ret = -1; #ifdef CONFIG_SLP_DISP_DEBUG int i; #endif fimd_lite = kzalloc(sizeof(struct s5p_fimd_lite), GFP_KERNEL); if (!fimd_lite) { dev_err(&fx_dev->dev, "failed to alloc fimd_lite object.\n"); return -EFAULT; } fimd_lite->dev = &fx_dev->dev; fimd_lite->lcd = (struct exynos_drm_fimd_pdata *) to_fimd_lite_platform_data(fx_dev); res = s5p_fimd_ext_get_resource(fx_dev, IORESOURCE_MEM, 0); if (!res) { dev_err(&fx_dev->dev, "failed to get io memory region.\n"); ret = -EINVAL; goto err0; } fimd_lite->iomem_base = ioremap(res->start, resource_size(res)); if (!fimd_lite->iomem_base) { dev_err(&fx_dev->dev, "failed to remap io region\n"); ret = -EFAULT; goto err0; } fimd_lite->clk = clk_get(&fx_dev->dev, "mdnie0"); if (IS_ERR(fimd_lite->clk)) { dev_err(&fx_dev->dev, "failed to get FIMD LITE clock source\n"); ret = -EINVAL; goto err1; } sclk = clk_get(&fx_dev->dev, "sclk_mdnie"); if (IS_ERR(sclk)) { dev_err(&fx_dev->dev, "failed to get sclk_mdnie clock\n"); ret = -EINVAL; goto err2; } fimd_lite->clk->parent = sclk; fimd_lite->irq = s5p_fimd_ext_get_irq(fx_dev, 0); /* register interrupt handler for fimd-lite. */ if (request_irq(fimd_lite->irq, s5p_fimd_lite_irq_frame, IRQF_DISABLED, fx_dev->name, (void *)fimd_lite)) { dev_err(&fx_dev->dev, "request_irq failed\n"); ret = -EINVAL; goto err3; } #ifdef CONFIG_SLP_DISP_DEBUG for (i = 0; i < ARRAY_SIZE(device_attrs); i++) { ret = device_create_file(&(fx_dev->dev), &device_attrs[i]); if (ret) break; } if (ret < 0) dev_err(&fx_dev->dev, "failed to add sysfs entries\n"); #endif fimd_ext_set_drvdata(fx_dev, fimd_lite); dev_info(&fx_dev->dev, "fimd lite driver has been probed.\n"); return 0; err3: free_irq(fimd_lite->irq, fx_dev); err2: clk_put(sclk); err1: iounmap(fimd_lite->iomem_base); clk_put(fimd_lite->clk); err0: kfree(fimd_lite); return ret; }
static int __devinit msm_vidc_probe(struct platform_device *pdev) { int rc = 0; struct msm_vidc_core *core; struct device *dev; int nr = BASE_DEVICE_NUMBER; core = kzalloc(sizeof(*core), GFP_KERNEL); if (!core || !vidc_driver) { dprintk(VIDC_ERR, "Failed to allocate memory for device core\n"); rc = -ENOMEM; goto err_no_mem; } rc = msm_vidc_initialize_core(pdev, core); if (rc) { dprintk(VIDC_ERR, "Failed to init core\n"); goto err_core_init; } rc = device_create_file(&pdev->dev, &dev_attr_pwr_collapse_delay); if (rc) { dprintk(VIDC_ERR, "Failed to create pwr_collapse_delay sysfs node"); goto err_core_init; } if (core->hfi_type == VIDC_HFI_Q6) { dprintk(VIDC_ERR, "Q6 hfi device probe called\n"); nr += MSM_VIDC_MAX_DEVICES; core->id = MSM_VIDC_CORE_Q6; } else { core->id = MSM_VIDC_CORE_VENUS; } rc = v4l2_device_register(&pdev->dev, &core->v4l2_dev); if (rc) { dprintk(VIDC_ERR, "Failed to register v4l2 device\n"); goto err_v4l2_register; } core->vdev[MSM_VIDC_DECODER].vdev.release = msm_vidc_release_video_device; core->vdev[MSM_VIDC_DECODER].vdev.fops = &msm_v4l2_vidc_fops; core->vdev[MSM_VIDC_DECODER].vdev.ioctl_ops = &msm_v4l2_ioctl_ops; core->vdev[MSM_VIDC_DECODER].type = MSM_VIDC_DECODER; rc = video_register_device(&core->vdev[MSM_VIDC_DECODER].vdev, VFL_TYPE_GRABBER, nr); if (rc) { dprintk(VIDC_ERR, "Failed to register video decoder device"); goto err_dec_register; } video_set_drvdata(&core->vdev[MSM_VIDC_DECODER].vdev, core); dev = &core->vdev[MSM_VIDC_DECODER].vdev.dev; rc = device_create_file(dev, &dev_attr_link_name); if (rc) { dprintk(VIDC_ERR, "Failed to create link name sysfs for decoder"); goto err_dec_attr_link_name; } core->vdev[MSM_VIDC_ENCODER].vdev.release = msm_vidc_release_video_device; core->vdev[MSM_VIDC_ENCODER].vdev.fops = &msm_v4l2_vidc_fops; core->vdev[MSM_VIDC_ENCODER].vdev.ioctl_ops = &msm_v4l2_ioctl_ops; core->vdev[MSM_VIDC_ENCODER].type = MSM_VIDC_ENCODER; rc = video_register_device(&core->vdev[MSM_VIDC_ENCODER].vdev, VFL_TYPE_GRABBER, nr + 1); if (rc) { dprintk(VIDC_ERR, "Failed to register video encoder device"); goto err_enc_register; } video_set_drvdata(&core->vdev[MSM_VIDC_ENCODER].vdev, core); dev = &core->vdev[MSM_VIDC_ENCODER].vdev.dev; rc = device_create_file(dev, &dev_attr_link_name); if (rc) { dprintk(VIDC_ERR, "Failed to create link name sysfs for encoder"); goto err_enc_attr_link_name; } mutex_lock(&vidc_driver->lock); if (vidc_driver->num_cores + 1 > MSM_VIDC_CORES_MAX) { mutex_unlock(&vidc_driver->lock); dprintk(VIDC_ERR, "Maximum cores already exist, core_no = %d\n", vidc_driver->num_cores); goto err_cores_exceeded; } vidc_driver->num_cores++; mutex_unlock(&vidc_driver->lock); core->device = vidc_hfi_initialize(core->hfi_type, core->id, &core->resources, &handle_cmd_response); if (IS_ERR_OR_NULL(core->device)) { mutex_lock(&vidc_driver->lock); vidc_driver->num_cores--; mutex_unlock(&vidc_driver->lock); rc = PTR_ERR(core->device); if (rc != -EPROBE_DEFER) dprintk(VIDC_ERR, "Failed to create HFI device\n"); else dprintk(VIDC_DBG, "msm_vidc: request probe defer\n"); goto err_cores_exceeded; } mutex_lock(&vidc_driver->lock); list_add_tail(&core->list, &vidc_driver->cores); mutex_unlock(&vidc_driver->lock); core->debugfs_root = msm_vidc_debugfs_init_core( core, vidc_driver->debugfs_root); pdev->dev.platform_data = core; return rc; err_cores_exceeded: device_remove_file(&core->vdev[MSM_VIDC_ENCODER].vdev.dev, &dev_attr_link_name); err_enc_attr_link_name: video_unregister_device(&core->vdev[MSM_VIDC_ENCODER].vdev); err_enc_register: device_remove_file(&core->vdev[MSM_VIDC_DECODER].vdev.dev, &dev_attr_link_name); err_dec_attr_link_name: video_unregister_device(&core->vdev[MSM_VIDC_DECODER].vdev); err_dec_register: v4l2_device_unregister(&core->v4l2_dev); err_v4l2_register: device_remove_file(&pdev->dev, &dev_attr_pwr_collapse_delay); err_core_init: kfree(core); err_no_mem: return rc; }
static int __init irled_init(void) { int ret; struct device *irled_dev; ir_data.cpu_frequency = CLOCK_VALUE; ir_data.on_offset = ON_OFFSET_VALUE; ir_data.off_offset = OFF_OFFSET_VALUE; INIT_WORK(&ir_data.work, irled_work); irled_dev = device_create(sec_class, NULL, 0, &ir_data, "sec_ir"); if (unlikely(IS_ERR(irled_dev))) { pr_err("irled: failed create irled device\n"); goto err_create_dev; } ret = device_create_file(irled_dev, &dev_attr_ir_send); if (unlikely(ret < 0)) { pr_err("irled: failed create device file\n"); goto err_create_dev_file1; } ret = device_create_file(irled_dev, &dev_attr_check_ir); if (unlikely(ret < 0)) { pr_err("irled: failed create device file\n"); goto err_create_dev_file2; } ret = device_create_file(irled_dev, &dev_attr_clock); if (unlikely(ret < 0)) { pr_err("irled: failed create device file\n"); goto err_create_dev_file3; } ret = device_create_file(irled_dev, &dev_attr_on_offset); if (unlikely(ret < 0)) { pr_err("irled: failed create device file\n"); goto err_create_dev_file4; } ret = device_create_file(irled_dev, &dev_attr_off_offset); if (unlikely(ret < 0)) { pr_err("irled: failed create device file\n"); goto err_create_dev_file5; } return 0; err_create_dev_file5: device_remove_file(irled_dev, &dev_attr_on_offset); err_create_dev_file4: device_remove_file(irled_dev, &dev_attr_clock); err_create_dev_file3: device_remove_file(irled_dev, &dev_attr_check_ir); err_create_dev_file2: device_remove_file(irled_dev, &dev_attr_ir_send); err_create_dev_file1: device_destroy(sec_class, irled_dev->devt); err_create_dev: return -1; }
static int pn544_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct pn544_i2c_platform_data *platform_data; struct pn544_dev *pn544_dev; pr_debug("%s : Probing pn544 driver\n", __func__); if (client->dev.of_node) platform_data = pn544_of_init(client); else platform_data = client->dev.platform_data; if (!platform_data) { pr_err("%s : GPIO has value 0, nfc probe fail.\n", __func__); goto err_exit; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : i2c_check_functionality I2C_FUNC_I2C failed.\n", __func__); goto err_exit; } pn544_dev = kzalloc(sizeof(*pn544_dev), GFP_KERNEL); if (pn544_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } ret = pn544_gpio_init(platform_data); if (ret) { dev_err(&client->dev, "gpio init failed\n"); goto err_gpio_init; } pn544_dev->irq_gpio = platform_data->irq_gpio; pn544_dev->ven_gpio = platform_data->ven_gpio; pn544_dev->firmware_gpio = platform_data->firmware_gpio; pn544_dev->ven_polarity = platform_data->ven_polarity; pn544_dev->discharge_delay = platform_data->discharge_delay; pn544_dev->client = client; wake_lock_init(&pn544_dev->wakelock, WAKE_LOCK_SUSPEND, "pn544c3"); /* init mutex and queues */ init_waitqueue_head(&pn544_dev->read_wq); mutex_init(&pn544_dev->read_mutex); mutex_init(&pn544_dev->ioctl_mutex); spin_lock_init(&pn544_dev->irq_enabled_lock); pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR; pn544_dev->pn544_device.name = "pn544"; pn544_dev->pn544_device.fops = &pn544_dev_fops; ret = misc_register(&pn544_dev->pn544_device); if (ret) { pr_err("%s : misc_register failed.\n", __FILE__); goto err_misc_register; } pr_debug("%s : PN544 Misc Minor: %d\n", __func__, pn544_dev->pn544_device.minor); /* Get the device structure */ pn544_dev->pn544_control_device = pn544_dev->pn544_device.this_device; /* Create sysfs device for PN544 control functionality */ ret = device_create_file(pn544_dev->pn544_control_device, &dev_attr_pn544_control_dev); if (ret) { pr_err("%s : device_create_file failed\n", __FILE__); goto err_device_create_file_failed; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_debug("%s : requesting IRQ %d\n", __func__, client->irq); pn544_dev->irq_enabled = true; ret = request_irq(client->irq, pn544_dev_irq_handler, IRQF_TRIGGER_HIGH, client->name, pn544_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } if (unlikely(irq_set_irq_wake(client->irq, 1))) pr_err("%s : unable to make irq %d wakeup\n", __func__, client->irq); pn544_disable_irq(pn544_dev); pn544_dev->reboot_notify.notifier_call = nfc_blk_reboot_notify; register_reboot_notifier(&pn544_dev->reboot_notify); i2c_set_clientdata(client, pn544_dev); return 0; err_request_irq_failed: device_remove_file(pn544_dev->pn544_control_device, &dev_attr_pn544_control_dev); err_device_create_file_failed: misc_deregister(&pn544_dev->pn544_device); err_misc_register: mutex_destroy(&pn544_dev->ioctl_mutex); mutex_destroy(&pn544_dev->read_mutex); pn544_gpio_free(pn544_dev); wake_unlock(&pn544_dev->wakelock); wake_lock_destroy(&pn544_dev->wakelock); err_gpio_init: kfree(pn544_dev); err_exit: return ret; }
/* * try to add a new ccwgroup device for one driver * argc and argv[] are a list of bus_id's of devices * belonging to the driver. */ int ccwgroup_create(struct device *root, unsigned int creator_id, struct ccw_driver *cdrv, int argc, char *argv[]) { struct ccwgroup_device *gdev; int i; int rc; if (argc > 256) /* disallow dumb users */ return -EINVAL; gdev = kzalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL); if (!gdev) return -ENOMEM; atomic_set(&gdev->onoff, 0); for (i = 0; i < argc; i++) { gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]); /* all devices have to be of the same type in * order to be grouped */ if (!gdev->cdev[i] || gdev->cdev[i]->id.driver_info != gdev->cdev[0]->id.driver_info) { rc = -EINVAL; goto free_dev; } /* Don't allow a device to belong to more than one group. */ if (gdev->cdev[i]->dev.driver_data) { rc = -EINVAL; goto free_dev; } gdev->cdev[i]->dev.driver_data = gdev; } gdev->creator_id = creator_id; gdev->count = argc; gdev->dev.bus = &ccwgroup_bus_type; gdev->dev.parent = root; gdev->dev.release = ccwgroup_release; snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s", gdev->cdev[0]->dev.bus_id); rc = device_register(&gdev->dev); if (rc) goto free_dev; get_device(&gdev->dev); rc = device_create_file(&gdev->dev, &dev_attr_ungroup); if (rc) { device_unregister(&gdev->dev); goto error; } rc = __ccwgroup_create_symlinks(gdev); if (!rc) { put_device(&gdev->dev); return 0; } device_remove_file(&gdev->dev, &dev_attr_ungroup); device_unregister(&gdev->dev); error: for (i = 0; i < argc; i++) if (gdev->cdev[i]) { put_device(&gdev->cdev[i]->dev); gdev->cdev[i]->dev.driver_data = NULL; } put_device(&gdev->dev); return rc; free_dev: for (i = 0; i < argc; i++) if (gdev->cdev[i]) { if (gdev->cdev[i]->dev.driver_data == gdev) gdev->cdev[i]->dev.driver_data = NULL; put_device(&gdev->cdev[i]->dev); } kfree(gdev); return rc; }
/** * Create the device files */ void dwc_otg_attr_create (struct lm_device *lmdev) { int error; error = device_create_file(&lmdev->dev, &dev_attr_regoffset); error = device_create_file(&lmdev->dev, &dev_attr_regvalue); error = device_create_file(&lmdev->dev, &dev_attr_mode); error = device_create_file(&lmdev->dev, &dev_attr_hnpcapable); error = device_create_file(&lmdev->dev, &dev_attr_srpcapable); error = device_create_file(&lmdev->dev, &dev_attr_hnp); error = device_create_file(&lmdev->dev, &dev_attr_srp); error = device_create_file(&lmdev->dev, &dev_attr_buspower); error = device_create_file(&lmdev->dev, &dev_attr_bussuspend); error = device_create_file(&lmdev->dev, &dev_attr_busconnected); error = device_create_file(&lmdev->dev, &dev_attr_gotgctl); error = device_create_file(&lmdev->dev, &dev_attr_gusbcfg); error = device_create_file(&lmdev->dev, &dev_attr_grxfsiz); error = device_create_file(&lmdev->dev, &dev_attr_gnptxfsiz); error = device_create_file(&lmdev->dev, &dev_attr_gpvndctl); error = device_create_file(&lmdev->dev, &dev_attr_ggpio); error = device_create_file(&lmdev->dev, &dev_attr_guid); error = device_create_file(&lmdev->dev, &dev_attr_gsnpsid); error = device_create_file(&lmdev->dev, &dev_attr_devspeed); error = device_create_file(&lmdev->dev, &dev_attr_enumspeed); error = device_create_file(&lmdev->dev, &dev_attr_hptxfsiz); error = device_create_file(&lmdev->dev, &dev_attr_hprt0); error = device_create_file(&lmdev->dev, &dev_attr_remote_wakeup); error = device_create_file(&lmdev->dev, &dev_attr_regdump); error = device_create_file(&lmdev->dev, &dev_attr_spramdump); error = device_create_file(&lmdev->dev, &dev_attr_hcddump); error = device_create_file(&lmdev->dev, &dev_attr_hcd_frrem); error = device_create_file(&lmdev->dev, &dev_attr_rd_reg_test); error = device_create_file(&lmdev->dev, &dev_attr_wr_reg_test); }
static int __init touchkey_init(void) { int ret = 0; u8 updated = 0; if ((ret = gpio_request(_3_GPIO_TOUCH_EN, "_3_GPIO_TOUCH_EN"))) printk(KERN_ERR "Failed to request gpio %s:%d\n", __func__, __LINE__); // if (ret = gpio_request(_3_GPIO_TOUCH_INT, "_3_GPIO_TOUCH_INT")) // printk(KERN_ERR "Failed to request gpio %s:%d\n", __func__, __LINE__); ret = misc_register(&touchkey_update_device); if (ret) { printk(KERN_ERR "%s misc_register fail\n",__FUNCTION__); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_activation) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_activation\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_activation.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_version) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_version\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_version.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_recommend) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_recommend\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_recommend.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_firmup) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_firmup\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_firmup.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_init) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_init\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_init.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_menu) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_menu\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_menu.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_touchkey_back) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_touchkey_back\n",__FUNCTION__); pr_err("Failed to create device file(%s)!\n", dev_attr_touchkey_back.attr.name); } if (device_create_file(touchkey_update_device.this_device, &dev_attr_brightness) < 0) { printk(KERN_ERR "%s device_create_file fail dev_attr_brightness\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(KERN_ERR "%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); } init_hw(); get_touchkey_data(version_info, 3); printk(TCHKEY_KERN_DEBUG "%s F/W version: 0x%x, Module version:0x%x\n",__FUNCTION__, version_info[1], version_info[2]); //------------------- Auto Firmware Update Routine Start -------------------// if(HWREV>=8) { if(version_info[1]==0xff) //unknown firmware state { if(!mcsdl_download_binary_data(MCS5000_CHIP)) //try MCS-5000 download mcsdl_download_binary_data(MCS5080_CHIP); // if first try is fail, MCS-5080 download updated = 1; } else { if(version_info[2]>=MCS5000_CHIP) //MCS-5000 { if(version_info[1]!=MCS5000_last_ver) //not latest version { mcsdl_download_binary_data(MCS5000_CHIP); updated = 1; } } else if(version_info[2]==MCS5080_CHIP)//MCS-5080 { if(version_info[1]!=MCS5080_last_ver) //not latest version { mcsdl_download_binary_data(MCS5080_CHIP); updated = 1; } } else printk("Touchkey IC module is old, can't update!"); } if(updated) { get_touchkey_data(version_info, 3); printk(TCHKEY_KERN_DEBUG "Updated F/W version: 0x%x, Module version:0x%x\n", version_info[1], version_info[2]); } } //------------------- Auto Firmware Update Routine End -------------------// ret = i2c_add_driver(&touchkey_i2c_driver); if(ret||(touchkey_driver==NULL)) { touchkey_dead = 1; printk("ret = %d, touch_driver= %p:", ret, touchkey_driver); printk(KERN_ERR "melfas touch keypad registration failed, module not inserted.ret= %d\n", ret); } return ret; }
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev) { const struct pm8xxx_vibrator_platform_data *pdata = pdev->dev.platform_data; struct pm8xxx_vib *vib; u8 val; int rc; if (!pdata) return -EINVAL; if (pdata->level_mV < VIB_MIN_LEVEL_mV || pdata->level_mV > VIB_MAX_LEVEL_mV) return -EINVAL; vib = kzalloc(sizeof(*vib), GFP_KERNEL); if (!vib) return -ENOMEM; vib->pdata = pdata; vib->level = pdata->level_mV / 100; vib->dev = &pdev->dev; #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_VOL vib->default_level = vib->level; vib->request_level = vib->level; #endif #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_MIN_TIMEOUT vib->min_timeout_ms = pdata->min_timeout_ms; vib->pre_value = 0; #endif #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_OVERDRIVE vib->overdrive_ms = pdata->overdrive_ms; vib->overdrive_range_ms = pdata->overdrive_range_ms; #endif #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_REST_POWER vib->min_stop_ms = pdata->min_stop_ms; vib->start_tv.tv_sec = 0; vib->start_tv.tv_usec = 0; vib->stop_tv.tv_sec = 0; vib->stop_tv.tv_usec = 0; #endif vib->max_level_mv = VIB_MAX_LEVEL_mV; vib->min_level_mv = VIB_MIN_LEVEL_mV; spin_lock_init(&vib->lock); INIT_WORK(&vib->work, pm8xxx_vib_update); hrtimer_init(&vib->vib_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vib->vib_timer.function = pm8xxx_vib_timer_func; #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_OVERDRIVE hrtimer_init(&vib->vib_overdrive_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vib->vib_overdrive_timer.function = pm8xxx_vib_overdrive_timer_func; #endif vib->timed_dev.name = "vibrator"; vib->timed_dev.get_time = pm8xxx_vib_get_time; vib->timed_dev.enable = pm8xxx_vib_enable; __dump_vib_regs(vib, "boot_vib_default"); /* * Configure the vibrator, it operates in manual mode * for timed_output framework. */ rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV); if (rc < 0) goto err_read_vib; val &= ~VIB_DRV_EN_MANUAL_MASK; rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV); if (rc < 0) goto err_read_vib; vib->reg_vib_drv = val; rc = timed_output_dev_register(&vib->timed_dev); if (rc < 0) goto err_read_vib; rc = sysfs_create_group(&vib->timed_dev.dev->kobj, &pm8xxx_vib_attr_group); #if 0 #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_VOL rc = device_create_file(vib->timed_dev.dev, &dev_attr_amp); if (rc < 0) goto err_read_vib; rc = device_create_file(vib->timed_dev.dev, &dev_attr_default_level); if (rc < 0) goto err_read_vib; #endif // LGE does not use this function. power on vib effect is played at SBL3 #ifndef CONFIG_MACH_LGE pm8xxx_vib_enable(&vib->timed_dev, pdata->initial_vibrate_ms); #endif #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_MIN_TIMEOUT rc = device_create_file(vib->timed_dev.dev, &dev_attr_min_ms); if (rc < 0) goto err_read_vib; #endif #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_OVERDRIVE rc = device_create_file(vib->timed_dev.dev, &dev_attr_over_ms); if (rc < 0) goto err_read_vib; rc = device_create_file(vib->timed_dev.dev, &dev_attr_over_range_ms); if (rc < 0) goto err_read_vib; #endif #ifdef CONFIG_LGE_PMIC8XXX_VIBRATOR_REST_POWER rc = device_create_file(vib->timed_dev.dev, &dev_attr_min_stop_ms); if (rc < 0) goto err_read_vib; #endif #endif // #if 0 platform_set_drvdata(pdev, vib); vib_dev = vib; return 0; err_read_vib: kfree(vib); return rc; }
int thermal_add_hwmon_sysfs(struct thermal_zone_device *tz) { struct thermal_hwmon_device *hwmon; struct thermal_hwmon_temp *temp; int new_hwmon_device = 1; int result; hwmon = thermal_hwmon_lookup_by_type(tz); if (hwmon) { new_hwmon_device = 0; goto register_sys_interface; } hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL); if (!hwmon) return -ENOMEM; INIT_LIST_HEAD(&hwmon->tz_list); strlcpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH); hwmon->device = hwmon_device_register(NULL); if (IS_ERR(hwmon->device)) { result = PTR_ERR(hwmon->device); goto free_mem; } dev_set_drvdata(hwmon->device, hwmon); result = device_create_file(hwmon->device, &dev_attr_name); if (result) goto free_mem; register_sys_interface: temp = kzalloc(sizeof(*temp), GFP_KERNEL); if (!temp) { result = -ENOMEM; goto unregister_name; } temp->tz = tz; hwmon->count++; snprintf(temp->temp_input.name, sizeof(temp->temp_input.name), "temp%d_input", hwmon->count); temp->temp_input.attr.attr.name = temp->temp_input.name; temp->temp_input.attr.attr.mode = 0444; temp->temp_input.attr.show = temp_input_show; sysfs_attr_init(&temp->temp_input.attr.attr); result = device_create_file(hwmon->device, &temp->temp_input.attr); if (result) goto free_temp_mem; if (thermal_zone_crit_temp_valid(tz)) { snprintf(temp->temp_crit.name, sizeof(temp->temp_crit.name), "temp%d_crit", hwmon->count); temp->temp_crit.attr.attr.name = temp->temp_crit.name; temp->temp_crit.attr.attr.mode = 0444; temp->temp_crit.attr.show = temp_crit_show; sysfs_attr_init(&temp->temp_crit.attr.attr); result = device_create_file(hwmon->device, &temp->temp_crit.attr); if (result) goto unregister_input; } mutex_lock(&thermal_hwmon_list_lock); if (new_hwmon_device) list_add_tail(&hwmon->node, &thermal_hwmon_list); list_add_tail(&temp->hwmon_node, &hwmon->tz_list); mutex_unlock(&thermal_hwmon_list_lock); return 0; unregister_input: device_remove_file(hwmon->device, &temp->temp_input.attr); free_temp_mem: kfree(temp); unregister_name: if (new_hwmon_device) { device_remove_file(hwmon->device, &dev_attr_name); hwmon_device_unregister(hwmon->device); } free_mem: if (new_hwmon_device) kfree(hwmon); return result; }
int xenbus_probe_node(struct xen_bus_type *bus, const char *type, const char *nodename) { char devname[XEN_BUS_ID_SIZE]; int err; struct xenbus_device *xendev; size_t stringlen; char *tmpstring; enum xenbus_state state = xenbus_read_driver_state(nodename); if (state != XenbusStateInitialising) { /* Device is not new, so ignore it. This can happen if a device is going away after switching to Closed. */ return 0; } stringlen = strlen(nodename) + 1 + strlen(type) + 1; xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL); if (!xendev) return -ENOMEM; xendev->state = XenbusStateInitialising; /* Copy the strings into the extra space. */ tmpstring = (char *)(xendev + 1); strcpy(tmpstring, nodename); xendev->nodename = tmpstring; tmpstring += strlen(tmpstring) + 1; strcpy(tmpstring, type); xendev->devicetype = tmpstring; init_completion(&xendev->down); xendev->dev.bus = &bus->bus; xendev->dev.release = xenbus_dev_release; err = bus->get_bus_id(devname, xendev->nodename); if (err) goto fail; dev_set_name(&xendev->dev, devname); /* Register with generic device framework. */ err = device_register(&xendev->dev); if (err) goto fail; err = device_create_file(&xendev->dev, &dev_attr_nodename); if (err) goto fail_unregister; err = device_create_file(&xendev->dev, &dev_attr_devtype); if (err) goto fail_remove_nodename; err = device_create_file(&xendev->dev, &dev_attr_modalias); if (err) goto fail_remove_devtype; return 0; fail_remove_devtype: device_remove_file(&xendev->dev, &dev_attr_devtype); fail_remove_nodename: device_remove_file(&xendev->dev, &dev_attr_nodename); fail_unregister: device_unregister(&xendev->dev); fail: kfree(xendev); return err; }
static int cm36686_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct cm36686_data *cm36686 = NULL; pr_info("%s is called.\n", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c functionality check failed!\n", __func__); return ret; } cm36686 = kzalloc(sizeof(struct cm36686_data), GFP_KERNEL); if (!cm36686) { pr_err("%s: failed to alloc memory for cm36686 module data\n", __func__); return -ENOMEM; } cm36686->pdata = client->dev.platform_data; cm36686->i2c_client = client; i2c_set_clientdata(client, cm36686); mutex_init(&cm36686->power_lock); mutex_init(&cm36686->read_lock); /* wake lock init for proximity sensor */ wake_lock_init(&cm36686->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); if (cm36686->pdata->cm36686_led_on) { cm36686->pdata->cm36686_led_on(true); msleep(20); } /* Check if the device is there or not. */ ret = cm36686_i2c_write_word(cm36686, REG_CS_CONF1, 0x0001); if (ret < 0) { pr_err("%s: cm36686 is not connected.(%d)\n", __func__, ret); goto err_setup_reg; } /* setup initial registers */ ret = cm36686_setup_reg(cm36686); if (ret < 0) { pr_err("%s: could not setup regs\n", __func__); goto err_setup_reg; } if (cm36686->pdata->cm36686_led_on) cm36686->pdata->cm36686_led_on(false); /* allocate proximity input_device */ cm36686->proximity_input_dev = input_allocate_device(); if (!cm36686->proximity_input_dev) { pr_err("%s: could not allocate proximity input device\n", __func__); goto err_input_allocate_device_proximity; } input_set_drvdata(cm36686->proximity_input_dev, cm36686); cm36686->proximity_input_dev->name = "proximity_sensor"; input_set_capability(cm36686->proximity_input_dev, EV_ABS, ABS_DISTANCE); input_set_abs_params(cm36686->proximity_input_dev, ABS_DISTANCE, 0, 1, 0, 0); ret = input_register_device(cm36686->proximity_input_dev); if (ret < 0) { input_free_device(cm36686->proximity_input_dev); pr_err("%s: could not register input device\n", __func__); goto err_input_register_device_proximity; } ret = sysfs_create_group(&cm36686->proximity_input_dev->dev.kobj, &proximity_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_proximity; } #if defined(CONFIG_SENSOR_USE_SYMLINK) ret = sensors_initialize_symlink(cm36686->proximity_input_dev); if (ret < 0) { pr_err("%s - proximity_sensors_initialize_symlink error(%d).\n", __func__, ret); goto err_proximity_sensor_register_failed; } #endif /* setup irq */ ret = cm36686_setup_irq(cm36686); if (ret) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } /* For factory test mode, we use timer to get average proximity data. */ /* prox_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm36686->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm36686->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC);/*2 sec*/ cm36686->prox_timer.function = cm36686_prox_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ cm36686->prox_wq = create_singlethread_workqueue("cm36686_prox_wq"); if (!cm36686->prox_wq) { ret = -ENOMEM; pr_err("%s: could not create prox workqueue\n", __func__); goto err_create_prox_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&cm36686->work_prox, cm36686_work_func_prox); /* allocate lightsensor input_device */ cm36686->light_input_dev = input_allocate_device(); if (!cm36686->light_input_dev) { pr_err("%s: could not allocate light input device\n", __func__); goto err_input_allocate_device_light; } input_set_drvdata(cm36686->light_input_dev, cm36686); cm36686->light_input_dev->name = "light_sensor"; input_set_capability(cm36686->light_input_dev, EV_REL, REL_MISC); input_set_capability(cm36686->light_input_dev, EV_REL, REL_DIAL); input_set_capability(cm36686->light_input_dev, EV_REL, REL_WHEEL); ret = input_register_device(cm36686->light_input_dev); if (ret < 0) { input_free_device(cm36686->light_input_dev); pr_err("%s: could not register input device\n", __func__); goto err_input_register_device_light; } ret = sysfs_create_group(&cm36686->light_input_dev->dev.kobj, &light_attribute_group); if (ret) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_light; } #if defined(CONFIG_SENSOR_USE_SYMLINK) ret = sensors_initialize_symlink(cm36686->light_input_dev); if (ret < 0) { pr_err("%s - light_sensors_initialize_symlink error(%d).\n", __func__, ret); goto err_light_sensor_register_failed; } #endif /* light_timer settings. we poll for light values using a timer. */ hrtimer_init(&cm36686->light_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); cm36686->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); cm36686->light_timer.function = cm36686_light_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ cm36686->light_wq = create_singlethread_workqueue("cm36686_light_wq"); if (!cm36686->light_wq) { ret = -ENOMEM; pr_err("%s: could not create light workqueue\n", __func__); goto err_create_light_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&cm36686->work_light, cm36686_work_func_light); /* set sysfs for proximity sensor */ cm36686->proximity_dev = sensors_classdev_register("proximity_sensor"); if (IS_ERR(cm36686->proximity_dev)) { pr_err("%s: could not create proximity_dev\n", __func__); goto err_proximity_device_create; } if (device_create_file(cm36686->proximity_dev, &dev_attr_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_state.attr.name); goto err_proximity_device_create_file1; } if (device_create_file(cm36686->proximity_dev, &attr_prox_raw) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, attr_prox_raw.attr.name); goto err_proximity_device_create_file2; } #ifdef CM36686_CANCELATION if (device_create_file(cm36686->proximity_dev, &dev_attr_prox_cal) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_prox_cal.attr.name); goto err_proximity_device_create_file3; } #endif if (device_create_file(cm36686->proximity_dev, &dev_attr_prox_avg) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_prox_avg.attr.name); goto err_proximity_device_create_file4; } if (device_create_file(cm36686->proximity_dev, &dev_attr_thresh_high) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_thresh_high.attr.name); goto err_proximity_device_create_file5; } if (device_create_file(cm36686->proximity_dev, &dev_attr_vendor) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_vendor.attr.name); goto err_proximity_device_create_file6; } if (device_create_file(cm36686->proximity_dev, &dev_attr_name) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_name.attr.name); goto err_proximity_device_create_file7; } if (device_create_file(cm36686->proximity_dev, &dev_attr_thresh_low) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_thresh_low.attr.name); goto err_proximity_device_create_file8; } dev_set_drvdata(cm36686->proximity_dev, cm36686); /* set sysfs for light sensor */ cm36686->light_dev = sensors_classdev_register("light_sensor"); if (IS_ERR(cm36686->light_dev)) { pr_err("%s: could not create light_dev\n", __func__); goto err_light_device_create; } if (device_create_file(cm36686->light_dev, &dev_attr_lux) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_lux.attr.name); goto err_light_device_create_file1; } if (device_create_file(cm36686->light_dev, &dev_attr_raw_data) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_raw_data.attr.name); goto err_light_device_create_file2; } if (device_create_file(cm36686->light_dev, &dev_attr_vendor) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_vendor.attr.name); goto err_light_device_create_file3; } if (device_create_file(cm36686->light_dev, &dev_attr_name) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_name.attr.name); goto err_light_device_create_file4; } dev_set_drvdata(cm36686->light_dev, cm36686); pr_info("%s is success.\n", __func__); goto done; /* error, unwind it all */ err_light_device_create_file4: device_remove_file(cm36686->light_dev, &dev_attr_vendor); err_light_device_create_file3: device_remove_file(cm36686->light_dev, &dev_attr_raw_data); err_light_device_create_file2: device_remove_file(cm36686->light_dev, &dev_attr_lux); err_light_device_create_file1: sensors_classdev_unregister(cm36686->light_dev); err_light_device_create: device_remove_file(cm36686->proximity_dev, &dev_attr_thresh_low); err_proximity_device_create_file8: device_remove_file(cm36686->proximity_dev, &dev_attr_name); err_proximity_device_create_file7: device_remove_file(cm36686->proximity_dev, &dev_attr_vendor); err_proximity_device_create_file6: device_remove_file(cm36686->proximity_dev, &dev_attr_thresh_high); err_proximity_device_create_file5: device_remove_file(cm36686->proximity_dev, &dev_attr_prox_avg); err_proximity_device_create_file4: #ifdef CM36686_CANCELATION device_remove_file(cm36686->proximity_dev, &dev_attr_prox_cal); err_proximity_device_create_file3: #endif device_remove_file(cm36686->proximity_dev, &attr_prox_raw); err_proximity_device_create_file2: device_remove_file(cm36686->proximity_dev, &dev_attr_state); err_proximity_device_create_file1: sensors_classdev_unregister(cm36686->proximity_dev); err_proximity_device_create: destroy_workqueue(cm36686->light_wq); err_create_light_workqueue: err_light_sensor_register_failed: sysfs_remove_group(&cm36686->light_input_dev->dev.kobj, &light_attribute_group); err_sysfs_create_group_light: input_unregister_device(cm36686->light_input_dev); err_input_register_device_light: err_input_allocate_device_light: destroy_workqueue(cm36686->prox_wq); err_create_prox_workqueue: free_irq(cm36686->irq, cm36686); gpio_free(cm36686->pdata->irq); err_setup_irq: err_proximity_sensor_register_failed: sysfs_remove_group(&cm36686->proximity_input_dev->dev.kobj, &proximity_attribute_group); err_sysfs_create_group_proximity: input_unregister_device(cm36686->proximity_input_dev); err_input_register_device_proximity: err_input_allocate_device_proximity: err_setup_reg: if (cm36686->pdata->cm36686_led_on) cm36686->pdata->cm36686_led_on(false); wake_lock_destroy(&cm36686->prx_wake_lock); mutex_destroy(&cm36686->read_lock); mutex_destroy(&cm36686->power_lock); kfree(cm36686); done: return ret; }
static void __cpuinit register_cpu_control(struct cpu *cpu) { device_create_file(&cpu->dev, &dev_attr_online); }
static int s3cfb_probe(struct platform_device *pdev) { struct s3c_platform_fb *pdata = NULL; struct resource *res = NULL; struct s3cfb_global *fbdev[2]; int ret = 0; int i = 0; #ifdef CONFIG_EXYNOS_DEV_PD /* to use the runtime PM helper functions */ pm_runtime_enable(&pdev->dev); /* enable the power domain */ pm_runtime_get_sync(&pdev->dev); #endif fbfimd = kzalloc(sizeof(struct s3cfb_fimd_desc), GFP_KERNEL); if (FIMD_MAX == 2) fbfimd->dual = 1; else fbfimd->dual = 0; for (i = 0; i < FIMD_MAX; i++) { /* global structure */ fbfimd->fbdev[i] = kzalloc(sizeof(struct s3cfb_global), GFP_KERNEL); fbdev[i] = fbfimd->fbdev[i]; if (!fbdev[i]) { dev_err(fbdev[i]->dev, "failed to allocate for \ global fb structure fimd[%d]!\n", i); ret = -ENOMEM; goto err0; } fbdev[i]->dev = &pdev->dev; #if defined(CONFIG_MACH_SMDK4X12) || defined(CONFIG_FB_S5P_AMS369FG06) s3cfb_set_lcd_info(fbdev[i]); #endif /* platform_data*/ pdata = to_fb_plat(&pdev->dev); if (pdata->lcd) fbdev[i]->lcd = (struct s3cfb_lcd *)pdata->lcd; if (pdata->cfg_gpio) pdata->cfg_gpio(pdev); if (pdata->clk_on) pdata->clk_on(pdev, &fbdev[i]->clock); /* io memory */ res = platform_get_resource(pdev, IORESOURCE_MEM, i); if (!res) { dev_err(fbdev[i]->dev, "failed to get io memory region\n"); ret = -EINVAL; goto err1; } res = request_mem_region(res->start, res->end - res->start + 1, pdev->name); if (!res) { dev_err(fbdev[i]->dev, "failed to request io memory region\n"); ret = -EINVAL; goto err1; } fbdev[i]->regs = ioremap(res->start, res->end - res->start + 1); fbdev[i]->regs_org = fbdev[i]->regs; if (!fbdev[i]->regs) { dev_err(fbdev[i]->dev, "failed to remap io region\n"); ret = -EINVAL; goto err1; } /* irq */ fbdev[i]->irq = platform_get_irq(pdev, 0); if (request_irq(fbdev[i]->irq, s3cfb_irq_frame, IRQF_SHARED, pdev->name, fbdev[i])) { dev_err(fbdev[i]->dev, "request_irq failed\n"); ret = -EINVAL; goto err2; } #ifdef CONFIG_FB_S5P_TRACE_UNDERRUN if (request_irq(platform_get_irq(pdev, 1), s3cfb_irq_fifo, IRQF_DISABLED, pdev->name, fbdev[i])) { dev_err(fbdev[i]->dev, "request_irq failed\n"); ret = -EINVAL; goto err2; } s3cfb_set_fifo_interrupt(fbdev[i], 1); dev_info(fbdev[i]->dev, "fifo underrun trace\n"); #endif #ifdef CONFIG_FB_S5P_MDNIE /* only FIMD0 is supported */ if (i == 0) s3c_mdnie_setup(); #endif /* hw setting */ s3cfb_init_global(fbdev[i]); fbdev[i]->system_state = POWER_ON; spin_lock_init(&fbdev[i]->slock); /* alloc fb_info */ if (s3cfb_alloc_framebuffer(fbdev[i], i)) { dev_err(fbdev[i]->dev, "alloc error fimd[%d]\n", i); ret = -ENOMEM; goto err3; } /* register fb_info */ if (s3cfb_register_framebuffer(fbdev[i])) { dev_err(fbdev[i]->dev, "register error fimd[%d]\n", i); return -EINVAL; goto err3; } /* enable display */ s3cfb_set_clock(fbdev[i]); #ifdef CONFIG_FB_S5P_MDNIE /* only FIMD0 is supported */ if (i == 0) { if (pdata->set_display_path) pdata->set_display_path(); s3cfb_set_dualrgb(fbdev[i], S3C_DUALRGB_MDNIE); s3c_mdnie_init_global(fbdev[i]); s3c_mdnie_display_on(fbdev[i]); } #endif s3cfb_enable_window(fbdev[0], pdata->default_win); s3cfb_update_power_state(fbdev[i], pdata->default_win, FB_BLANK_UNBLANK); /* Set alpha value width to 8-bit */ s3cfb_set_alpha_value_width(fbdev[i], i); s3cfb_display_on(fbdev[i]); #if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) #ifdef CONFIG_BUSFREQ_OPP /* To lock bus frequency in OPP mode */ fbdev[i]->bus_dev = dev_get("exynos-busfreq"); #endif #endif #ifdef CONFIG_HAS_WAKELOCK #ifdef CONFIG_HAS_EARLYSUSPEND fbdev[i]->early_suspend.suspend = s3cfb_early_suspend; fbdev[i]->early_suspend.resume = s3cfb_late_resume; fbdev[i]->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB; register_early_suspend(&fbdev[i]->early_suspend); #endif #endif ret = device_create_file(fbdev[i]->dev, &dev_attr_fimd_dump); if (ret < 0) dev_err(fbdev[0]->dev, "failed to add sysfs entries\n"); ret = device_create_file(fbdev[i]->dev, &dev_attr_ielcd_dump); if (ret < 0) dev_err(fbdev[0]->dev, "failed to add sysfs entries\n"); }
/* this function creates the sys files that will export each signal status * to sysfs each value will be put in a separate filename */ void dgnc_create_ports_sysfiles(struct dgnc_board *bd) { int rc = 0; dev_set_drvdata(&bd->pdev->dev, bd); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_state); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_baud); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_msignals); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_iflag); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_cflag); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_oflag); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_lflag); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_digi_flag); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_rxcount); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_ports_txcount); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_vpd); rc |= device_create_file(&(bd->pdev->dev), &dev_attr_serial_number); if (rc) printk(KERN_ERR "DGNC: sysfs device_create_file failed!\n"); }
static int fimc_is_probe(struct platform_device *pdev) { struct exynos4_platform_fimc_is *pdata; struct resource *mem_res; struct resource *regs_res; struct fimc_is_dev *dev; #if defined(CONFIG_VIDEO_EXYNOS_FIMC_IS_BAYER) struct v4l2_device *v4l2_dev; struct vb2_queue *isp_q; #endif int ret = -ENODEV; dev = kzalloc(sizeof(*dev), GFP_KERNEL); if (!dev) { dev_err(&pdev->dev, "Not enough memory for FIMC-IS device.\n"); return -ENOMEM; } dev->faceinfo_array = kzalloc(sizeof(*(dev->faceinfo_array)), GFP_KERNEL); if (!dev->faceinfo_array) { kfree(dev); dev_err(&pdev->dev, "Not enough memory for FIMC-IS device.\n"); return -ENOMEM; } dev->faceinfo_array->faceinfo = kzalloc(sizeof(*(dev->faceinfo_array->faceinfo)) * MAX_FRAME_COUNT, GFP_KERNEL); if (!dev->faceinfo_array->faceinfo) { kfree(dev->faceinfo_array); kfree(dev); dev_err(&pdev->dev, "Not enough memory for FIMC-IS device.\n"); return -ENOMEM; } mutex_init(&dev->lock); spin_lock_init(&dev->slock); init_waitqueue_head(&dev->irq_queue1); init_waitqueue_head(&dev->aflost_queue); INIT_WORK(&fimc_is_af_wq,fimc_is_af_interrupt); dev->pdev = pdev; if (!dev->pdev) { dev_err(&pdev->dev, "No platform data specified\n"); goto p_err_info; } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "Platform data not set\n"); goto p_err_info; } dev->pdata = pdata; /* * I/O remap */ mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem_res) { dev_err(&pdev->dev, "Failed to get io memory region\n"); ret = -ENOENT; goto p_err_info; } regs_res = request_mem_region(mem_res->start, resource_size(mem_res), pdev->name); if (!regs_res) { dev_err(&pdev->dev, "Failed to request io memory region\n"); ret = -ENOENT; goto p_err_info; } dev->regs_res = regs_res; dev->regs = ioremap(mem_res->start, resource_size(mem_res)); if (!dev->regs) { dev_err(&pdev->dev, "Failed to remap io region\n"); ret = -ENXIO; goto p_err_req_region; } /* * initialize IRQ , FIMC-IS IRQ : ISP[0] -> SPI[90] , ISP[1] -> SPI[95] */ dev->irq1 = platform_get_irq(pdev, 0); if (dev->irq1 < 0) { ret = dev->irq1; dev_err(&pdev->dev, "Failed to get irq\n"); goto p_err_get_irq; } ret = request_irq(dev->irq1, fimc_is_irq_handler1, IRQF_DISABLED, dev_name(&pdev->dev), dev); if (ret) { dev_err(&pdev->dev, "failed to allocate irq (%d)\n", ret); goto p_err_req_irq; } #if defined(CONFIG_VIDEO_EXYNOS_FIMC_IS_BAYER) /* Init v4l2 device (ISP) */ #if defined(CONFIG_VIDEOBUF2_CMA_PHYS) dev->vb2 = &fimc_is_vb2_cma; #elif defined(CONFIG_VIDEOBUF2_ION) dev->vb2 = &fimc_is_vb2_ion; #endif /* Init and register V4L2 device */ v4l2_dev = &dev->video[FIMC_IS_VIDEO_NUM_BAYER].v4l2_dev; if (!v4l2_dev->name[0]) snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s.isp", dev_name(&dev->pdev->dev)); ret = v4l2_device_register(NULL, v4l2_dev); snprintf(dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.name, sizeof(dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.name), "%s", "exynos4-fimc-is-bayer"); dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.fops = &fimc_is_isp_video_fops; dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.ioctl_ops = &fimc_is_isp_video_ioctl_ops; dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.minor = -1; dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.release = video_device_release; dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.lock = &dev->lock; video_set_drvdata(&dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd, dev); dev->video[FIMC_IS_VIDEO_NUM_BAYER].dev = dev; isp_q = &dev->video[FIMC_IS_VIDEO_NUM_BAYER].vbq; memset(isp_q, 0, sizeof(*isp_q)); isp_q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; isp_q->io_modes = VB2_MMAP | VB2_USERPTR; isp_q->drv_priv = &dev->video[FIMC_IS_VIDEO_NUM_BAYER]; isp_q->ops = &fimc_is_isp_qops; isp_q->mem_ops = dev->vb2->ops; vb2_queue_init(isp_q); ret = video_register_device(&dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd, VFL_TYPE_GRABBER, 30); if (ret) { v4l2_err(v4l2_dev, "Failed to register video device\n"); goto err_vd_reg; } printk(KERN_INFO "FIMC-IS Video node :: ISP %d minor : %d\n", dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.num, dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd.minor); #endif /* * initialize memory manager */ ret = fimc_is_init_mem_mgr(dev); if (ret) { dev_err(&pdev->dev, "failed to fimc_is_init_mem_mgr (%d)\n", ret); goto p_err_init_mem; } dbg("Parameter region = 0x%08x\n", (unsigned int)dev->is_p_region); /* * Get related clock for FIMC-IS */ if (dev->pdata->clk_get) { dev->pdata->clk_get(pdev); } else { err("#### failed to Get Clock####\n"); goto p_err_init_mem; } /* * Get regulator for FIMC-IS */ #ifdef CONFIG_REGULATOR dev->r_vdd18_cam = regulator_get(NULL, "vdd_ldo17"); if (IS_ERR(dev->r_vdd18_cam)) { pr_err("failed to get resource %s\n", "vdd_ldo17"); goto p_err_init_mem; } dev->r_vddio18_cam = regulator_get(NULL, "vdd_ldo18"); if (IS_ERR(dev->r_vdd18_cam)) { pr_err("failed to get resource %s\n", "vdd_ldo18"); regulator_put(dev->r_vdd18_cam); goto p_err_init_mem; } dev->r_vdd28_af_cam = regulator_get(NULL, "vdd_ldo24"); if (IS_ERR(dev->r_vdd18_cam)) { pr_err("failed to get resource %s\n", "vdd_ldo24"); regulator_put(dev->r_vddio18_cam); regulator_put(dev->r_vdd18_cam); goto p_err_init_mem; } dev->r_vadd28_cam = regulator_get(NULL, "vdd_ldo26"); if (IS_ERR(dev->r_vdd18_cam)) { pr_err("failed to get resource %s\n", "vdd_ldo26"); regulator_put(dev->r_vdd28_af_cam); regulator_put(dev->r_vddio18_cam); regulator_put(dev->r_vdd18_cam); goto p_err_init_mem; } #endif /* Init v4l2 sub device */ v4l2_subdev_init(&dev->sd, &fimc_is_subdev_ops); dev->sd.owner = THIS_MODULE; strcpy(dev->sd.name, MODULE_NAME); v4l2_set_subdevdata(&dev->sd, pdev); platform_set_drvdata(pdev, &dev->sd); pm_runtime_enable(&pdev->dev); #if defined(CONFIG_BUSFREQ_OPP) || defined(CONFIG_BUSFREQ_LOCK_WRAPPER) /* To lock bus frequency in OPP mode */ dev->bus_dev = dev_get("exynos-busfreq"); #endif dev->power = 0; dev->state = 0; dev->sensor_num = FIMC_IS_SENSOR_NUM; dev->sensor.id = 0; dev->p_region_index1 = 0; dev->p_region_index2 = 0; dev->sensor.offset_x = 16; dev->sensor.offset_y = 12; dev->sensor.framerate_update = false; atomic_set(&dev->p_region_num, 0); set_bit(IS_ST_IDLE, &dev->state); set_bit(IS_PWR_ST_POWEROFF, &dev->power); dev->af.af_state = FIMC_IS_AF_IDLE; dev->af.mode = IS_FOCUS_MODE_IDLE; dev->low_power_mode = false; dev->fw.state = 0; dev->setfile.state = 0; dev->af.af_lost_state = 0; #if defined(M0) s5k6a3_dev = device_create(camera_class, NULL, 0, NULL, "front"); if (IS_ERR(s5k6a3_dev)) { printk(KERN_ERR "failed to create device!\n"); } else { if (device_create_file(s5k6a3_dev, &dev_attr_front_camtype) < 0) { printk(KERN_ERR "failed to create device file, %s\n", dev_attr_front_camtype.attr.name); } if (device_create_file(s5k6a3_dev, &dev_attr_front_camfw) < 0) { printk(KERN_ERR "failed to create device file, %s\n", dev_attr_front_camfw.attr.name); } } #endif printk(KERN_INFO "FIMC-IS probe completed\n"); return 0; p_err_init_mem: free_irq(dev->irq1, dev); #if defined(CONFIG_VIDEO_EXYNOS_FIMC_IS_BAYER) err_vd_reg: video_device_release(&dev->video[FIMC_IS_VIDEO_NUM_BAYER].vd); #endif p_err_req_irq: p_err_get_irq: iounmap(dev->regs); p_err_req_region: release_mem_region(regs_res->start, resource_size(regs_res)); p_err_info: dev_err(&dev->pdev->dev, "failed to install\n"); kfree(dev); return ret; }
static int __devinit sharpsl_pm_probe(struct platform_device *pdev) { int ret; if (!pdev->dev.platform_data) return -EINVAL; sharpsl_pm.dev = &pdev->dev; sharpsl_pm.machinfo = pdev->dev.platform_data; sharpsl_pm.charge_mode = CHRG_OFF; sharpsl_pm.flags = 0; init_timer(&sharpsl_pm.ac_timer); sharpsl_pm.ac_timer.function = sharpsl_ac_timer; init_timer(&sharpsl_pm.chrg_full_timer); sharpsl_pm.chrg_full_timer.function = sharpsl_chrg_full_timer; led_trigger_register_simple("sharpsl-charge", &sharpsl_charge_led_trigger); sharpsl_pm.machinfo->init(); gpio_request(sharpsl_pm.machinfo->gpio_acin, "AC IN"); gpio_direction_input(sharpsl_pm.machinfo->gpio_acin); gpio_request(sharpsl_pm.machinfo->gpio_batfull, "Battery Full"); gpio_direction_input(sharpsl_pm.machinfo->gpio_batfull); gpio_request(sharpsl_pm.machinfo->gpio_batlock, "Battery Lock"); gpio_direction_input(sharpsl_pm.machinfo->gpio_batlock); /* Register interrupt handlers */ if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin), sharpsl_ac_isr, IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "AC Input Detect", sharpsl_ac_isr)) { dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin)); } if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock), sharpsl_fatal_isr, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "Battery Cover", sharpsl_fatal_isr)) { dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock)); } if (sharpsl_pm.machinfo->gpio_fatal) { if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal), sharpsl_fatal_isr, IRQF_DISABLED | IRQF_TRIGGER_FALLING, "Fatal Battery", sharpsl_fatal_isr)) { dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal)); } } if (sharpsl_pm.machinfo->batfull_irq) { /* Register interrupt handler. */ if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull), sharpsl_chrg_full_isr, IRQF_DISABLED | IRQF_TRIGGER_RISING, "CO", sharpsl_chrg_full_isr)) { dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull)); } } ret = device_create_file(&pdev->dev, &dev_attr_battery_percentage); ret |= device_create_file(&pdev->dev, &dev_attr_battery_voltage); if (ret != 0) dev_warn(&pdev->dev, "Failed to register attributes (%d)\n", ret); apm_get_power_status = sharpsl_apm_get_power_status; #ifdef CONFIG_PM suspend_set_ops(&sharpsl_pm_ops); #endif mod_timer(&sharpsl_pm.ac_timer, jiffies + msecs_to_jiffies(250)); return 0; }
static int acm_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_cdc_union_desc *union_header = NULL; struct usb_cdc_country_functional_desc *cfd = NULL; unsigned char *buffer = intf->altsetting->extra; int buflen = intf->altsetting->extralen; struct usb_interface *control_interface; struct usb_interface *data_interface; struct usb_endpoint_descriptor *epctrl = NULL; struct usb_endpoint_descriptor *epread = NULL; struct usb_endpoint_descriptor *epwrite = NULL; struct usb_device *usb_dev = interface_to_usbdev(intf); struct acm *acm; int minor; int ctrlsize, readsize; u8 *buf; u8 ac_management_function = 0; u8 call_management_function = 0; int call_interface_num = -1; int data_interface_num = -1; unsigned long quirks; int num_rx_buf; int i; int combined_interfaces = 0; quirks = (unsigned long)id->driver_info; num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR; if (quirks == NO_UNION_NORMAL) { data_interface = usb_ifnum_to_if(usb_dev, 1); control_interface = usb_ifnum_to_if(usb_dev, 0); goto skip_normal_probe; } if (!buffer) { dev_err(&intf->dev, "Weird descriptor references\n"); return -EINVAL; } if (!buflen) { if (intf->cur_altsetting->endpoint && intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) { dev_dbg(&intf->dev, "Seeking extra descriptors on endpoint\n"); buflen = intf->cur_altsetting->endpoint->extralen; buffer = intf->cur_altsetting->endpoint->extra; } else { dev_err(&intf->dev, "Zero length descriptor references\n"); return -EINVAL; } } while (buflen > 0) { if (buffer[1] != USB_DT_CS_INTERFACE) { dev_err(&intf->dev, "skipping garbage\n"); goto next_desc; } switch (buffer[2]) { case USB_CDC_UNION_TYPE: if (union_header) { dev_err(&intf->dev, "More than one " "union descriptor, skipping ...\n"); goto next_desc; } union_header = (struct usb_cdc_union_desc *)buffer; break; case USB_CDC_COUNTRY_TYPE: cfd = (struct usb_cdc_country_functional_desc *)buffer; break; case USB_CDC_HEADER_TYPE: break; case USB_CDC_ACM_TYPE: ac_management_function = buffer[3]; break; case USB_CDC_CALL_MANAGEMENT_TYPE: call_management_function = buffer[3]; call_interface_num = buffer[4]; if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3) dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n"); break; default: dev_dbg(&intf->dev, "Ignoring descriptor: " "type %02x, length %d\n", buffer[2], buffer[0]); break; } next_desc: buflen -= buffer[0]; buffer += buffer[0]; } if (!union_header) { if (call_interface_num > 0) { dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n"); if (quirks & NO_DATA_INTERFACE) data_interface = usb_ifnum_to_if(usb_dev, 0); else data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); control_interface = intf; } else { if (intf->cur_altsetting->desc.bNumEndpoints != 3) { dev_dbg(&intf->dev,"No union descriptor, giving up\n"); return -ENODEV; } else { dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n"); combined_interfaces = 1; control_interface = data_interface = intf; goto look_for_collapsed_interface; } } } else { control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0)); if (!control_interface || !data_interface) { dev_dbg(&intf->dev, "no interfaces\n"); return -ENODEV; } } if (data_interface_num != call_interface_num) dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n"); if (control_interface == data_interface) { dev_warn(&intf->dev,"Control and data interfaces are not separated!\n"); combined_interfaces = 1; quirks |= NO_CAP_LINE; if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) { dev_err(&intf->dev, "This needs exactly 3 endpoints\n"); return -EINVAL; } look_for_collapsed_interface: for (i = 0; i < 3; i++) { struct usb_endpoint_descriptor *ep; ep = &data_interface->cur_altsetting->endpoint[i].desc; if (usb_endpoint_is_int_in(ep)) epctrl = ep; else if (usb_endpoint_is_bulk_out(ep)) epwrite = ep; else if (usb_endpoint_is_bulk_in(ep)) epread = ep; else return -EINVAL; } if (!epctrl || !epread || !epwrite) return -ENODEV; else goto made_compressed_probe; } skip_normal_probe: if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) { if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) { struct usb_interface *t; dev_dbg(&intf->dev, "Your device has switched interfaces.\n"); t = control_interface; control_interface = data_interface; data_interface = t; } else { return -EINVAL; } } if (!combined_interfaces && intf != control_interface) return -ENODEV; if (!combined_interfaces && usb_interface_claimed(data_interface)) { dev_dbg(&intf->dev, "The data interface isn't available\n"); return -EBUSY; } if (data_interface->cur_altsetting->desc.bNumEndpoints < 2) return -EINVAL; epctrl = &control_interface->cur_altsetting->endpoint[0].desc; epread = &data_interface->cur_altsetting->endpoint[0].desc; epwrite = &data_interface->cur_altsetting->endpoint[1].desc; if (!usb_endpoint_dir_in(epread)) { struct usb_endpoint_descriptor *t; dev_dbg(&intf->dev, "The data interface has switched endpoints\n"); t = epread; epread = epwrite; epwrite = t; } made_compressed_probe: dev_dbg(&intf->dev, "interfaces are valid\n"); acm = kzalloc(sizeof(struct acm), GFP_KERNEL); if (acm == NULL) { dev_err(&intf->dev, "out of memory (acm kzalloc)\n"); goto alloc_fail; } minor = acm_alloc_minor(acm); if (minor == ACM_TTY_MINORS) { dev_err(&intf->dev, "no more free acm devices\n"); kfree(acm); return -ENODEV; } ctrlsize = usb_endpoint_maxp(epctrl); readsize = usb_endpoint_maxp(epread) * (quirks == SINGLE_RX_URB ? 1 : 2); acm->combined_interfaces = combined_interfaces; acm->writesize = usb_endpoint_maxp(epwrite) * 20; acm->control = control_interface; acm->data = data_interface; acm->minor = minor; acm->dev = usb_dev; acm->ctrl_caps = ac_management_function; if (quirks & NO_CAP_LINE) acm->ctrl_caps &= ~USB_CDC_CAP_LINE; acm->ctrlsize = ctrlsize; acm->readsize = readsize; acm->rx_buflimit = num_rx_buf; INIT_WORK(&acm->work, acm_softint); spin_lock_init(&acm->write_lock); spin_lock_init(&acm->read_lock); mutex_init(&acm->mutex); acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress); acm->is_int_ep = usb_endpoint_xfer_int(epread); if (acm->is_int_ep) acm->bInterval = epread->bInterval; tty_port_init(&acm->port); acm->port.ops = &acm_port_ops; buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); if (!buf) { dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n"); goto alloc_fail2; } acm->ctrl_buffer = buf; if (acm_write_buffers_alloc(acm) < 0) { dev_err(&intf->dev, "out of memory (write buffer alloc)\n"); goto alloc_fail4; } acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL); if (!acm->ctrlurb) { dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n"); goto alloc_fail5; } for (i = 0; i < num_rx_buf; i++) { struct acm_rb *rb = &(acm->read_buffers[i]); struct urb *urb; rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL, &rb->dma); if (!rb->base) { dev_err(&intf->dev, "out of memory " "(read bufs usb_alloc_coherent)\n"); goto alloc_fail6; } rb->index = i; rb->instance = acm; urb = usb_alloc_urb(0, GFP_KERNEL); if (!urb) { dev_err(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n"); goto alloc_fail6; } urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; urb->transfer_dma = rb->dma; if (acm->is_int_ep) { usb_fill_int_urb(urb, acm->dev, acm->rx_endpoint, rb->base, acm->readsize, acm_read_bulk_callback, rb, acm->bInterval); } else { usb_fill_bulk_urb(urb, acm->dev, acm->rx_endpoint, rb->base, acm->readsize, acm_read_bulk_callback, rb); } acm->read_urbs[i] = urb; __set_bit(i, &acm->read_urbs_free); } for (i = 0; i < ACM_NW; i++) { struct acm_wb *snd = &(acm->wb[i]); snd->urb = usb_alloc_urb(0, GFP_KERNEL); if (snd->urb == NULL) { dev_err(&intf->dev, "out of memory (write urbs usb_alloc_urb)\n"); goto alloc_fail7; } if (usb_endpoint_xfer_int(epwrite)) usb_fill_int_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval); else usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), NULL, acm->writesize, acm_write_bulk, snd); snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; snd->instance = acm; } usb_set_intfdata(intf, acm); i = device_create_file(&intf->dev, &dev_attr_bmCapabilities); if (i < 0) goto alloc_fail7; if (cfd) { acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL); if (!acm->country_codes) goto skip_countries; acm->country_code_size = cfd->bLength - 4; memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4); acm->country_rel_date = cfd->iCountryCodeRelDate; i = device_create_file(&intf->dev, &dev_attr_wCountryCodes); if (i < 0) { kfree(acm->country_codes); acm->country_codes = NULL; acm->country_code_size = 0; goto skip_countries; } i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate); if (i < 0) { device_remove_file(&intf->dev, &dev_attr_wCountryCodes); kfree(acm->country_codes); acm->country_codes = NULL; acm->country_code_size = 0; goto skip_countries; } } skip_countries: usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval ? epctrl->bInterval : 0xff); acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; acm->ctrlurb->transfer_dma = acm->ctrl_dma; dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); acm_set_control(acm, acm->ctrlout); acm->line.dwDTERate = cpu_to_le32(9600); acm->line.bDataBits = 8; acm_set_line(acm, &acm->line); usb_driver_claim_interface(&acm_driver, data_interface, acm); usb_set_intfdata(data_interface, acm); usb_get_intf(control_interface); tty_register_device(acm_tty_driver, minor, &control_interface->dev); return 0; alloc_fail7: for (i = 0; i < ACM_NW; i++) usb_free_urb(acm->wb[i].urb); alloc_fail6: for (i = 0; i < num_rx_buf; i++) usb_free_urb(acm->read_urbs[i]); acm_read_buffers_free(acm); usb_free_urb(acm->ctrlurb); alloc_fail5: acm_write_buffers_free(acm); alloc_fail4: usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); alloc_fail2: acm_release_minor(acm); kfree(acm); alloc_fail: return -ENOMEM; }
static int gp2a_opt_probe(struct platform_device *pdev) { struct gp2a_data *gp2a; struct gp2a_platform_data *pdata = pdev->dev.platform_data; u8 value = 0; int err = 0; gprintk("probe start!\n"); if (!pdata) { pr_err("%s: missing pdata!\n", __func__); return err; } if (!pdata->gp2a_led_on) { pr_err("%s: incomplete pdata!\n", __func__); return err; } /* gp2a power on */ pdata->gp2a_led_on(true); if (pdata->gp2a_get_threshold) { gp2a_update_threshold(is_gp2a030a() ? gp2a_original_image_030a : gp2a_original_image, pdata->gp2a_get_threshold(), false); } /* allocate driver_data */ gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL); if (!gp2a) { pr_err("kzalloc error\n"); return -ENOMEM; } proximity_enable = 0; proximity_sensor_detection = 0; proximity_avg_on = 0; gp2a->enabled = 0; gp2a->pdata = pdata; /* prox_timer settings. we poll for prox_avg values using a timer. */ hrtimer_init(&gp2a->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); gp2a->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC); gp2a->prox_timer.function = gp2a_prox_timer_func; gp2a->prox_wq = create_singlethread_workqueue("gp2a_prox_wq"); if (!gp2a->prox_wq) { err = -ENOMEM; pr_err("%s: could not create prox workqueue\n", __func__); goto err_create_prox_workqueue; } INIT_WORK(&gp2a->work_prox, gp2a_work_func_prox_avg); INIT_WORK(&gp2a->work, gp2a_work_func_prox); err = proximity_input_init(gp2a); if (err < 0) goto error_setup_reg; err = sysfs_create_group(&gp2a->input_dev->dev.kobj, &proximity_attribute_group); if (err < 0) goto err_sysfs_create_group_proximity; /* set platdata */ platform_set_drvdata(pdev, gp2a); /* wake lock init */ wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND, "prx_wake_lock"); /* init i2c */ opt_i2c_init(); if (opt_i2c_client == NULL) { pr_err("opt_probe failed : i2c_client is NULL\n"); goto err_no_device; } else printk(KERN_INFO "opt_i2c_client : (0x%p), address = %x\n", opt_i2c_client, opt_i2c_client->addr); /* GP2A Regs INIT SETTINGS and Check I2C communication */ value = 0x00; /* shutdown mode op[3]=0 */ err = opt_i2c_write((u8) (COMMAND1), &value); if (err < 0) { pr_err("%s failed : threre is no such device.\n", __func__); goto err_no_device; } /* Setup irq */ err = gp2a_setup_irq(gp2a); if (err) { pr_err("%s: could not setup irq\n", __func__); goto err_setup_irq; } /* set sysfs for proximity sensor */ gp2a->proximity_dev = sensors_classdev_register("proximity_sensor"); if (IS_ERR(gp2a->proximity_dev)) { pr_err("%s: could not create proximity_dev\n", __func__); goto err_proximity_device_create; } if (device_create_file(gp2a->proximity_dev, &dev_attr_state) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_state.attr.name); goto err_proximity_device_create_file1; } if (device_create_file(gp2a->proximity_dev, &dev_attr_prox_avg) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_prox_avg.attr.name); goto err_proximity_device_create_file2; } if (device_create_file(gp2a->proximity_dev, &dev_attr_prox_thresh) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_prox_thresh.attr.name); goto err_proximity_device_create_file3; } if (device_create_file(gp2a->proximity_dev, &dev_attr_vendor) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_vendor.attr.name); goto err_proximity_device_create_file4; } if (device_create_file(gp2a->proximity_dev, &dev_attr_name) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_name.attr.name); goto err_proximity_device_create_file5; } if (device_create_file(gp2a->proximity_dev, &dev_attr_raw_data) < 0) { pr_err("%s: could not create device file(%s)!\n", __func__, dev_attr_raw_data.attr.name); goto err_proximity_device_create_file6; } #ifdef CONFIG_SLP device_init_wakeup(gp2a->proximity_dev, true); #endif dev_set_drvdata(gp2a->proximity_dev, gp2a); device_init_wakeup(&pdev->dev, 1); gprintk("probe success!\n"); return 0; err_proximity_device_create_file6: device_remove_file(gp2a->proximity_dev, &dev_attr_raw_data); err_proximity_device_create_file5: device_remove_file(gp2a->proximity_dev, &dev_attr_name); err_proximity_device_create_file4: device_remove_file(gp2a->proximity_dev, &dev_attr_vendor); err_proximity_device_create_file3: device_remove_file(gp2a->proximity_dev, &dev_attr_prox_avg); err_proximity_device_create_file2: device_remove_file(gp2a->proximity_dev, &dev_attr_state); err_proximity_device_create_file1: sensors_classdev_unregister(gp2a->proximity_dev); err_proximity_device_create: gpio_free(pdata->p_out); err_setup_irq: err_no_device: sysfs_remove_group(&gp2a->input_dev->dev.kobj, &proximity_attribute_group); wake_lock_destroy(&gp2a->prx_wake_lock); err_sysfs_create_group_proximity: input_unregister_device(gp2a->input_dev); error_setup_reg: destroy_workqueue(gp2a->prox_wq); err_create_prox_workqueue: kfree(gp2a); return err; }
static int spt_modem_probe(struct platform_device *pdev) { int ret; struct spt_modem_ctl *mc; struct spt_modem_platform_data *pdata; pdata = pdev->dev.platform_data; if(pdata == NULL){ dev_err(&pdev->dev, "no platform data\n"); return -ENOMEM; } mc = kzalloc(sizeof(struct spt_modem_ctl), GFP_KERNEL); if(mc == NULL){ dev_err(&pdev->dev, "kmalloc fail\n"); return -ENOMEM; } init_completion(&mc->done); init_waitqueue_head(&mc->read_wq); spt_modem_wake_lock_initial(mc); mc->power_on = pdata->pwr_on; mc->modem_alive = pdata->salive; mc->power_status = pdata->s2m1; mc->usb_download = pdata->m2s1; mc->cp_user_reset = 0; mc->cp_usb_download = 0; /*reset irq*/ mc->modem_crash_irq = gpio_to_irq(mc->modem_alive); ret = request_threaded_irq(mc->modem_crash_irq, NULL, spt_modem_cpcrash_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "CP_CRASH_INT", mc); if (ret) { pr_err("Failed register gpio_cp_reset_int irq(%d)!\n", mc->modem_crash_irq); goto err1; } ret = enable_irq_wake(mc->modem_crash_irq); if (ret) { pr_err("failed to enable_irq_wake of modem reset:%d\n", ret); goto err2; } ret = misc_register(&spt_modem_miscdev); if(ret) { pr_err("Failed to register modem control device\n"); goto err3; } ret = device_create_file(spt_modem_miscdev.this_device, &attr_spt_modem_debug); if (ret) { pr_err("failed to create sysfs file:attr_modem_debug!\n"); goto err4; } ret = device_create_file(spt_modem_miscdev.this_device, &attr_spt_usb_download); if (ret) { pr_err("failed to create sysfs file:attr_spt_usb_download!\n"); goto err4; } platform_set_drvdata(pdev, mc); spt_modem_global_mc = mc; /*power on modem*/ spt_sc8803g_on(mc); return 0; err4: misc_deregister(&spt_modem_miscdev); err3: disable_irq_wake(mc->modem_crash_irq); err2: free_irq(mc->modem_crash_irq, NULL); err1: kfree(mc); return ret; }
static int bh1721_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct input_dev *input_dev; struct bh1721_data *bh1721; struct bh1721_platform_data *pdata = client->dev.platform_data; if (!pdata) { pr_err("%s: missing pdata!\n", __func__); return ret; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c functionality check failed!\n", __func__); return ret; } bh1721 = kzalloc(sizeof(struct bh1721_data), GFP_KERNEL); if (!bh1721) { pr_err("%s: failed to alloc memory for module data\n", __func__); return -ENOMEM; } bh1721->pdata = pdata; bh1721->reset = pdata->reset; bh1721->i2c_client = client; i2c_set_clientdata(client, bh1721); if (bh1721->reset) bh1721->reset(); mutex_init(&bh1721->power_lock); /* hrtimer settings. we poll for light values using a timer. */ hrtimer_init(&bh1721->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); bh1721->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); bh1721->timer.function = bh1721_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ bh1721->wq = create_singlethread_workqueue("bh1721_wq"); if (!bh1721->wq) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&bh1721->work_light, bh1721_work_func_light); /* allocate lightsensor-level input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); ret = -ENOMEM; goto err_input_allocate_device_light; } input_set_drvdata(input_dev, bh1721); input_dev->name = "lightsensor-level"; input_set_capability(input_dev, EV_ABS, ABS_MISC); input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_light; } bh1721->light_input_dev = input_dev; ret = sysfs_create_group(&input_dev->dev.kobj,&light_attribute_group); if (ret) { printk("Creating bh1721 attribute group failed"); goto error_device; } /* set sysfs for light sensor test mode*/ lightsensor_class = class_create(THIS_MODULE, "lightsensor"); if (IS_ERR(lightsensor_class)) { printk("Failed to create class(lightsensor)!\n"); goto error_device; } switch_cmd_dev = device_create(lightsensor_class, NULL, 0, NULL, "switch_cmd"); if (IS_ERR(switch_cmd_dev)) { printk("Failed to create device(switch_cmd_dev)!\n"); goto DESTROY_CLASS; } if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_state) < 0) { printk("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_state.attr.name); device_remove_file(switch_cmd_dev, &dev_attr_lightsensor_file_state); goto DESTROY_DEVICE; } if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_illuminance) < 0) { printk("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_illuminance.attr.name); device_remove_file(switch_cmd_dev, &dev_attr_lightsensor_file_illuminance); goto DESTROY_DEVICE; } if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_cmd) < 0) { printk("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_cmd.attr.name); goto DESTROY_DEVICE; } dev_set_drvdata(switch_cmd_dev, bh1721); printk("[%s]: Light Sensor probe complete.", __func__); goto done; /* error, unwind it all */ DESTROY_DEVICE: device_destroy(lightsensor_class,0); DESTROY_CLASS: class_destroy(lightsensor_class); error_device: sysfs_remove_group(&client->dev.kobj, &light_attribute_group); err_input_register_device_light: input_unregister_device(bh1721->light_input_dev); err_input_allocate_device_light: destroy_workqueue(bh1721->wq); err_create_workqueue: mutex_destroy(&bh1721->power_lock); kfree(bh1721); done: return ret; }