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; #ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_SWEEP2WAKE if (!strcmp(input_dev->name, "keypad_8960")) { sweep2wake_setdev(input_dev); printk(KERN_INFO "[sweep2wake]: set device %s\n", input_dev->name); } #endif #ifdef CONFIG_BMA250_WAKE_OPTIONS if (!strcmp(input_dev->name, "keypad_8960")) { flick2wake_setdev(input_dev); printk(KERN_INFO "[flick2wake]: set device %s\n", input_dev->name); } #endif } ip->input_devs->count = dev_count; ip->info = event_info; if (event_info->power) 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++; } 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) 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 long pn544_dev_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct pn544_dev *pn544_dev = filp->private_data; switch (cmd) { case PN544_SET_PWR: if (arg == 2) { /* power on with firmware download (requires hw reset) */ dprintk(PN544_DRV_NAME ":%s power on with firmware\n", __func__); gpio_set_value(pn544_dev->ven_gpio, 1); gpio_set_value(pn544_dev->firm_gpio, 1); msleep(10); gpio_set_value(pn544_dev->ven_gpio, 0); msleep(10); gpio_set_value(pn544_dev->ven_gpio, 1); msleep(10); } else if (arg == 1) { /* power on */ dprintk(PN544_DRV_NAME ":%s power on\n", __func__); gpio_set_value(pn544_dev->firm_gpio, 0); gpio_set_value(pn544_dev->ven_gpio, 1); msleep(10); #ifdef CONFIG_LGE_NFC_SET_IRQ_WAKEUP if (sIrqState == false) { irq_set_irq_wake(pn544_dev->client->irq,1); sIrqState = true; dprintk(PN544_DRV_NAME ":%s enable IRQ\n", __func__); } else { pr_err("%s IRQ is already enabled!\n", __func__); } #endif } else if (arg == 0) { /* power off */ dprintk(PN544_DRV_NAME ":%s power off\n", __func__); gpio_set_value(pn544_dev->firm_gpio, 0); gpio_set_value(pn544_dev->ven_gpio, 0); msleep(10); #ifdef CONFIG_LGE_NFC_SET_IRQ_WAKEUP if (sIrqState == true) { irq_set_irq_wake(pn544_dev->client->irq,0); sIrqState = false; dprintk(PN544_DRV_NAME ":%s disable IRQ\n", __func__); } else { pr_err("%s IRQ is already disabled!\n", __func__); } #endif #ifdef LGE_NFC_READ_IRQ_MODIFY } else if (arg == 3) {//DY_TEST dprintk("%s Read Cancle\n", __func__); cancle_read = true; do_reading = 1; wake_up(&pn544_dev->read_wq); #endif } else { pr_err("%s bad arg %ld\n", __func__, arg); return -EINVAL; } break; case PN544_INTERRUPT_CMD: { /* pn544_disable_irq = level; */ dprintk(PN544_DRV_NAME ":ioctl: pn544_interrupt enable level:%ld\n", arg); break; } case PN544_READ_POLLING_CMD: { stReadIntFlag = arg; dprintk(PN544_DRV_NAME ":ioctl: pn544_polling flag set:%ld\n", arg); break; } case PN544_HW_REVISION: { return pn544_get_hw_revision(); } default: pr_err("%s bad ioctl %d\n", __func__, cmd); return -EINVAL; } return 0; }
static int pn544_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct pn544_i2c_platform_data *platform_data; struct pn544_dev *pn544_dev; platform_data = client->dev.platform_data; if (platform_data == NULL) { pr_err("%s : nfc probe fail\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } ret = gpio_request(platform_data->irq_gpio, "nfc_int"); if (ret) return -ENODEV; ret = gpio_request(platform_data->ven_gpio, "nfc_ven"); if (ret) goto err_ven; if (platform_data->firm_gpio) { ret = gpio_request(platform_data->firm_gpio, "nfc_firm"); if (ret) goto err_firm; } 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; } pn544_dev->irq_gpio = platform_data->irq_gpio; pn544_dev->ven_gpio = platform_data->ven_gpio; pn544_dev->firm_gpio = platform_data->firm_gpio; pn544_dev->client = client; ret = gpio_direction_input(pn544_dev->irq_gpio); if (ret < 0) { pr_err("%s :not able to set irq_gpio as input\n", __func__); goto err_ven; } ret = gpio_direction_output(pn544_dev->ven_gpio, 0); if (ret < 0) { pr_err("%s : not able to set ven_gpio as output\n", __func__); goto err_firm; } if (platform_data->firm_gpio) { ret = gpio_direction_output(pn544_dev->firm_gpio, 0); if (ret < 0) { pr_err("%s : not able to set firm_gpio as output\n", __func__); goto err_exit; } } /* init mutex and queues */ init_waitqueue_head(&pn544_dev->read_wq); mutex_init(&pn544_dev->read_mutex); mutex_init(&pn544_dev->shutdown_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; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%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; } pn544_disable_irq(pn544_dev); i2c_set_clientdata(client, pn544_dev); return 0; err_request_irq_failed: misc_deregister(&pn544_dev->pn544_device); err_misc_register: mutex_destroy(&pn544_dev->read_mutex); mutex_destroy(&pn544_dev->shutdown_mutex); kfree(pn544_dev); err_exit: if (pn544_dev->firm_gpio) gpio_free(platform_data->firm_gpio); err_firm: gpio_free(platform_data->ven_gpio); err_ven: gpio_free(platform_data->irq_gpio); return ret; }
static int mdss_dsi_regulator_init(struct platform_device *pdev) { int ret = 0; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; struct dsi_drv_cm_data *dsi_drv = NULL; #ifdef CONFIG_MACH_LGE struct device_node *node = pdev->dev.of_node; #endif if (!pdev) { pr_err("%s: invalid input\n", __func__); return -EINVAL; } ctrl_pdata = platform_get_drvdata(pdev); if (!ctrl_pdata) { pr_err("%s: invalid driver data\n", __func__); return -EINVAL; } dsi_drv = &(ctrl_pdata->shared_pdata); if (ctrl_pdata->power_data.num_vreg > 0) { ret = msm_dss_config_vreg(&pdev->dev, ctrl_pdata->power_data.vreg_config, ctrl_pdata->power_data.num_vreg, 1); } else { #ifdef CONFIG_MACH_LGE /* if "lge,mdss-dsi-use-vdd-supply" property is not exist, we * assume that it is used in board. if don't want vdd-supply, * please use "lge,mdss-dsi-use-vdd-supply=<0>" in your dtsi. */ ret = of_property_read_u32(node, "lge,mdss-dsi-use-vdd-supply", &mdss_dsi_use_vdd_supply); if (ret == -EINVAL) mdss_dsi_use_vdd_supply = 1; if (mdss_dsi_use_vdd_supply) { dsi_drv->vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(dsi_drv->vdd_vreg)) { pr_err("%s: could not get vdd vreg, rc = %ld\n", __func__, PTR_ERR(dsi_drv->vdd_vreg)); return -ENODEV; } ret = regulator_set_voltage(dsi_drv->vdd_vreg, 3000000, 3000000); if (ret) { pr_err("%s: set voltage failed on vdd vreg, rc=%d\n", __func__, ret); return -EINVAL; } } #else dsi_drv->vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(dsi_drv->vdd_vreg)) { pr_err("%s: could not get vdda vreg, rc=%ld\n", __func__, PTR_ERR(dsi_drv->vdd_vreg)); return PTR_ERR(dsi_drv->vdd_vreg); } ret = regulator_set_voltage(dsi_drv->vdd_vreg, 3000000, 3000000); if (ret) { pr_err("%s: set voltage failed on vdda vreg, rc=%d\n", __func__, ret); return ret; } #endif dsi_drv->vdd_io_vreg = devm_regulator_get(&pdev->dev, "vddio"); if (IS_ERR(dsi_drv->vdd_io_vreg)) { pr_err("%s: could not get vddio reg, rc=%ld\n", __func__, PTR_ERR(dsi_drv->vdd_io_vreg)); return PTR_ERR(dsi_drv->vdd_io_vreg); } ret = regulator_set_voltage(dsi_drv->vdd_io_vreg, 1800000, 1800000); if (ret) { pr_err("%s: set voltage failed on vddio vreg, rc=%d\n", __func__, ret); return ret; } dsi_drv->vdda_vreg = devm_regulator_get(&pdev->dev, "vdda"); if (IS_ERR(dsi_drv->vdda_vreg)) { pr_err("%s: could not get vdda vreg, rc=%ld\n", __func__, PTR_ERR(dsi_drv->vdda_vreg)); return PTR_ERR(dsi_drv->vdda_vreg); } ret = regulator_set_voltage(dsi_drv->vdda_vreg, 1200000, 1200000); if (ret) { pr_err("%s: set voltage failed on vdda vreg, rc=%d\n", __func__, ret); return ret; } } return 0; }
int mdss_dsi_on(struct mdss_panel_data *pdata) { int ret = 0; u32 clk_rate; struct mdss_panel_info *pinfo; struct mipi_panel_info *mipi; u32 hbp, hfp, vbp, vfp, hspw, vspw, width, height; u32 ystride, bpp, data, dst_bpp; u32 dummy_xres, dummy_yres; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; if (pdata == NULL) { pr_err("%s: Invalid input data\n", __func__); return -EINVAL; } if (pdata->panel_info.panel_power_on) { pr_warn("%s:%d Panel already on.\n", __func__, __LINE__); return 0; } ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata, panel_data); pr_info("%s+: ctrl=%p ndx=%d\n", __func__, ctrl_pdata, ctrl_pdata->ndx); pinfo = &pdata->panel_info; ret = mdss_dsi_panel_power_on(pdata, 1); if (ret) { pr_err("%s: Panel power on failed\n", __func__); return ret; } pdata->panel_info.panel_power_on = 1; ret = mdss_dsi_enable_bus_clocks(ctrl_pdata); if (ret) { pr_err("%s: failed to enable bus clocks. rc=%d\n", __func__, ret); mdss_dsi_panel_power_on(pdata, 0); return ret; } mdss_dsi_phy_sw_reset((ctrl_pdata->ctrl_base)); mdss_dsi_phy_init(pdata); mdss_dsi_disable_bus_clocks(ctrl_pdata); mdss_dsi_clk_ctrl(ctrl_pdata, 1); clk_rate = pdata->panel_info.clk_rate; clk_rate = min(clk_rate, pdata->panel_info.clk_max); dst_bpp = pdata->panel_info.fbc.enabled ? (pdata->panel_info.fbc.target_bpp) : (pinfo->bpp); hbp = mult_frac(pdata->panel_info.lcdc.h_back_porch, dst_bpp, pdata->panel_info.bpp); hfp = mult_frac(pdata->panel_info.lcdc.h_front_porch, dst_bpp, pdata->panel_info.bpp); vbp = mult_frac(pdata->panel_info.lcdc.v_back_porch, dst_bpp, pdata->panel_info.bpp); vfp = mult_frac(pdata->panel_info.lcdc.v_front_porch, dst_bpp, pdata->panel_info.bpp); hspw = mult_frac(pdata->panel_info.lcdc.h_pulse_width, dst_bpp, pdata->panel_info.bpp); vspw = pdata->panel_info.lcdc.v_pulse_width; width = mult_frac(pdata->panel_info.xres, dst_bpp, pdata->panel_info.bpp); #ifdef CONFIG_OLED_SUPPORT height = pdata->panel_info.yres + pdata->panel_info.lcdc.yres_margin; #else height = pdata->panel_info.yres; #endif mipi = &pdata->panel_info.mipi; if (pdata->panel_info.type == MIPI_VIDEO_PANEL) { dummy_xres = pdata->panel_info.lcdc.xres_pad; dummy_yres = pdata->panel_info.lcdc.yres_pad; MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x24, ((hspw + hbp + width + dummy_xres) << 16 | (hspw + hbp))); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x28, ((vspw + vbp + height + dummy_yres) << 16 | (vspw + vbp))); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x2C, (vspw + vbp + height + dummy_yres + vfp - 1) << 16 | (hspw + hbp + width + dummy_xres + hfp - 1)); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x30, (hspw << 16)); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x34, 0); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x38, (vspw << 16)); } else { /* command mode */ if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB888) bpp = 3; else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB666) bpp = 3; else if (mipi->dst_format == DSI_CMD_DST_FORMAT_RGB565) bpp = 2; else bpp = 3; /* Default format set to RGB888 */ ystride = width * bpp + 1; /* DSI_COMMAND_MODE_MDP_STREAM_CTRL */ data = (ystride << 16) | (mipi->vc << 8) | DTYPE_DCS_LWRITE; MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x60, data); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x58, data); /* DSI_COMMAND_MODE_MDP_STREAM_TOTAL */ data = height << 16 | width; MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x64, data); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0x5C, data); } mdss_dsi_sw_reset(pdata); mdss_dsi_host_init(mipi, pdata); if (mipi->force_clk_lane_hs) { u32 tmp; tmp = MIPI_INP((ctrl_pdata->ctrl_base) + 0xac); tmp |= (1<<28); MIPI_OUTP((ctrl_pdata->ctrl_base) + 0xac, tmp); wmb(); } #if defined(CONFIG_MACH_LGE) #if defined(CONFIG_OLED_SUPPORT) msleep(10); mdss_dsi_panel_reset(pdata, 1); msleep(20); #else /* LGE_CHANGE_S * power sequence for LGD_FHD panel * 2013-04-05, [email protected] */ #if defined (CONFIG_MACH_MSM8974_VU3_KR) msleep(40); #else msleep(1); #endif mdss_dsi_panel_reset(pdata, 1); #endif #endif if (pdata->panel_info.type == MIPI_CMD_PANEL) mdss_dsi_clk_ctrl(ctrl_pdata, 0); pr_debug("%s-:\n", __func__); return 0; }
static int __devinit mdss_dsi_ctrl_probe(struct platform_device *pdev) { int rc = 0; u32 index; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; if (pdev->dev.of_node) { struct resource *mdss_dsi_mres; const char *ctrl_name; ctrl_pdata = platform_get_drvdata(pdev); if (!ctrl_pdata) { ctrl_pdata = devm_kzalloc(&pdev->dev, sizeof(struct mdss_dsi_ctrl_pdata), GFP_KERNEL); if (!ctrl_pdata) { pr_err("%s: FAILED: cannot alloc dsi ctrl\n", __func__); rc = -ENOMEM; goto error_no_mem; } platform_set_drvdata(pdev, ctrl_pdata); } ctrl_name = of_get_property(pdev->dev.of_node, "label", NULL); if (!ctrl_name) pr_info("%s:%d, DSI Ctrl name not specified\n", __func__, __LINE__); else pr_info("%s: DSI Ctrl name = %s\n", __func__, ctrl_name); rc = of_property_read_u32(pdev->dev.of_node, "cell-index", &index); if (rc) { dev_err(&pdev->dev, "%s: Cell-index not specified, rc=%d\n", __func__, rc); goto error_no_mem; } if (index == 0) pdev->id = 1; else pdev->id = 2; mdss_dsi_mres = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mdss_dsi_mres) { pr_err("%s:%d unable to get the MDSS resources", __func__, __LINE__); rc = -ENOMEM; goto error_no_mem; } if (mdss_dsi_mres) { mdss_dsi_base = ioremap(mdss_dsi_mres->start, resource_size(mdss_dsi_mres)); if (!mdss_dsi_base) { pr_err("%s:%d unable to remap dsi resources", __func__, __LINE__); rc = -ENOMEM; goto error_no_mem; } } rc = of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev); if (rc) { dev_err(&pdev->dev, "%s: failed to add child nodes, rc=%d\n", __func__, rc); goto error_ioremap; } /* Parse the regulator information */ rc = mdss_dsi_get_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data); if (rc) { pr_err("%s: failed to get vreg data from dt. rc=%d\n", __func__, rc); goto error_vreg; } pr_debug("%s: Dsi Ctrl->%d initialized\n", __func__, index); } return 0; error_ioremap: iounmap(mdss_dsi_base); error_no_mem: devm_kfree(&pdev->dev, ctrl_pdata); error_vreg: mdss_dsi_put_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data); return rc; }
int mdss_dsi_panel_power_on(struct mdss_panel_data *pdata, int enable) { int ret; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; if (pdata == NULL) { pr_err("%s: Invalid input data\n", __func__); return -EINVAL; } ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata, panel_data); pr_debug("%s: enable=%d\n", __func__, enable); // Z OLED power on start if (enable) { if (ctrl_pdata->power_data.num_vreg > 0) { ret = msm_dss_enable_vreg( ctrl_pdata->power_data.vreg_config, ctrl_pdata->power_data.num_vreg, 1); if (ret) { pr_err("%s:Failed to enable regulators.rc=%d\n", __func__, ret); return ret; } /* * A small delay is needed here after enabling * all regulators and before issuing panel reset */ msleep(20); } else { ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_io_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_io_vreg set opt mode failed.\n", __func__); return ret; } ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdda_vreg, 100000); if (ret < 0) { pr_err("%s: vdda_vreg set opt mode failed.\n", __func__); return ret; } if (gpio_is_valid(ctrl_pdata->disp_en_gpio)){ gpio_set_value((ctrl_pdata->disp_en_gpio), 1); msleep(1); } else pr_err("%s:%d, disp_en_gpio is not valid\n", __func__, __LINE__); ret = regulator_enable( (ctrl_pdata->shared_pdata).vdd_io_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } ret = regulator_enable( (ctrl_pdata->shared_pdata).vdda_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } msleep(10); } // Z OLED power off start } else { msleep(20); mdss_dsi_panel_reset(pdata, 0); msleep(20); if (ctrl_pdata->power_data.num_vreg > 0) { ret = msm_dss_enable_vreg( ctrl_pdata->power_data.vreg_config, ctrl_pdata->power_data.num_vreg, 0); if (ret) { pr_err("%s: Failed to disable regs.rc=%d\n", __func__, ret); return ret; } } else { ret = regulator_disable( (ctrl_pdata->shared_pdata).vdda_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } #if 0 ret = regulator_disable( (ctrl_pdata->shared_pdata).vdd_io_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } #endif if (gpio_is_valid(ctrl_pdata->disp_en_gpio)){ gpio_set_value((ctrl_pdata->disp_en_gpio), 0); msleep(1); } else pr_err("%s:%d, disp_en_gpio is not valid\n", __func__, __LINE__); ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_io_vreg, 100); if (ret < 0) { pr_err("%s: vdd_io_vreg set opt mode failed.\n", __func__); return ret; } ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdda_vreg, 100); if (ret < 0) { pr_err("%s: vdda_vreg set opt mode failed.\n", __func__); return ret; } } } pr_info("[Zee][OLED] mdss_dsi_panel_power %s\n", enable ? "on" : "off"); return 0; }
static int soc_compr_open_fe(struct snd_compr_stream *cstream) { struct snd_soc_pcm_runtime *fe = cstream->private_data; struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream; struct snd_soc_platform *platform = fe->platform; struct snd_soc_dpcm *dpcm; struct snd_soc_dapm_widget_list *list; int stream; int ret = 0; if (cstream->direction == SND_COMPRESS_PLAYBACK) stream = SNDRV_PCM_STREAM_PLAYBACK; else stream = SNDRV_PCM_STREAM_CAPTURE; mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME); if (platform->driver->compr_ops && platform->driver->compr_ops->open) { ret = platform->driver->compr_ops->open(cstream); if (ret < 0) { pr_err("compress asoc: can't open platform %s\n", platform->component.name); goto out; } } if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) { ret = fe->dai_link->compr_ops->startup(cstream); if (ret < 0) { pr_err("compress asoc: %s startup failed\n", fe->dai_link->name); goto machine_err; } } fe->dpcm[stream].runtime = fe_substream->runtime; ret = dpcm_path_get(fe, stream, &list); if (ret < 0) goto fe_err; else if (ret == 0) dev_dbg(fe->dev, "ASoC: %s no valid %s route\n", fe->dai_link->name, stream ? "capture" : "playback"); /* calculate valid and active FE <-> BE dpcms */ dpcm_process_paths(fe, stream, &list, 1); fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE; ret = dpcm_be_dai_startup(fe, stream); if (ret < 0) { /* clean up all links */ list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE; dpcm_be_disconnect(fe, stream); fe->dpcm[stream].runtime = NULL; goto fe_err; } dpcm_clear_pending_state(fe, stream); dpcm_path_put(&list); fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN; fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; snd_soc_runtime_activate(fe, stream); mutex_unlock(&fe->card->mutex); return 0; fe_err: if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown) fe->dai_link->compr_ops->shutdown(cstream); machine_err: if (platform->driver->compr_ops && platform->driver->compr_ops->free) platform->driver->compr_ops->free(cstream); out: fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO; mutex_unlock(&fe->card->mutex); return ret; }
int mdp4_dsi_video_pipe_commit(int cndx, int wait) { int i, undx; int mixer = 0; struct vsycn_ctrl *vctrl; struct vsync_update *vp; struct mdp4_overlay_pipe *pipe; struct mdp4_overlay_pipe *real_pipe; unsigned long flags; int cnt = 0; vctrl = &vsync_ctrl_db[cndx]; mutex_lock(&vctrl->update_lock); undx = vctrl->update_ndx; vp = &vctrl->vlist[undx]; pipe = vctrl->base_pipe; if (pipe == NULL) { pr_err("%s: NO base pipe\n", __func__); mutex_unlock(&vctrl->update_lock); return 0; } mixer = pipe->mixer_num; mdp_update_pm(vctrl->mfd, vctrl->vsync_time); /* * allow stage_commit without pipes queued * (vp->update_cnt == 0) to unstage pipes after * overlay_unset */ vctrl->update_ndx++; vctrl->update_ndx &= 0x01; vp->update_cnt = 0; /* reset */ if (vctrl->blt_free) { vctrl->blt_free--; if (vctrl->blt_free == 0) mdp4_free_writeback_buf(vctrl->mfd, mixer); } mutex_unlock(&vctrl->update_lock); spin_lock_irqsave(&vctrl->spin_lock, flags); if (vctrl->ov_koff != vctrl->ov_done) { spin_unlock_irqrestore(&vctrl->spin_lock, flags); pr_err("%s: Error, frame dropped %d %d\n", __func__, vctrl->ov_koff, vctrl->ov_done); return 0; } spin_unlock_irqrestore(&vctrl->spin_lock, flags); if (vctrl->blt_change) { pipe = vctrl->base_pipe; spin_lock_irqsave(&vctrl->spin_lock, flags); INIT_COMPLETION(vctrl->dmap_comp); INIT_COMPLETION(vctrl->ov_comp); vsync_irq_enable(INTR_DMA_P_DONE, MDP_DMAP_TERM); spin_unlock_irqrestore(&vctrl->spin_lock, flags); mdp4_dsi_video_wait4dmap(0); if (pipe->ov_blt_addr) mdp4_dsi_video_wait4ov(0); } pipe = vp->plist; for (i = 0; i < OVERLAY_PIPE_MAX; i++, pipe++) { if (pipe->pipe_used) { cnt++; real_pipe = mdp4_overlay_ndx2pipe(pipe->pipe_ndx); if (real_pipe && real_pipe->pipe_used) { /* * commit pipes which are in pending queue * and not be unset yet */ mdp4_overlay_vsync_commit(pipe); } } } mdp4_mixer_stage_commit(mixer); /* start timing generator & mmu if they are not started yet */ mdp4_overlay_dsi_video_start(); /* * there has possibility that pipe commit come very close to next vsync * this may cause two consecutive pie_commits happen within same vsync * period which casue iommu page fault when previous iommu buffer * freed. Set ION_IOMMU_UNMAP_DELAYED flag at ion_map_iommu() to * add delay unmap iommu buffer to fix this problem. * Also ion_unmap_iommu() may take as long as 9 ms to free an ion buffer. * therefore mdp4_overlay_iommu_unmap_freelist(mixer) should be called * ater stage_commit() to ensure pipe_commit (up to stage_commit) * is completed within vsync period. */ /* free previous committed iommu back to pool */ mdp4_overlay_iommu_unmap_freelist(mixer); pipe = vp->plist; for (i = 0; i < OVERLAY_PIPE_MAX; i++, pipe++) { if (pipe->pipe_used) { /* free previous iommu to freelist * which will be freed at next * pipe_commit */ mdp4_overlay_iommu_pipe_free(pipe->pipe_ndx, 0); pipe->pipe_used = 0; /* clear */ } } pipe = vctrl->base_pipe; spin_lock_irqsave(&vctrl->spin_lock, flags); if (pipe->ov_blt_addr) { mdp4_dsi_video_blt_ov_update(pipe); pipe->ov_cnt++; INIT_COMPLETION(vctrl->ov_comp); vsync_irq_enable(INTR_OVERLAY0_DONE, MDP_OVERLAY0_TERM); mb(); vctrl->ov_koff++; /* kickoff overlay engine */ mdp4_stat.kickoff_ov0++; outpdw(MDP_BASE + 0x0004, 0); } else { /* schedule second phase update at dmap */ INIT_COMPLETION(vctrl->dmap_comp); vsync_irq_enable(INTR_DMA_P_DONE, MDP_DMAP_TERM); } spin_unlock_irqrestore(&vctrl->spin_lock, flags); mdp4_stat.overlay_commit[pipe->mixer_num]++; if (wait) { if (pipe->ov_blt_addr) mdp4_dsi_video_wait4ov(0); else mdp4_dsi_video_wait4dmap(0); } return cnt; }
static int32_t s5k5b3g_power_up(struct msm_sensor_ctrl_t *s_ctrl) { int32_t rc; struct device *dev = &s_ctrl->sensor_i2c_client->client->dev; struct msm_camera_sensor_info *info = s_ctrl->sensordata; if (!info->oem_data) { pr_err("%s: oem data NULL in sensor info, aborting", __func__); rc = -EINVAL; goto power_up_done; } pr_debug("%s: R: %d, A: %d D: %d D_On %d MIPI %d\n", __func__, info->sensor_reset, info->oem_data->sensor_avdd_en, info->oem_data->sensor_dig_en, info->oem_data->sensor_vdig_on_always, info->oem_data->sensor_using_shared_mipi); /* Request gpios */ rc = gpio_request(info->oem_data->sensor_avdd_en, "s5k5b3g"); if (rc < 0) { pr_err("%s: gpio request sensor_avdd_en failed (%d)\n", __func__, rc); goto power_up_done; } rc = gpio_request(info->sensor_reset, "s5k5b3g"); if (rc < 0) { pr_err("%s: gpio request sensor_reset failed (%d)\n", __func__, rc); goto abort0; } rc = gpio_request(info->oem_data->sensor_dig_en, "s5k5b3g"); if (rc < 0) { pr_err("%s: gpio request sensor_dig_en failed (%d)\n", __func__, rc); goto abort1; } /* Set reset low */ gpio_direction_output(info->sensor_reset, 0); /* Enable supplies */ rc = s5k5b3g_regulator_on(&cam_vio, dev, "cam_vio", 0); if (rc < 0) goto abort2; if (info->oem_data->sensor_vdig_on_always == 0) { rc = s5k5b3g_regulator_on(&cam_vdig, dev, "cam_vdig", 1200000); if (rc < 0) { pr_err("%s: cam_vdig is unable to turn on (%d)\n", __func__, rc); goto abort2; } } if (info->oem_data->sensor_using_shared_mipi) { rc = s5k5b3g_regulator_on(&cam_mipi_mux, dev, "cam_mipi_mux", 2800000); if (rc < 0) { pr_err("%s: cam_mipi_mux is unable to turn on (%d)\n", __func__, rc); goto abort2; } } /* Wait for core supplies to power up */ usleep_range(10000, 15000); /* Set dig_en high */ gpio_direction_output(info->oem_data->sensor_dig_en, 1); /*Enable MCLK*/ cam_mot_8960_clk_info->clk_rate = s_ctrl->clk_rate; rc = msm_cam_clk_enable(dev, cam_mot_8960_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(cam_mot_8960_clk_info), 1); if (rc < 0) { pr_err("%s: msm_cam_clk_enable failed (%d)\n", __func__, rc); goto abort2; } /* Set avdd_en high */ gpio_direction_output(info->oem_data->sensor_avdd_en, 1); usleep_range(1000, 2000); /* Set reset high */ gpio_direction_output(info->sensor_reset, 1); usleep_range(1000, 2000); goto power_up_done; /* Cleanup, ignore errors during abort */ abort2: gpio_free(info->oem_data->sensor_dig_en); abort1: gpio_free(info->sensor_reset); abort0: gpio_free(info->oem_data->sensor_avdd_en); s5k5b3g_regulator_off(&cam_vio, NULL); if (info->oem_data->sensor_vdig_on_always == 0) s5k5b3g_regulator_off(&cam_vdig, NULL); if (info->oem_data->sensor_using_shared_mipi) s5k5b3g_regulator_off(&cam_mipi_mux, NULL); power_up_done: return rc; }
/* create a new compress */ int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) { struct snd_soc_codec *codec = rtd->codec; struct snd_soc_platform *platform = rtd->platform; struct snd_soc_dai *codec_dai = rtd->codec_dai; struct snd_soc_dai *cpu_dai = rtd->cpu_dai; struct snd_compr *compr; struct snd_pcm *be_pcm; char new_name[64]; int ret = 0, direction = 0; if (rtd->num_codecs > 1) { dev_err(rtd->card->dev, "Multicodec not supported for compressed stream\n"); return -EINVAL; } /* check client and interface hw capabilities */ snprintf(new_name, sizeof(new_name), "%s %s-%d", rtd->dai_link->stream_name, codec_dai->name, num); if (codec_dai->driver->playback.channels_min) direction = SND_COMPRESS_PLAYBACK; else if (codec_dai->driver->capture.channels_min) direction = SND_COMPRESS_CAPTURE; else return -EINVAL; compr = kzalloc(sizeof(*compr), GFP_KERNEL); if (compr == NULL) { snd_printk(KERN_ERR "Cannot allocate compr\n"); return -ENOMEM; } compr->ops = devm_kzalloc(rtd->card->dev, sizeof(soc_compr_ops), GFP_KERNEL); if (compr->ops == NULL) { dev_err(rtd->card->dev, "Cannot allocate compressed ops\n"); ret = -ENOMEM; goto compr_err; } if (rtd->dai_link->dynamic) { snprintf(new_name, sizeof(new_name), "(%s)", rtd->dai_link->stream_name); ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num, rtd->dai_link->dpcm_playback, rtd->dai_link->dpcm_capture, &be_pcm); if (ret < 0) { dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n", rtd->dai_link->name); goto compr_err; } rtd->pcm = be_pcm; rtd->fe_compr = 1; if (rtd->dai_link->dpcm_playback) be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd; else if (rtd->dai_link->dpcm_capture) be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd; memcpy(compr->ops, &soc_compr_dyn_ops, sizeof(soc_compr_dyn_ops)); } else memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops)); /* Add copy callback for not memory mapped DSPs */ if (platform->driver->compr_ops && platform->driver->compr_ops->copy) compr->ops->copy = soc_compr_copy; mutex_init(&compr->lock); ret = snd_compress_new(rtd->card->snd_card, num, direction, compr); if (ret < 0) { pr_err("compress asoc: can't create compress for codec %s\n", codec->component.name); goto compr_err; } /* DAPM dai link stream work */ INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); rtd->compr = compr; compr->private_data = rtd; printk(KERN_INFO "compress asoc: %s <-> %s mapping ok\n", codec_dai->name, cpu_dai->name); return ret; compr_err: kfree(compr); return ret; }
/* * Set an SMPS regulator to be disabled in its CTRL register, but enabled * in the master enable register. Also set it's pull down enable bit. * Take care to make sure that the output voltage doesn't change if switching * from advanced mode to legacy mode. */ static int disable_smps_locally_set_pull_down(u16 ctrl_addr, u16 test2_addr, u16 master_enable_addr, u8 master_enable_bit) { int rc = 0; u8 vref_sel, vlow_sel, band, vprog, bank, reg; if (pmic_chip == NULL) return -ENODEV; bank = REGULATOR_BANK_SEL(7); rc = ssbi_write(pmic_chip->dev, test2_addr, &bank, 1); if (rc) { pr_err("%s: FAIL ssbi_write(0x%03X): rc=%d\n", __func__, test2_addr, rc); goto done; } rc = ssbi_read(pmic_chip->dev, test2_addr, ®, 1); if (rc) { pr_err("%s: FAIL pm8058_read(0x%03X): rc=%d\n", __func__, test2_addr, rc); goto done; } /* Check if in advanced mode. */ if ((reg & SMPS_ADVANCED_MODE_MASK) == SMPS_ADVANCED_MODE) { /* Determine current output voltage. */ rc = ssbi_read(pmic_chip->dev, ctrl_addr, ®, 1); if (rc) { pr_err("%s: FAIL pm8058_read(0x%03X): rc=%d\n", __func__, ctrl_addr, rc); goto done; } band = (reg & SMPS_ADVANCED_BAND_MASK) >> SMPS_ADVANCED_BAND_SHIFT; switch (band) { case 3: vref_sel = 0; vlow_sel = 0; break; case 2: vref_sel = SMPS_LEGACY_VREF_SEL; vlow_sel = 0; break; case 1: vref_sel = SMPS_LEGACY_VREF_SEL; vlow_sel = SMPS_LEGACY_VLOW_SEL; break; default: pr_err("%s: regulator already disabled\n", __func__); return -EPERM; } vprog = (reg & SMPS_ADVANCED_VPROG_MASK); /* Round up if fine step is in use. */ vprog = (vprog + 1) >> 1; if (vprog > SMPS_LEGACY_VPROG_MASK) vprog = SMPS_LEGACY_VPROG_MASK; /* Set VLOW_SEL bit. */ bank = REGULATOR_BANK_SEL(1); rc = ssbi_write(pmic_chip->dev, test2_addr, &bank, 1); if (rc) { pr_err("%s: FAIL ssbi_write(0x%03X): rc=%d\n", __func__, test2_addr, rc); goto done; } rc = pm8058_masked_write(test2_addr, REGULATOR_BANK_WRITE | REGULATOR_BANK_SEL(1) | vlow_sel, REGULATOR_BANK_WRITE | REGULATOR_BANK_MASK | SMPS_LEGACY_VLOW_SEL); if (rc) goto done; /* Switch to legacy mode */ bank = REGULATOR_BANK_SEL(7); rc = ssbi_write(pmic_chip->dev, test2_addr, &bank, 1); if (rc) { pr_err("%s: FAIL ssbi_write(0x%03X): rc=%d\n", __func__, test2_addr, rc); goto done; } rc = pm8058_masked_write(test2_addr, REGULATOR_BANK_WRITE | REGULATOR_BANK_SEL(7) | SMPS_LEGACY_MODE, REGULATOR_BANK_WRITE | REGULATOR_BANK_MASK | SMPS_ADVANCED_MODE_MASK); if (rc) goto done; /* Enable locally, enable pull down, keep voltage the same. */ rc = pm8058_masked_write(ctrl_addr, REGULATOR_ENABLE | REGULATOR_PULL_DOWN_EN | vref_sel | vprog, REGULATOR_ENABLE_MASK | REGULATOR_PULL_DOWN_MASK | SMPS_LEGACY_VREF_SEL | SMPS_LEGACY_VPROG_MASK); if (rc) goto done; }
static int __devinit fsa9485_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct fsa9485_usbsw *usbsw; int ret = 0; struct input_dev *input; struct device *switch_dev; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; input = input_allocate_device(); usbsw = kzalloc(sizeof(struct fsa9485_usbsw), GFP_KERNEL); if (!usbsw || !input) { dev_err(&client->dev, "failed to allocate driver data\n"); kfree(usbsw); return -ENOMEM; } usbsw->input = input; input->name = client->name; input->phys = "deskdock-key/input0"; input->dev.parent = &client->dev; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0001; /* Enable auto repeat feature of Linux input subsystem */ __set_bit(EV_REP, input->evbit); input_set_capability(input, EV_KEY, KEY_VOLUMEUP); input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN); input_set_capability(input, EV_KEY, KEY_PLAYPAUSE); input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG); input_set_capability(input, EV_KEY, KEY_NEXTSONG); ret = input_register_device(input); if (ret) { dev_err(&client->dev, "input_register_device %s: err %d\n", __func__, ret); input_free_device(input); kfree(usbsw); return ret; } usbsw->client = client; usbsw->pdata = client->dev.platform_data; if (!usbsw->pdata) goto fail1; i2c_set_clientdata(client, usbsw); mutex_init(&usbsw->mutex); local_usbsw = usbsw; if (usbsw->pdata->cfg_gpio) usbsw->pdata->cfg_gpio(); fsa9485_reg_init(usbsw); uart_connecting = 0; ret = sysfs_create_group(&client->dev.kobj, &fsa9485_group); if (ret) { dev_err(&client->dev, "failed to create fsa9485 attribute group\n"); goto fail2; } /* make sysfs node /sys/class/sec/switch/usb_state */ switch_dev = device_create(sec_class, NULL, 0, NULL, "switch"); if (IS_ERR(switch_dev)) { pr_err("[FSA9485] Failed to create device (switch_dev)!\n"); ret = PTR_ERR(switch_dev); goto fail2; } ret = device_create_file(switch_dev, &dev_attr_usb_state); if (ret < 0) { pr_err("[FSA9485] Failed to create file (usb_state)!\n"); goto err_create_file_state; } ret = device_create_file(switch_dev, &dev_attr_adc); if (ret < 0) { pr_err("[FSA9485] Failed to create file (adc)!\n"); goto err_create_file_adc; } ret = device_create_file(switch_dev, &dev_attr_reset_switch); if (ret < 0) { pr_err("[FSA9485] Failed to create file (reset_switch)!\n"); goto err_create_file_reset_switch; } dev_set_drvdata(switch_dev, usbsw); /* fsa9485 dock init*/ if (usbsw->pdata->dock_init) usbsw->pdata->dock_init(); /* fsa9485 reset */ if (usbsw->pdata->reset_cb) usbsw->pdata->reset_cb(); /* set fsa9485 init flag. */ if (usbsw->pdata->set_init_flag) usbsw->pdata->set_init_flag(); /* initial cable detection */ INIT_DELAYED_WORK(&usbsw->init_work, fsa9485_init_detect); schedule_delayed_work(&usbsw->init_work, msecs_to_jiffies(2700)); return 0; err_create_file_reset_switch: device_remove_file(switch_dev, &dev_attr_reset_switch); err_create_file_adc: device_remove_file(switch_dev, &dev_attr_adc); err_create_file_state: device_remove_file(switch_dev, &dev_attr_usb_state); fail2: if (client->irq) free_irq(client->irq, usbsw); fail1: input_unregister_device(input); mutex_destroy(&usbsw->mutex); kfree(usbsw); return ret; }
/** * read_eeprom_memory() - read map data into buffer * @e_ctrl: eeprom control struct * @block: block to be read * * This function iterates through blocks stored in block->map, reads each * region and concatenate them into the pre-allocated block->mapdata */ static int read_eeprom_memory(struct msm_eeprom_ctrl_t *e_ctrl, struct msm_eeprom_memory_block_t *block) { int rc = 0; int j; struct msm_eeprom_memory_map_t *emap = block->map; struct msm_eeprom_board_info *eb_info; uint8_t *memptr = block->mapdata; if (!e_ctrl) { pr_err("%s e_ctrl is NULL", __func__); return -EINVAL; } eb_info = e_ctrl->eboard_info; for (j = 0; j < block->num_map; j++) { if (emap[j].saddr.addr) { eb_info->i2c_slaveaddr = emap[j].saddr.addr; e_ctrl->i2c_client.cci_client->sid = eb_info->i2c_slaveaddr >> 1; pr_err("qcom,slave-addr = 0x%X\n", eb_info->i2c_slaveaddr); } if (emap[j].page.valid_size) { e_ctrl->i2c_client.addr_type = emap[j].page.addr_t; rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_write( &(e_ctrl->i2c_client), emap[j].page.addr, emap[j].page.data, emap[j].page.data_t); msleep(emap[j].page.delay); if (rc < 0) { pr_err("%s: page write failed\n", __func__); return rc; } } if (emap[j].pageen.valid_size) { e_ctrl->i2c_client.addr_type = emap[j].pageen.addr_t; rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_write( &(e_ctrl->i2c_client), emap[j].pageen.addr, emap[j].pageen.data, emap[j].pageen.data_t); msleep(emap[j].pageen.delay); if (rc < 0) { pr_err("%s: page enable failed\n", __func__); return rc; } } if (emap[j].poll.valid_size) { e_ctrl->i2c_client.addr_type = emap[j].poll.addr_t; rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_poll( &(e_ctrl->i2c_client), emap[j].poll.addr, emap[j].poll.data, emap[j].poll.data_t); msleep(emap[j].poll.delay); if (rc < 0) { pr_err("%s: poll failed\n", __func__); return rc; } } if (emap[j].mem.valid_size) { e_ctrl->i2c_client.addr_type = emap[j].mem.addr_t; rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_read_seq( &(e_ctrl->i2c_client), emap[j].mem.addr, memptr, emap[j].mem.valid_size); if (rc < 0) { pr_err("%s: read failed\n", __func__); return rc; } memptr += emap[j].mem.valid_size; } if (emap[j].pageen.valid_size) { e_ctrl->i2c_client.addr_type = emap[j].pageen.addr_t; rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_write( &(e_ctrl->i2c_client), emap[j].pageen.addr, 0, emap[j].pageen.data_t); if (rc < 0) { pr_err("%s: page disable failed\n", __func__); return rc; } } }
static int ssp_probe(struct spi_device *spi_dev) { int iRet = 0; struct ssp_data *data; struct ssp_platform_data *pdata; if (poweroff_charging == 1 || recovery_mode == 1) { pr_err("[SSP] probe exit : lpm %d recovery %d \n", poweroff_charging, recovery_mode); return -ENODEV; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) { pr_err("[SSP]: %s - failed to allocate memory for data\n", __func__); iRet = -ENOMEM; goto exit; } if (spi_dev->dev.of_node) { iRet = ssp_parse_dt(&spi_dev->dev, data); if (iRet) { pr_err("[SSP]: %s - Failed to parse DT\n", __func__); goto err_setup; } data->ssp_changes = SSP_MCU_L5; /* K330, MPU L5*/ } else { pdata = spi_dev->dev.platform_data; if (pdata == NULL) { pr_err("[SSP]: %s - platform_data is null\n", __func__); iRet = -ENOMEM; goto err_setup; } data->wakeup_mcu = pdata->wakeup_mcu; data->check_mcu_ready = pdata->check_mcu_ready; data->check_mcu_busy = pdata->check_mcu_busy; data->set_mcu_reset = pdata->set_mcu_reset; data->read_chg = pdata->read_chg; /* AP system_rev */ if (pdata->check_ap_rev) data->ap_rev = pdata->check_ap_rev(); else data->ap_rev = 0; /* For changed devices */ if (pdata->check_changes) data->ssp_changes = pdata->check_changes(); else data->ssp_changes = SSP_MCU_L5; /* K330, MPU L5*/ /* Get sensor positions */ if (pdata->get_positions) pdata->get_positions(&data->accel_position, &data->mag_position); else if (spi_dev->dev.of_node == NULL) { data->accel_position = 0; data->mag_position = 0; } } spi_dev->mode = SPI_MODE_1; if (spi_setup(spi_dev)) { pr_err("failed to setup spi for ssp_spi\n"); goto err_setup; } data->bProbeIsDone = false; data->fw_dl_state = FW_DL_STATE_NONE; data->spi = spi_dev; spi_set_drvdata(spi_dev, data); #ifdef CONFIG_SENSORS_SSP_SHTC1 mutex_init(&data->cp_temp_adc_lock); mutex_init(&data->bulk_temp_read_lock); #endif #ifdef CONFIG_SENSORS_SSP_STM mutex_init(&data->comm_mutex); mutex_init(&data->pending_mutex); #endif if (((data->wakeup_mcu == NULL) || (data->check_mcu_ready == NULL) || (data->check_mcu_busy == NULL) || (data->set_mcu_reset == NULL) || (data->read_chg == NULL)) && (spi_dev->dev.of_node == NULL)) { pr_err("[SSP]: %s - function callback is null\n", __func__); iRet = -EIO; goto err_reset_null; } pr_info("\n#####################################################\n"); INIT_DELAYED_WORK(&data->work_firmware, work_function_firmware_update); wake_lock_init(&data->ssp_wake_lock, WAKE_LOCK_SUSPEND, "ssp_wake_lock"); iRet = initialize_input_dev(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create input device\n", __func__); goto err_input_register_device; } iRet = initialize_debug_timer(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create workqueue\n", __func__); goto err_create_workqueue; } iRet = initialize_irq(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create irq\n", __func__); goto err_setup_irq; } iRet = initialize_sysfs(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create sysfs\n", __func__); goto err_sysfs_create; } iRet = initialize_event_symlink(data); if (iRet < 0) { pr_err("[SSP]: %s - could not create symlink\n", __func__); goto err_symlink_create; } initialize_variable(data); ssp_enable(data, true); /* check boot loader binary */ data->fw_dl_state = check_fwbl(data); if (data->fw_dl_state == FW_DL_STATE_NONE) { iRet = initialize_mcu(data); if (iRet == ERROR) { data->uResetCnt++; toggle_mcu_reset(data); msleep(SSP_SW_RESET_TIME); initialize_mcu(data); } else if (iRet < ERROR) { pr_err("[SSP]: %s - initialize_mcu failed\n", __func__); goto err_read_reg; } } #ifdef CONFIG_HAS_EARLYSUSPEND data->early_suspend.suspend = ssp_early_suspend; data->early_suspend.resume = ssp_late_resume; register_early_suspend(&data->early_suspend); #endif #ifdef CONFIG_SENSORS_SSP_SENSORHUB /* init sensorhub device */ iRet = ssp_sensorhub_initialize(data); if (iRet < 0) { pr_err("%s: ssp_sensorhub_initialize err(%d)", __func__, iRet); ssp_sensorhub_remove(data); } #endif data->bMcuDumpMode = sec_debug_is_enabled(); iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,data->bMcuDumpMode); if (iRet < 0) { pr_err("[SSP]: %s - MSG2SSP_AP_MCU_SET_DUMPMODE failed\n", __func__); } pr_info("[SSP]: %s - setup debuglevel %d!\n", __func__,data->bMcuDumpMode); pr_info("[SSP]: %s - probe success!\n", __func__); enable_debug_timer(data); iRet = 0; if (data->fw_dl_state == FW_DL_STATE_NEED_TO_SCHEDULE) { pr_info("[SSP]: Firmware update is scheduled\n"); schedule_delayed_work(&data->work_firmware, msecs_to_jiffies(1000)); data->fw_dl_state = FW_DL_STATE_SCHEDULED; } else if (data->fw_dl_state == FW_DL_STATE_FAIL) data->bSspShutdown = true; data->bProbeIsDone = true; goto exit; err_read_reg: err_symlink_create: remove_sysfs(data); err_sysfs_create: free_irq(data->iIrq, data); gpio_free(data->mcu_int1); err_setup_irq: destroy_workqueue(data->debug_wq); err_create_workqueue: remove_input_dev(data); err_input_register_device: wake_lock_destroy(&data->ssp_wake_lock); err_reset_null: #ifdef CONFIG_SENSORS_SSP_SHTC1 mutex_destroy(&data->cp_temp_adc_lock); mutex_destroy(&data->bulk_temp_read_lock); #endif #ifdef CONFIG_SENSORS_SSP_STM mutex_destroy(&data->comm_mutex); mutex_destroy(&data->pending_mutex); #endif err_setup: kfree(data); pr_err("[SSP]: %s - probe failed!\n", __func__); exit: pr_info("#####################################################\n\n"); return iRet; }
static int mdss_dsi_parse_dcs_cmds(struct device_node *np, struct dsi_panel_cmds *pcmds, char *cmd_key, char *link_key) { const char *data; int blen = 0, len; char *buf, *bp; struct dsi_ctrl_hdr *dchdr; int i, cnt; data = of_get_property(np, cmd_key, &blen); if (!data) { pr_err("%s: failed, key=%s\n", __func__, cmd_key); return -ENOMEM; } buf = kzalloc(sizeof(char) * blen, GFP_KERNEL); if (!buf) return -ENOMEM; memcpy(buf, data, blen); /* scan dcs commands */ bp = buf; len = blen; cnt = 0; while (len > sizeof(*dchdr)) { dchdr = (struct dsi_ctrl_hdr *)bp; dchdr->dlen = ntohs(dchdr->dlen); if (dchdr->dlen > len) { pr_err("%s: dtsi cmd=%x error, len=%d", __func__, dchdr->dtype, dchdr->dlen); kfree(buf); return -ENOMEM; } pr_debug("bp : %x, dlen : %x, len : %x",*bp,dchdr->dlen,len); bp += sizeof(*dchdr); len -= sizeof(*dchdr); bp += dchdr->dlen; len -= dchdr->dlen; cnt++; } if (len != 0) { pr_err("%s: dcs_cmd=%x len=%d error!", __func__, buf[0], blen); kfree(buf); return -ENOMEM; } pcmds->cmds = kzalloc(cnt * sizeof(struct dsi_cmd_desc), GFP_KERNEL); if (!pcmds->cmds) { kfree(buf); return -ENOMEM; } pcmds->cmd_cnt = cnt; pcmds->buf = buf; pcmds->blen = blen; bp = buf; len = blen; for (i = 0; i < cnt; i++) { dchdr = (struct dsi_ctrl_hdr *)bp; len -= sizeof(*dchdr); bp += sizeof(*dchdr); pcmds->cmds[i].dchdr = *dchdr; pcmds->cmds[i].payload = bp; bp += dchdr->dlen; len -= dchdr->dlen; } pcmds->link_state = DSI_LP_MODE; /* default */ data = of_get_property(np, link_key, NULL); if (!strncmp(data, "DSI_HS_MODE", 11)) pcmds->link_state = DSI_HS_MODE; pr_debug("%s: dcs_cmd=%x len=%d, cmd_cnt=%d link_state=%d\n", __func__, pcmds->buf[0], pcmds->blen, pcmds->cmd_cnt, pcmds->link_state); return 0; }
static int mdss_dsi_event_handler(struct mdss_panel_data *pdata, int event, void *arg) { int rc = 0; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; if (pdata == NULL) { pr_err("%s: Invalid input data\n", __func__); return -EINVAL; } ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata, panel_data); pr_debug("%s+:event=%d\n", __func__, event); switch (event) { case MDSS_EVENT_UNBLANK: rc = mdss_dsi_on(pdata); if (ctrl_pdata->on_cmds.link_state == DSI_LP_MODE) rc = mdss_dsi_unblank(pdata); break; case MDSS_EVENT_PANEL_ON: ctrl_pdata->ctrl_state |= CTRL_STATE_MDP_ACTIVE; if (ctrl_pdata->on_cmds.link_state == DSI_HS_MODE) rc = mdss_dsi_unblank(pdata); break; case MDSS_EVENT_BLANK: if (ctrl_pdata->off_cmds.link_state == DSI_HS_MODE) rc = mdss_dsi_blank(pdata); break; case MDSS_EVENT_PANEL_OFF: ctrl_pdata->ctrl_state &= ~CTRL_STATE_MDP_ACTIVE; if (ctrl_pdata->off_cmds.link_state == DSI_LP_MODE) rc = mdss_dsi_blank(pdata); rc = mdss_dsi_off(pdata); break; case MDSS_EVENT_CONT_SPLASH_FINISH: ctrl_pdata->ctrl_state &= ~CTRL_STATE_MDP_ACTIVE; if (ctrl_pdata->on_cmds.link_state == DSI_LP_MODE) { rc = mdss_dsi_cont_splash_on(pdata); } else { pr_debug("%s:event=%d, Dsi On not called: ctrl_state: %d\n", __func__, event, ctrl_pdata->on_cmds.link_state); rc = -EINVAL; } break; #ifdef CONFIG_OLED_SUPPORT case MDSS_EVENT_FIRST_FRAME_UPDATE: /*Event is send only if cont_splash feature is enabled */ if (ctrl_pdata->off_cmds.link_state == DSI_HS_MODE) { /* Panel is Enabled already in Bootloader */ ctrl_pdata->ctrl_state |= CTRL_STATE_PANEL_INIT; rc = mdss_dsi_blank(pdata); } break; #endif case MDSS_EVENT_PANEL_CLK_CTRL: mdss_dsi_clk_req(ctrl_pdata, (int)arg); break; case MDSS_EVENT_DSI_CMDLIST_KOFF: mdss_dsi_cmdlist_commit(ctrl_pdata, 1); break; case MDSS_EVENT_CONT_SPLASH_BEGIN: if (ctrl_pdata->off_cmds.link_state == DSI_HS_MODE) { /* Panel is Enabled in Bootloader */ rc = mdss_dsi_blank(pdata); } break; default: pr_debug("%s: unhandled event=%d\n", __func__, event); break; } pr_debug("%s-:event=%d, rc=%d\n", __func__, event, rc); return rc; }
static int mdss_panel_parse_dt(struct device_node *np, struct mdss_dsi_ctrl_pdata *ctrl_pdata) { u32 res[6], tmp; int rc, i, len; const char *data; static const char *bl_ctrl_type, *pdest; static const char *on_cmds_state, *off_cmds_state; struct mdss_panel_info *pinfo = &(ctrl_pdata->panel_data.panel_info); rc = of_property_read_u32_array(np, "qcom,mdss-pan-res", res, 2); if (rc) { pr_err("%s:%d, panel resolution not specified\n", __func__, __LINE__); return -EINVAL; } pinfo->xres = (!rc ? res[0] : 640); pinfo->yres = (!rc ? res[1] : 480); rc = of_property_read_u32_array(np, "qcom,mdss-pan-active-res", res, 2); if (rc == 0) { pinfo->lcdc.xres_pad = pinfo->xres - res[0]; pinfo->lcdc.yres_pad = pinfo->yres - res[1]; } rc = of_property_read_u32_array(np, "qcom,mdss-pan-physical-dimension", res, 2); pinfo->physical_width = (!rc ? res[0] : -1); pinfo->physical_height = (!rc ? res[1] : -1); pr_debug("Panel Physical Width=%d, Height=%d\n", pinfo->physical_width, pinfo->physical_height); rc = of_property_read_u32(np, "qcom,mdss-pan-bpp", &tmp); if (rc) { pr_err("%s:%d, panel bpp not specified\n", __func__, __LINE__); return -EINVAL; } pinfo->bpp = (!rc ? tmp : 24); pdest = of_get_property(np, "qcom,mdss-pan-dest", NULL); if (strlen(pdest) != 9) { pr_err("%s: Unknown pdest specified\n", __func__); return -EINVAL; } if (!strncmp(pdest, "display_1", 9)) pinfo->pdest = DISPLAY_1; else if (!strncmp(pdest, "display_2", 9)) pinfo->pdest = DISPLAY_2; else { pr_debug("%s: pdest not specified. Set Default\n", __func__); pinfo->pdest = DISPLAY_1; } rc = of_property_read_u32_array(np, "qcom,mdss-pan-porch-values", res, 6); pinfo->lcdc.h_back_porch = (!rc ? res[0] : 6); pinfo->lcdc.h_pulse_width = (!rc ? res[1] : 2); pinfo->lcdc.h_front_porch = (!rc ? res[2] : 6); pinfo->lcdc.v_back_porch = (!rc ? res[3] : 6); pinfo->lcdc.v_pulse_width = (!rc ? res[4] : 2); pinfo->lcdc.v_front_porch = (!rc ? res[5] : 6); rc = of_property_read_u32(np, "qcom,mdss-pan-underflow-clr", &tmp); pinfo->lcdc.underflow_clr = (!rc ? tmp : 0xff); bl_ctrl_type = of_get_property(np, "qcom,mdss-pan-bl-ctrl", NULL); if ((bl_ctrl_type) && (!strncmp(bl_ctrl_type, "bl_ctrl_wled", 12))) { led_trigger_register_simple("bkl-trigger", &bl_led_trigger); pr_err("%s: SUCCESS-> WLED TRIGGER register\n", __func__); pinfo->bklt_ctrl = BL_WLED; } else if (!strncmp(bl_ctrl_type, "bl_ctrl_pwm", 11)) { ctrl_pdata->bklt_ctrl = BL_PWM; rc = of_property_read_u32(np, "qcom,pwm-period", &tmp); if (rc) { pr_err("%s:%d, Error, panel pwm_period\n", __func__, __LINE__); return -EINVAL; } ctrl_pdata->pwm_period = tmp; rc = of_property_read_u32(np, "qcom,pwm-lpg-channel", &tmp); if (rc) { pr_err("%s:%d, Error, dsi lpg channel\n", __func__, __LINE__); return -EINVAL; } ctrl_pdata->pwm_lpg_chan = tmp; tmp = of_get_named_gpio(np, "qcom,pwm-pmic-gpio", 0); ctrl_pdata->pwm_pmic_gpio = tmp; pr_info("%s: pwm_pmic_gpio=%d\n",__func__, ctrl_pdata->pwm_pmic_gpio); } else if (!strncmp(bl_ctrl_type, "bl_ctrl_dcs", 11)) { pr_info("%s: BL DCS Control \n",__func__); pinfo->bklt_ctrl = BL_DCS_CMD; } else { pr_err("%s: Unknown backlight control\n", __func__); pinfo->bklt_ctrl = UNKNOWN_CTRL; } rc = of_property_read_u32_array(np, "qcom,mdss-pan-bl-levels", res, 2); pinfo->bl_min = (!rc ? res[0] : 0); pinfo->bl_max = (!rc ? res[1] : 255); ctrl_pdata->bklt_max = pinfo->bl_max; rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-mode", &tmp); pinfo->mipi.mode = (!rc ? tmp : DSI_VIDEO_MODE); rc = of_property_read_u32(np, "qcom,mdss-vsync-enable", &tmp); pinfo->mipi.vsync_enable = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-hw-vsync-mode", &tmp); pinfo->mipi.hw_vsync_mode = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-h-pulse-mode", &tmp); pinfo->mipi.pulse_mode_hsa_he = (!rc ? tmp : false); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-h-power-stop", res, 3); pinfo->mipi.hbp_power_stop = (!rc ? res[0] : false); pinfo->mipi.hsa_power_stop = (!rc ? res[1] : false); pinfo->mipi.hfp_power_stop = (!rc ? res[2] : false); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-bllp-power-stop", res, 2); pinfo->mipi.bllp_power_stop = (!rc ? res[0] : false); pinfo->mipi.eof_bllp_power_stop = (!rc ? res[1] : false); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-traffic-mode", &tmp); pinfo->mipi.traffic_mode = (!rc ? tmp : DSI_NON_BURST_SYNCH_PULSE); rc = of_property_read_u32(np, "qcom,mdss-pan-insert-dcs-cmd", &tmp); pinfo->mipi.insert_dcs_cmd = (!rc ? tmp : 1); rc = of_property_read_u32(np, "qcom,mdss-pan-wr-mem-continue", &tmp); pinfo->mipi.wr_mem_continue = (!rc ? tmp : 0x3c); rc = of_property_read_u32(np, "qcom,mdss-pan-wr-mem-start", &tmp); pinfo->mipi.wr_mem_start = (!rc ? tmp : 0x2c); rc = of_property_read_u32(np, "qcom,mdss-pan-te-sel", &tmp); pinfo->mipi.te_sel = (!rc ? tmp : 1); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-dst-format", &tmp); pinfo->mipi.dst_format = (!rc ? tmp : DSI_VIDEO_DST_FORMAT_RGB888); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-vc", &tmp); pinfo->mipi.vc = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-rgb-swap", &tmp); pinfo->mipi.rgb_swap = (!rc ? tmp : DSI_RGB_SWAP_RGB); rc = of_property_read_u32(np, "qcom,mdss-force-clk-lane-hs", &tmp); pinfo->mipi.force_clk_lane_hs = (!rc ? tmp : 0); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-data-lanes", res, 4); pinfo->mipi.data_lane0 = (!rc ? res[0] : true); pinfo->mipi.data_lane1 = (!rc ? res[1] : false); pinfo->mipi.data_lane2 = (!rc ? res[2] : false); pinfo->mipi.data_lane3 = (!rc ? res[3] : false); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-dlane-swap", &tmp); pinfo->mipi.dlane_swap = (!rc ? tmp : 0); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-t-clk", res, 2); pinfo->mipi.t_clk_pre = (!rc ? res[0] : 0x24); pinfo->mipi.t_clk_post = (!rc ? res[1] : 0x03); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-stream", &tmp); pinfo->mipi.stream = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-mdp-tr", &tmp); pinfo->mipi.mdp_trigger = (!rc ? tmp : DSI_CMD_TRIGGER_SW); if (pinfo->mipi.mdp_trigger > 6) { pr_err("%s:%d, Invalid mdp trigger. Forcing to sw trigger", __func__, __LINE__); pinfo->mipi.mdp_trigger = DSI_CMD_TRIGGER_SW; } rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-dma-tr", &tmp); pinfo->mipi.dma_trigger = (!rc ? tmp : DSI_CMD_TRIGGER_SW); if (pinfo->mipi.dma_trigger > 6) { pr_err("%s:%d, Invalid dma trigger. Forcing to sw trigger", __func__, __LINE__); pinfo->mipi.dma_trigger = DSI_CMD_TRIGGER_SW; } rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-frame-rate", &tmp); pinfo->mipi.frame_rate = (!rc ? tmp : 60); rc = of_property_read_u32(np, "qcom,mdss-pan-clk-rate", &tmp); pinfo->clk_rate = (!rc ? tmp : 0); data = of_get_property(np, "qcom,panel-phy-regulatorSettings", &len); if ((!data) || (len != 7)) { pr_err("%s:%d, Unable to read Phy regulator settings", __func__, __LINE__); goto error; } for (i = 0; i < len; i++) phy_params.regulator[i] = data[i]; data = of_get_property(np, "qcom,panel-phy-timingSettings", &len); if ((!data) || (len != 12)) { pr_err("%s:%d, Unable to read Phy timing settings", __func__, __LINE__); goto error; } for (i = 0; i < len; i++) phy_params.timing[i] = data[i]; data = of_get_property(np, "qcom,panel-phy-strengthCtrl", &len); if ((!data) || (len != 2)) { pr_err("%s:%d, Unable to read Phy Strength ctrl settings", __func__, __LINE__); goto error; } phy_params.strength[0] = data[0]; phy_params.strength[1] = data[1]; data = of_get_property(np, "qcom,panel-phy-bistCtrl", &len); if ((!data) || (len != 6)) { pr_err("%s:%d, Unable to read Phy Bist Ctrl settings", __func__, __LINE__); goto error; } for (i = 0; i < len; i++) phy_params.bistctrl[i] = data[i]; data = of_get_property(np, "qcom,panel-phy-laneConfig", &len); if ((!data) || (len != 45)) { pr_err("%s:%d, Unable to read Phy lane configure settings", __func__, __LINE__); goto error; } for (i = 0; i < len; i++) phy_params.lanecfg[i] = data[i]; pinfo->mipi.dsi_phy_db = phy_params; mdss_dsi_parse_fbc_params(np, pinfo); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->on_cmds, "qcom,panel-on-cmds", "qcom,on-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->off_cmds, "qcom,panel-off-cmds", "qcom,off-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->ce_on_cmds, "samsung,panel-ce-on-cmds", "qcom,on-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->ce_off_cmds, "samsung,panel-ce-off-cmds", "qcom,off-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->cabc_on_cmds, "samsung,panel-cabc-on-cmds", "qcom,on-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->cabc_off_cmds, "samsung,panel-cabc-off-cmds", "qcom,off-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &ctrl_pdata->cabc_tune_cmds, "samsung,panel-cabc-tune-cmds", "qcom,off-cmds-dsi-state"); on_cmds_state = of_get_property(np, "qcom,on-cmds-dsi-state", NULL); if (!strncmp(on_cmds_state, "DSI_LP_MODE", 11)) { ctrl_pdata->dsi_on_state = DSI_LP_MODE; } else if (!strncmp(on_cmds_state, "DSI_HS_MODE", 11)) { ctrl_pdata->dsi_on_state = DSI_HS_MODE; } else { pr_debug("%s: ON cmds state not specified. Set Default\n", __func__); ctrl_pdata->dsi_on_state = DSI_LP_MODE; } off_cmds_state = of_get_property(np, "qcom,off-cmds-dsi-state", NULL); if (!strncmp(off_cmds_state, "DSI_LP_MODE", 11)) { ctrl_pdata->dsi_off_state = DSI_LP_MODE; } else if (!strncmp(off_cmds_state, "DSI_HS_MODE", 11)) { ctrl_pdata->dsi_off_state = DSI_HS_MODE; } else { pr_debug("%s: ON cmds state not specified. Set Default\n", __func__); ctrl_pdata->dsi_off_state = DSI_LP_MODE; } return 0; error: return -EINVAL; }
int dsi_panel_device_register(struct platform_device *pdev, struct mdss_panel_common_pdata *panel_data) { struct mipi_panel_info *mipi; int rc; u8 lanes = 0, bpp; u32 h_period, v_period, dsi_pclk_rate; struct mdss_dsi_ctrl_pdata *ctrl_pdata; struct device_node *dsi_ctrl_np = NULL; struct platform_device *ctrl_pdev = NULL; bool broadcast; bool cont_splash_enabled = false; h_period = ((panel_data->panel_info.lcdc.h_pulse_width) + (panel_data->panel_info.lcdc.h_back_porch) + (panel_data->panel_info.xres) + (panel_data->panel_info.lcdc.h_front_porch)); #ifdef CONFIG_OLED_SUPPORT v_period = ((panel_data->panel_info.lcdc.v_pulse_width) + (panel_data->panel_info.lcdc.v_back_porch) + (panel_data->panel_info.yres) + (panel_data->panel_info.lcdc.yres_margin) + (panel_data->panel_info.lcdc.v_front_porch)); #else v_period = ((panel_data->panel_info.lcdc.v_pulse_width) + (panel_data->panel_info.lcdc.v_back_porch) + (panel_data->panel_info.yres) + (panel_data->panel_info.lcdc.v_front_porch)); #endif mipi = &panel_data->panel_info.mipi; panel_data->panel_info.type = ((mipi->mode == DSI_VIDEO_MODE) ? MIPI_VIDEO_PANEL : MIPI_CMD_PANEL); if (mipi->data_lane3) lanes += 1; if (mipi->data_lane2) lanes += 1; if (mipi->data_lane1) lanes += 1; if (mipi->data_lane0) lanes += 1; if ((mipi->dst_format == DSI_CMD_DST_FORMAT_RGB888) || (mipi->dst_format == DSI_VIDEO_DST_FORMAT_RGB888) || (mipi->dst_format == DSI_VIDEO_DST_FORMAT_RGB666_LOOSE)) bpp = 3; else if ((mipi->dst_format == DSI_CMD_DST_FORMAT_RGB565) || (mipi->dst_format == DSI_VIDEO_DST_FORMAT_RGB565)) bpp = 2; else bpp = 3; /* Default format set to RGB888 */ if (!panel_data->panel_info.clk_rate) { h_period += panel_data->panel_info.lcdc.xres_pad; v_period += panel_data->panel_info.lcdc.yres_pad; if (lanes > 0) { panel_data->panel_info.clk_rate = ((h_period * v_period * (mipi->frame_rate) * bpp * 8) / lanes); } else { pr_err("%s: forcing mdss_dsi lanes to 1\n", __func__); panel_data->panel_info.clk_rate = (h_period * v_period * (mipi->frame_rate) * bpp * 8); } #ifdef CONFIG_MACH_LGE rc = of_property_read_u32(pdev->dev.of_node, "lge,mdss-dsi-bit-rate", &mdss_dsi_bit_rate); if (rc == 0) panel_data->panel_info.clk_rate = mdss_dsi_bit_rate; pr_info("%s: DSI data rate:%u\n", __func__, panel_data->panel_info.clk_rate); #endif } pll_divider_config.clk_rate = panel_data->panel_info.clk_rate; rc = mdss_dsi_clk_div_config(bpp, lanes, &dsi_pclk_rate); if (rc) { pr_err("%s: unable to initialize the clk dividers\n", __func__); return rc; } if ((dsi_pclk_rate < 3300000) || (dsi_pclk_rate > 250000000)) dsi_pclk_rate = 35000000; mipi->dsi_pclk_rate = dsi_pclk_rate; dsi_ctrl_np = of_parse_phandle(pdev->dev.of_node, "qcom,dsi-ctrl-phandle", 0); if (!dsi_ctrl_np) { pr_err("%s: Dsi controller node not initialized\n", __func__); return -EPROBE_DEFER; } ctrl_pdev = of_find_device_by_node(dsi_ctrl_np); #ifdef CONFIG_MACH_LGE if (!ctrl_pdev) return -ENODEV; #endif ctrl_pdata = platform_get_drvdata(ctrl_pdev); if (!ctrl_pdata) { pr_err("%s: no dsi ctrl driver data\n", __func__); return -EINVAL; } rc = mdss_dsi_regulator_init(ctrl_pdev); if (rc) { dev_err(&pdev->dev, "%s: failed to init regulator, rc=%d\n", __func__, rc); return rc; } broadcast = of_property_read_bool(pdev->dev.of_node, "qcom,mdss-pan-broadcast-mode"); if (broadcast) ctrl_pdata->shared_pdata.broadcast_enable = 1; ctrl_pdata->disp_en_gpio = of_get_named_gpio(pdev->dev.of_node, "qcom,enable-gpio", 0); if (!gpio_is_valid(ctrl_pdata->disp_en_gpio)) { pr_err("%s:%d, Disp_en gpio not specified\n", __func__, __LINE__); } else { rc = gpio_request(ctrl_pdata->disp_en_gpio, "disp_enable"); if (rc) { pr_err("request reset gpio failed, rc=%d\n", rc); gpio_free(ctrl_pdata->disp_en_gpio); return -ENODEV; } } ctrl_pdata->disp_te_gpio = of_get_named_gpio(pdev->dev.of_node, "qcom,te-gpio", 0); if (!gpio_is_valid(ctrl_pdata->disp_te_gpio)) { pr_err("%s:%d, Disp_te gpio not specified\n", __func__, __LINE__); } else { rc = gpio_request(ctrl_pdata->disp_te_gpio, "disp_te"); if (rc) { pr_err("request TE gpio failed, rc=%d\n", rc); gpio_free(ctrl_pdata->disp_te_gpio); return -ENODEV; } rc = gpio_tlmm_config(GPIO_CFG( ctrl_pdata->disp_te_gpio, 1, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc) { pr_err("%s: unable to config tlmm = %d\n", __func__, ctrl_pdata->disp_te_gpio); gpio_free(ctrl_pdata->disp_te_gpio); return -ENODEV; } rc = gpio_direction_input(ctrl_pdata->disp_te_gpio); if (rc) { pr_err("set_direction for disp_en gpio failed, rc=%d\n", rc); gpio_free(ctrl_pdata->disp_te_gpio); return -ENODEV; } pr_debug("%s: te_gpio=%d\n", __func__, ctrl_pdata->disp_te_gpio); } ctrl_pdata->rst_gpio = of_get_named_gpio(pdev->dev.of_node, "qcom,rst-gpio", 0); if (!gpio_is_valid(ctrl_pdata->rst_gpio)) { pr_err("%s:%d, reset gpio not specified\n", __func__, __LINE__); } else { rc = gpio_request(ctrl_pdata->rst_gpio, "disp_rst_n"); if (rc) { pr_err("request reset gpio failed, rc=%d\n", rc); gpio_free(ctrl_pdata->rst_gpio); if (gpio_is_valid(ctrl_pdata->disp_en_gpio)) gpio_free(ctrl_pdata->disp_en_gpio); return -ENODEV; } } if (mdss_dsi_clk_init(ctrl_pdev, ctrl_pdata)) { pr_err("%s: unable to initialize Dsi ctrl clks\n", __func__); return -EPERM; } if (mdss_dsi_retrieve_ctrl_resources(ctrl_pdev, panel_data->panel_info.pdest, ctrl_pdata)) { pr_err("%s: unable to get Dsi controller res\n", __func__); return -EPERM; } ctrl_pdata->panel_data.event_handler = mdss_dsi_event_handler; ctrl_pdata->on_cmds = panel_data->on_cmds; ctrl_pdata->off_cmds = panel_data->off_cmds; memcpy(&((ctrl_pdata->panel_data).panel_info), &(panel_data->panel_info), sizeof(struct mdss_panel_info)); #ifdef CONFIG_MACH_LGE ctrl_pdata->on = panel_data->on; ctrl_pdata->off = panel_data->off; #endif ctrl_pdata->panel_data.set_backlight = panel_data->bl_fnc; ctrl_pdata->bklt_ctrl = panel_data->panel_info.bklt_ctrl; ctrl_pdata->pwm_pmic_gpio = panel_data->panel_info.pwm_pmic_gpio; ctrl_pdata->pwm_period = panel_data->panel_info.pwm_period; ctrl_pdata->pwm_lpg_chan = panel_data->panel_info.pwm_lpg_chan; ctrl_pdata->bklt_max = panel_data->panel_info.bl_max; #ifdef CONFIG_OLED_SUPPORT ctrl_pdata->panel_data.panel_info.blmap_size = panel_data->panel_info.blmap_size; ctrl_pdata->panel_data.panel_info.blmap = panel_data->panel_info.blmap; #endif if (ctrl_pdata->bklt_ctrl == BL_PWM) mdss_dsi_panel_pwm_cfg(ctrl_pdata); mdss_dsi_ctrl_init(ctrl_pdata); /* * register in mdp driver */ ctrl_pdata->pclk_rate = dsi_pclk_rate; ctrl_pdata->byte_clk_rate = panel_data->panel_info.clk_rate / 8; pr_debug("%s: pclk=%d, bclk=%d\n", __func__, ctrl_pdata->pclk_rate, ctrl_pdata->byte_clk_rate); ctrl_pdata->ctrl_state = CTRL_STATE_UNKNOWN; #ifdef CONFIG_MACH_LGE cont_splash_enabled = lge_get_cont_splash_enabled(); #else cont_splash_enabled = of_property_read_bool(pdev->dev.of_node, "qcom,cont-splash-enabled"); #endif if (!cont_splash_enabled) { pr_info("%s:%d Continuous splash flag not found.\n", __func__, __LINE__); ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0; ctrl_pdata->panel_data.panel_info.panel_power_on = 0; } else { pr_info("%s:%d Continuous splash flag enabled.\n", __func__, __LINE__); ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 1; ctrl_pdata->panel_data.panel_info.panel_power_on = 1; rc = mdss_dsi_panel_power_on(&(ctrl_pdata->panel_data), 1); if (rc) { pr_err("%s: Panel power on failed\n", __func__); return rc; } mdss_dsi_clk_ctrl(ctrl_pdata, 1); ctrl_pdata->ctrl_state |= (CTRL_STATE_PANEL_INIT | CTRL_STATE_MDP_ACTIVE); } rc = mdss_register_panel(ctrl_pdev, &(ctrl_pdata->panel_data)); if (rc) { dev_err(&pdev->dev, "unable to register MIPI DSI panel\n"); if (ctrl_pdata->rst_gpio) gpio_free(ctrl_pdata->rst_gpio); if (gpio_is_valid(ctrl_pdata->disp_en_gpio)) gpio_free(ctrl_pdata->disp_en_gpio); return rc; } #ifndef CONFIG_MACH_LGE ctrl_pdata->on = panel_data->on; ctrl_pdata->off = panel_data->off; #endif if (panel_data->panel_info.pdest == DISPLAY_1) { mdss_debug_register_base("dsi0", ctrl_pdata->ctrl_base, ctrl_pdata->reg_size); ctrl_pdata->ndx = 0; } else { mdss_debug_register_base("dsi1", ctrl_pdata->ctrl_base, ctrl_pdata->reg_size); ctrl_pdata->ndx = 1; } pr_debug("%s: Panal data initialized\n", __func__); return 0; }
int mdss_dsi_panel_init(struct device_node *node, struct mdss_dsi_ctrl_pdata *ctrl_pdata, bool cmd_cfg_cont_splash) { int rc = 0; static const char *panel_name; static int first_init = 0; bool cont_splash_enabled; struct lcd_device *lcd_device; if (!node) { pr_err("%s: no panel node\n", __func__); return -ENODEV; } pr_debug("%s:%d\n", __func__, __LINE__); panel_name = of_get_property(node, "qcom,mdss-dsi-panel-name", NULL); if (!panel_name) pr_info("%s:%d, Panel name not specified\n", __func__, __LINE__); else pr_err("%s: Panel Name = %s\n", __func__, panel_name); rc = mdss_panel_parse_dt(node, ctrl_pdata); if (rc) { pr_err("%s:%d panel dt parse failed\n", __func__, __LINE__); return rc; } cont_splash_enabled = of_property_read_bool(node, "qcom,cont-splash-enabled"); if (!cont_splash_enabled) { pr_info("%s:%d Continuous splash flag not found.\n", __func__, __LINE__); ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0; } else { pr_info("%s:%d Continuous splash flag enabled.\n", __func__, __LINE__); ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 1; } if (get_lcd_attached() == 0) { ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0; } ctrl_pdata->on = mdss_dsi_panel_on; ctrl_pdata->off = mdss_dsi_panel_off; ctrl_pdata->panel_reset = mdss_dsi_panel_reset; ctrl_pdata->bl_fnc= mdss_dsi_panel_bl_ctrl; ctrl_pdata->registered = mdss_dsi_panel_registered; ctrl_pdata->panel_data.set_backlight = mdss_dsi_panel_bl_ctrl; ctrl_pdata->bklt_ctrl = ctrl_pdata->panel_data.panel_info.bklt_ctrl; if(!left_back_up_data && ctrl_pdata->panel_data.panel_info.pdest == DISPLAY_2) { pr_info("%s: dsi_ctrl_1 backup",__func__); left_back_up_data = ctrl_pdata; } if(!first_init) { mutex_init(&msd.lock); lcd_device = lcd_device_register("panel", NULL, NULL, &mipi_samsung_disp_props); if (IS_ERR(lcd_device)) { rc = PTR_ERR(lcd_device); return rc; } rc = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (rc) pr_info(" can't create lcd_type sysfs\n"); rc = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lux.attr); if (rc) pr_info(" can't create lux sysfs\n"); first_init = 1; } #if defined(CONFIG_CABC_TUNING) cabc_tuning_init(ctrl_pdata); #endif return 0; }
static int mdss_dsi_panel_power_on(struct mdss_panel_data *pdata, int enable) #endif { int ret; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; if (pdata == NULL) { pr_err("%s: Invalid input data\n", __func__); return -EINVAL; } ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata, panel_data); pr_debug("%s: enable=%d\n", __func__, enable); if (enable) { if (ctrl_pdata->power_data.num_vreg > 0) { ret = msm_dss_enable_vreg( ctrl_pdata->power_data.vreg_config, ctrl_pdata->power_data.num_vreg, 1); if (ret) { pr_err("%s:Failed to enable regulators.rc=%d\n", __func__, ret); return ret; } /* * A small delay is needed here after enabling * all regulators and before issuing panel reset */ msleep(20); } else { #ifdef CONFIG_MACH_LGE if (mdss_dsi_use_vdd_supply) { ret = regulator_set_optimum_mode ((ctrl_pdata->shared_pdata).vdd_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_vreg set opt mode failed.\n", __func__); return ret; } } #else ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_vreg set opt mode failed.\n", __func__); return ret; } #endif ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_io_vreg, 100000); if (ret < 0) { pr_err("%s: vdd_io_vreg set opt mode failed.\n", __func__); return ret; } ret = regulator_set_optimum_mode ((ctrl_pdata->shared_pdata).vdda_vreg, 100000); if (ret < 0) { pr_err("%s: vdda_vreg set opt mode failed.\n", __func__); return ret; } ret = regulator_enable( (ctrl_pdata->shared_pdata).vdd_io_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } msleep(20); #ifdef CONFIG_MACH_LGE if (mdss_dsi_use_vdd_supply) { ret = regulator_enable( (ctrl_pdata->shared_pdata).vdd_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } } msleep(20); #else ret = regulator_enable( (ctrl_pdata->shared_pdata).vdd_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } msleep(20); #endif ret = regulator_enable( (ctrl_pdata->shared_pdata).vdda_vreg); if (ret) { pr_err("%s: Failed to enable regulator.\n", __func__); return ret; } } #if defined(CONFIG_MACH_LGE) /* LGE_CHANGE_S * power sequence for LGD_FHD panel * 2013-04-05, [email protected] */ if (gpio_is_valid(ctrl_pdata->disp_en_gpio)){ gpio_set_value((ctrl_pdata->disp_en_gpio), 1); msleep(1); } else pr_debug("%s:%d, reset line not configured\n", __func__, __LINE__); #else if (pdata->panel_info.panel_power_on == 0) mdss_dsi_panel_reset(pdata, 1); /* LGE_CHANGE_E */ #endif } else { #if !defined(CONFIG_MACH_LGE) /* LGE_CHANGE_S * power sequence for LGD_FHD panel * 2013-04-05, [email protected] */ mdss_dsi_panel_reset(pdata, 0); #endif if (ctrl_pdata->power_data.num_vreg > 0) { ret = msm_dss_enable_vreg( ctrl_pdata->power_data.vreg_config, ctrl_pdata->power_data.num_vreg, 0); if (ret) { pr_err("%s: Failed to disable regs.rc=%d\n", __func__, ret); return ret; } } else { #ifdef CONFIG_MACH_LGE if (mdss_dsi_use_vdd_supply) { ret = regulator_disable( (ctrl_pdata->shared_pdata).vdd_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } } #else ret = regulator_disable( (ctrl_pdata->shared_pdata).vdd_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } #endif ret = regulator_disable( (ctrl_pdata->shared_pdata).vdda_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } #if defined(CONFIG_MACH_LGE) /* LGE_CHANGE_S * power sequence for LGD_FHD panel * 2013-04-09, [email protected] */ msleep(1); mdss_dsi_panel_reset(pdata, 0); msleep(1); gpio_set_value((ctrl_pdata->disp_en_gpio), 0); msleep(1); #endif #if !defined(CONFIG_MACH_MSM8974_VU3_KR) ret = regulator_disable( (ctrl_pdata->shared_pdata).vdd_io_vreg); if (ret) { pr_err("%s: Failed to disable regulator.\n", __func__); return ret; } #endif #ifdef CONFIG_MACH_LGE if (mdss_dsi_use_vdd_supply) { ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_vreg, 100); if (ret < 0) { pr_err("%s: vdd_vreg set opt mode failed.\n", __func__); return ret; } } #else ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_vreg, 100); if (ret < 0) { pr_err("%s: vdd_vreg set opt mode failed.\n", __func__); return ret; } #endif ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdd_io_vreg, 100); if (ret < 0) { pr_err("%s: vdd_io_vreg set opt mode failed.\n", __func__); return ret; } ret = regulator_set_optimum_mode( (ctrl_pdata->shared_pdata).vdda_vreg, 100); if (ret < 0) { pr_err("%s: vdda_vreg set opt mode failed.\n", __func__); return ret; } } } return 0; pr_info("%s: %s\n", __func__, enable ? "on" : "off"); }
static ssize_t magnetic_get_selftest(struct device *dev, struct device_attribute *attr, char *buf) { char chTempBuf[22] = { 0, }; int iRet = 0; s8 id = 0, x = 0, y1 = 0, y2 = 0, dir = 0; s16 sx = 0, sy = 0, ohx = 0, ohy = 0, ohz = 0; s8 err[7] = {-1, }; struct ssp_data *data = dev_get_drvdata(dev); struct ssp_msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL); if (msg == NULL) { pr_err("[SSP] %s, failed to alloc memory for ssp_msg\n", __func__); goto exit; } msg->cmd = GEOMAGNETIC_FACTORY; msg->length = 22; msg->options = AP2HUB_READ; msg->buffer = chTempBuf; msg->free_buffer = 0; iRet = ssp_spi_sync(data, msg, 1000); if (iRet != SUCCESS) { pr_err("[SSP]: %s - Magnetic Selftest Timeout!! %d\n", __func__, iRet); goto exit; } id = (s8)(chTempBuf[0]); err[0] = (s8)(chTempBuf[1]); err[1] = (s8)(chTempBuf[2]); err[2] = (s8)(chTempBuf[3]); x = (s8)(chTempBuf[4]); y1 = (s8)(chTempBuf[5]); y2 = (s8)(chTempBuf[6]); err[3] = (s8)(chTempBuf[7]); dir = (s8)(chTempBuf[8]); err[4] = (s8)(chTempBuf[9]); ohx = (s16)((chTempBuf[10] << 8) + chTempBuf[11]); ohy = (s16)((chTempBuf[12] << 8) + chTempBuf[13]); ohz = (s16)((chTempBuf[14] << 8) + chTempBuf[15]); err[6] = (s8)(chTempBuf[16]); sx = (s16)((chTempBuf[17] << 8) + chTempBuf[18]); sy = (s16)((chTempBuf[19] << 8) + chTempBuf[20]); err[5] = (s8)(chTempBuf[21]); if (unlikely(id != 0x2)) err[0] = -1; if (unlikely(x < -30 || x > 30)) err[3] = -1; if (unlikely(y1 < -30 || y1 > 30)) err[3] = -1; if (unlikely(y2 < -30 || y2 > 30)) err[3] = -1; if (unlikely(sx < 17 || sy < 22)) err[5] = -1; if (unlikely(ohx < -600 || ohx > 600)) err[6] = -1; if (unlikely(ohy < -600 || ohy > 600)) err[6] = -1; if (unlikely(ohz < -600 || ohz > 600)) err[6] = -1; pr_info("[SSP] %s\n" "[SSP] Test1 - err = %d, id = %d\n" "[SSP] Test3 - err = %d\n" "[SSP] Test4 - err = %d, offset = %d,%d,%d\n" "[SSP] Test5 - err = %d, direction = %d\n" "[SSP] Test6 - err = %d, sensitivity = %d,%d\n" "[SSP] Test7 - err = %d, offset = %d,%d,%d\n" "[SSP] Test2 - err = %d\n", __func__, err[0], id, err[2], err[3], x, y1, y2, err[4], dir, err[5], sx, sy, err[6], ohx, ohy, ohz, err[1]); exit: return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n", err[0], id, err[2], err[3], x, y1, y2, err[4], dir, err[5], sx, sy, err[6], ohx, ohy, ohz, err[1]); }
static int mdss_dsi_get_dt_vreg_data(struct device *dev, struct dss_module_power *mp) { int i, rc = 0; int dt_vreg_total = 0; u32 *val_array = NULL; struct device_node *of_node = NULL; if (!dev || !mp) { pr_err("%s: invalid input\n", __func__); rc = -EINVAL; goto error; } of_node = dev->of_node; mp->num_vreg = 0; dt_vreg_total = of_property_count_strings(of_node, "qcom,supply-names"); if (dt_vreg_total < 0) { pr_debug("%s: vreg not found. rc=%d\n", __func__, dt_vreg_total); rc = 0; goto error; } else { pr_debug("%s: vreg found. count=%d\n", __func__, dt_vreg_total); } if (dt_vreg_total > 0) { mp->num_vreg = dt_vreg_total; mp->vreg_config = devm_kzalloc(dev, sizeof(struct dss_vreg) * dt_vreg_total, GFP_KERNEL); if (!mp->vreg_config) { pr_err("%s: can't alloc vreg mem\n", __func__); goto error; } } else { pr_debug("%s: no vreg\n", __func__); return 0; } val_array = devm_kzalloc(dev, sizeof(u32) * dt_vreg_total, GFP_KERNEL); if (!val_array) { pr_err("%s: can't allocate vreg scratch mem\n", __func__); rc = -ENOMEM; goto error; } for (i = 0; i < dt_vreg_total; i++) { const char *st = NULL; /* vreg-name */ rc = of_property_read_string_index(of_node, "qcom,supply-names", i, &st); if (rc) { pr_err("%s: error reading name. i=%d, rc=%d\n", __func__, i, rc); goto error; } snprintf(mp->vreg_config[i].vreg_name, ARRAY_SIZE((mp->vreg_config[i].vreg_name)), "%s", st); /* vreg-min-voltage */ memset(val_array, 0, sizeof(u32) * dt_vreg_total); rc = of_property_read_u32_array(of_node, "qcom,supply-min-voltage-level", val_array, dt_vreg_total); if (rc) { pr_err("%s: error reading min volt. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].min_voltage = val_array[i]; /* vreg-max-voltage */ memset(val_array, 0, sizeof(u32) * dt_vreg_total); rc = of_property_read_u32_array(of_node, "qcom,supply-max-voltage-level", val_array, dt_vreg_total); if (rc) { pr_err("%s: error reading max volt. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].max_voltage = val_array[i]; /* vreg-peak-current*/ memset(val_array, 0, sizeof(u32) * dt_vreg_total); rc = of_property_read_u32_array(of_node, "qcom,supply-peak-current", val_array, dt_vreg_total); if (rc) { pr_err("%s: error reading peak current. rc=%d\n", __func__, rc); goto error; } mp->vreg_config[i].peak_current = val_array[i]; pr_debug("%s: %s min=%d, max=%d, pc=%d\n", __func__, mp->vreg_config[i].vreg_name, mp->vreg_config[i].min_voltage, mp->vreg_config[i].max_voltage, mp->vreg_config[i].peak_current); } devm_kfree(dev, val_array); return rc; error: if (mp->vreg_config) { devm_kfree(dev, mp->vreg_config); mp->vreg_config = NULL; } mp->num_vreg = 0; if (val_array) devm_kfree(dev, val_array); return rc; }
static void __init board_init(void) { int package = OMAP_PACKAGE_CBS; int status; omap_board_config = board_config; omap_board_config_size = ARRAY_SIZE(board_config); board_set_osc_timings(); if (omap_rev() == OMAP4430_REV_ES1_0) package = OMAP_PACKAGE_CBL; omap4_mux_init(board_mux, NULL, package); archos_memory_init(); archos_create_board_props(); omap4_i2c_init(); board_buttons_init(); board_xceiv_init(); archos_usb_musb_init(&archos_vbus_info); archos_audio_twl6040_init(&twl6040_codec); archos_accel_mma8453q_init(&board_mma8453q_pdata); archos_compass_init(&board_akm8975_pdata); archos_battery_twl4030_bci_init(&board_bci_data); omap4_leds_init(); platform_add_devices(a80s_devices, ARRAY_SIZE(a80s_devices)); board_touch_init(); wake_lock_init(&st_wk_lock, WAKE_LOCK_SUSPEND, "st_wake_lock"); board_serial_init(); board_wifi_init(); usb_musb_init(&musb_board_data); omap4_twl6030_hsmmc_init(mmc); archos_omap4_ehci_init(); omap_dmm_init(); omap_board_display_init(); archos_hsusb_ext_regulator_init(); enable_board_wakeup_source(); hardware_comp.tps62361 = 1; /* Vsel0 = gpio, vsel1 = gnd */ status = omap_tps6236x_board_setup(true, TPS62361_GPIO, -1, OMAP_PIN_OFF_OUTPUT_HIGH, -1); if (status) pr_err("TPS62361 initialization failed: %d\n", status); omap_enable_smartreflex_on_init(); if (omap_rev() >= OMAP4430_REV_ES2_3) if (enable_suspend_off) omap_pm_enable_off_mode(); }
static ssize_t pn544_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset) { struct pn544_dev *pn544_dev = filp->private_data; static char tmp[MAX_BUFFER_SIZE]; int ret; int irq_gpio_val = 0; if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; pr_debug("%s : reading %zu bytes.\n", __func__, count); mutex_lock(&pn544_dev->read_mutex); if (!stReadIntFlag) { irq_gpio_val = gpio_get_value(pn544_dev->irq_gpio); dprintk(PN544_DRV_NAME ":IRQ GPIO = %d\n", irq_gpio_val); if (irq_gpio_val == 0) { if (filp->f_flags & O_NONBLOCK) { pr_err(PN544_DRV_NAME ":f_falg has O_NONBLOCK. EAGAIN!\n"); ret = -EAGAIN; goto fail; } pn544_dev->irq_enabled = true; #ifdef LGE_NFC_READ_IRQ_MODIFY do_reading=0;//DY_TEST #endif // #if !defined(LGE_NFC_HW_QCT_MSM8660) enable_irq_wake(pn544_get_irq_pin(pn544_dev)); #endif enable_irq(pn544_get_irq_pin(pn544_dev)); #ifdef LGE_NFC_READ_IRQ_MODIFY ret = wait_event_interruptible(pn544_dev->read_wq, do_reading); #else ret = wait_event_interruptible(pn544_dev->read_wq, gpio_get_value(pn544_dev->irq_gpio)); #endif pn544_disable_irq(pn544_dev); //dprintk(PN544_DRV_NAME ":wait_event_interruptible : %d\n", ret); #ifdef LGE_NFC_READ_IRQ_MODIFY //DY_TEST if(cancle_read == true) { cancle_read = false; ret = -1; goto fail; } #endif if (ret) goto fail; } } /* Read data */ memset(tmp, 0x00, MAX_BUFFER_SIZE); ret = i2c_master_recv(pn544_dev->client, tmp, count); mutex_unlock(&pn544_dev->read_mutex); if (ret < 0) { pr_err("%s: i2c_master_recv returned %d\n", __func__, ret); return ret; } if (ret > count) { pr_err("%s: received too many bytes from i2c (%d)\n", __func__, ret); return -EIO; } if (copy_to_user(buf, tmp, ret)) { pr_warning("%s : failed to copy to user space\n", __func__); return -EFAULT; } return ret; fail: mutex_unlock(&pn544_dev->read_mutex); return ret; }
static int __init omap_hsmmc_pdata_init(struct omap2_hsmmc_info *c, struct omap_mmc_platform_data *mmc) { char *hc_name; unsigned long max_freq, min_freq; hc_name = kzalloc(sizeof(char) * (HSMMC_NAME_LEN + 1), GFP_KERNEL); if (!hc_name) { pr_err("Cannot allocate memory for controller slot name\n"); kfree(hc_name); return -ENOMEM; } if (c->name) strncpy(hc_name, c->name, HSMMC_NAME_LEN); else snprintf(hc_name, (HSMMC_NAME_LEN + 1), "mmc%islot%i", c->mmc, 1); mmc->slots[0].name = hc_name; mmc->nr_slots = 1; mmc->slots[0].caps = c->caps; mmc->slots[0].pm_caps = c->pm_caps; mmc->slots[0].internal_clock = !c->ext_clock; mmc->dma_mask = 0xffffffff; mmc->set_clk_src = omap_hsmmc_set_clks_src; if (omap_hsmmc_max_min(c->mmc - 1, &max_freq, &min_freq)) { pr_err("Invalid mmc slot"); kfree(hc_name); return -EINVAL; } if (c->max_freq > 0) mmc->max_freq = min(c->max_freq, max_freq); else mmc->max_freq = max_freq; mmc->max_si_freq = max_freq; mmc->min_freq = min_freq; if (cpu_is_omap44xx()) mmc->reg_offset = OMAP4_MMC_REG_OFFSET; else mmc->reg_offset = 0; //mmc->get_context_loss_count = hsmmc_get_context_loss; mmc->slots[0].switch_pin = c->gpio_cd; mmc->slots[0].gpio_wp = c->gpio_wp; mmc->slots[0].remux = c->remux; mmc->slots[0].init_card = c->init_card; if (c->cover_only) mmc->slots[0].cover = 1; if (c->nonremovable) mmc->slots[0].nonremovable = 1; if (c->power_saving) mmc->slots[0].power_saving = 1; if (c->no_off) mmc->slots[0].no_off = 1; if (c->no_off_init) mmc->slots[0].no_regulator_off_init = c->no_off_init; if (c->vcc_aux_disable_is_sleep) mmc->slots[0].vcc_aux_disable_is_sleep = 1; /* * NOTE: MMC slots should have a Vcc regulator set up. * This may be from a TWL4030-family chip, another * controllable regulator, or a fixed supply. * * temporary HACK: ocr_mask instead of fixed supply */ //if (cpu_is_omap3505() || cpu_is_omap3517()) //mmc->slots[0].ocr_mask = MMC_VDD_165_195 | //MMC_VDD_26_27 | //MMC_VDD_27_28 | //MMC_VDD_29_30 | //MMC_VDD_30_31 | //MMC_VDD_31_32; //else mmc->slots[0].built_in = c->built_in; if (cpu_is_omap44xx()) { if (omap_rev() > OMAP4430_REV_ES1_0) mmc->slots[0].features |= HSMMC_HAS_UPDATED_RESET; if (c->mmc >= 3 && c->mmc <= 5) mmc->slots[0].features |= HSMMC_HAS_48MHZ_MASTER_CLK; } //if (c->mmc_data) { //memcpy(&mmc->slots[0].mmc_data, c->mmc_data, //sizeof(struct mmc_platform_data)); //mmc->slots[0].card_detect = //(mmc_card_detect_func)c->mmc_data->status; //} /* * NOTE: MMC slots should have a Vcc regulator set up. * This may be from a TWL4030-family chip, another * controllable regulator, or a fixed supply. * * temporary HACK: ocr_mask instead of fixed supply */ mmc->slots[0].ocr_mask = c->ocr_mask; if (cpu_is_omap3517() || cpu_is_omap3505()) mmc->slots[0].set_power = nop_mmc_set_power; else mmc->slots[0].features |= HSMMC_HAS_PBIAS; if (cpu_is_omap44xx() && (omap_rev() > OMAP4430_REV_ES1_0)) mmc->slots[0].features |= HSMMC_HAS_UPDATED_RESET; switch (c->mmc) { case 1: if (mmc->slots[0].features & HSMMC_HAS_PBIAS) { /* on-chip level shifting via PBIAS0/PBIAS1 */ if (cpu_is_omap44xx()) { mmc->slots[0].before_set_reg = omap4_hsmmc1_before_set_reg; mmc->slots[0].after_set_reg = omap4_hsmmc1_after_set_reg; } else { mmc->slots[0].before_set_reg = omap_hsmmc1_before_set_reg; mmc->slots[0].after_set_reg = omap_hsmmc1_after_set_reg; } } /* OMAP3630 HSMMC1 supports only 4-bit */ if (cpu_is_omap3630() && (c->caps & MMC_CAP_8_BIT_DATA)) { c->caps &= ~MMC_CAP_8_BIT_DATA; c->caps |= MMC_CAP_4_BIT_DATA; mmc->slots[0].caps = c->caps; } break; case 2: if (c->ext_clock) c->transceiver = 1; if (c->transceiver && (c->caps & MMC_CAP_8_BIT_DATA)) { c->caps &= ~MMC_CAP_8_BIT_DATA; c->caps |= MMC_CAP_4_BIT_DATA; } /* FALLTHROUGH */ case 3: if (mmc->slots[0].features & HSMMC_HAS_PBIAS) { /* off-chip level shifting, or none */ mmc->slots[0].before_set_reg = hsmmc23_before_set_reg; mmc->slots[0].after_set_reg = NULL; } break; case 4: case 5: mmc->slots[0].before_set_reg = NULL; mmc->slots[0].after_set_reg = NULL; break; default: pr_err("MMC%d configuration not supported!\n", c->mmc); kfree(hc_name); return -ENODEV; } return 0; }
static int pn544_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct pn544_dev *pn544_dev = NULL; pn544_client = client; dprintk(PN544_DRV_NAME ": pn544_probe() start\n"); 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; } pn544_parse_dt(&client->dev, pn544_dev); pn544_dev->client = client; dprintk(PN544_DRV_NAME ":IRQ : %d\nVEN : %d\nFIRM : %d\n", pn544_dev->irq_gpio, pn544_dev->ven_gpio, pn544_dev->firm_gpio); ret = gpio_request(pn544_dev->irq_gpio, "nfc_int"); if (ret) { dprintk(PN544_DRV_NAME ":pn544_probe() : nfc_int request failed!\n"); goto err_int; } ret = gpio_request(pn544_dev->ven_gpio, "nfc_ven"); if (ret) { dprintk(PN544_DRV_NAME ":pn544_probe() : nfc_ven request failed!\n"); goto err_ven; } ret = gpio_request(pn544_dev->firm_gpio, "nfc_firm"); if (ret) { dprintk(PN544_DRV_NAME ":pn544_probe() : nfc_firm request failed!\n"); goto err_firm; } pn544_gpio_enable(pn544_dev); ret = gpio_direction_output(pn544_dev->ven_gpio,1); ret = gpio_direction_output(pn544_dev->firm_gpio,0); ret = gpio_direction_input(pn544_dev->irq_gpio); /* init mutex and queues */ init_waitqueue_head(&pn544_dev->read_wq); mutex_init(&pn544_dev->read_mutex); #ifdef CONFIG_LGE_NFC_PRESTANDBY mutex_init(&mode_mutex); #endif spin_lock_init(&pn544_dev->irq_enabled_lock); pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR; pn544_dev->pn544_device.name = PN544_DRV_NAME; 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; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); pn544_dev->irq_enabled = true; ret = request_irq(pn544_gpio_to_irq(pn544_dev), 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 !defined(LGE_NFC_HW_QCT_MSM8660)&&!defined(CONFIG_LGE_NFC_HW_QCT_MSM8255) enable_irq_wake(pn544_get_irq_pin(pn544_dev)); #endif pn544_disable_irq(pn544_dev); i2c_set_clientdata(client, pn544_dev); dprintk(PN544_DRV_NAME ": pn544_probe() end\n"); /* */ #ifdef CONFIG_LGE_NFC_PRESTANDBY if (pn544_validate_boot_mode()) { dprintk("%s : get in the standbyset\n", __func__); #ifdef CONFIG_LGE_NFC_MULTICORE_FASTBOOT { struct task_struct *th; th = kthread_create(pn544_factory_standby_set_thread, NULL, "pn544_factory_standby"); if (IS_ERR(th)) { ret = PTR_ERR(th); goto err_request_irq_failed; } wake_up_process(th); } #else pn544_factory_standby_set(); #endif /* */ } #endif return 0; err_request_irq_failed: misc_deregister(&pn544_dev->pn544_device); err_misc_register: mutex_destroy(&pn544_dev->read_mutex); #ifdef CONFIG_LGE_NFC_PRESTANDBY mutex_destroy(&mode_mutex); #endif gpio_free(pn544_dev->firm_gpio); err_firm: gpio_free(pn544_dev->ven_gpio); err_ven: gpio_free(pn544_dev->irq_gpio); err_int: kfree(pn544_dev); err_exit: pr_err(PN544_DRV_NAME ": pn544_dev is null\n"); pr_err(PN544_DRV_NAME ": pn544_probe() end with error!\n"); return ret; }
static int ssp_parse_dt(struct device *dev, struct ssp_data *data) { struct device_node *np = dev->of_node; enum of_gpio_flags flags; int errorno = 0; data->mcu_int1 = of_get_named_gpio_flags(np, "ssp,mcu_int1-gpio", 0, &flags); if (data->mcu_int1 < 0) { errorno = data->mcu_int1; goto dt_exit; } data->mcu_int2 = of_get_named_gpio_flags(np, "ssp,mcu_int2-gpio", 0, &flags); if (data->mcu_int2 < 0) { errorno = data->mcu_int2; goto dt_exit; } data->ap_int = of_get_named_gpio_flags(np, "ssp,ap_int-gpio", 0, &flags); if (data->ap_int < 0) { errorno = data->ap_int; goto dt_exit; } data->rst = of_get_named_gpio_flags(np, "ssp,rst-gpio", 0, &flags); if (data->rst < 0) { errorno = data->rst ; goto dt_exit; } if (of_property_read_u32(np, "ssp,acc-position", &data->accel_position)) data->accel_position = 0; if (of_property_read_u32(np, "ssp,mag-position", &data->mag_position)) data->mag_position = 0; if (of_property_read_u32(np, "ssp,sns-combination", &data->sns_combination)) data->sns_combination = 0; if (of_property_read_u32(np, "ssp,ap-rev", &data->ap_rev)) data->ap_rev = 0; if (of_property_read_u32(np, "ssp,rotation-direction", &data->rot_direction)) data->rot_direction = 0; errorno = gpio_request(data->mcu_int1, "mpu_ap_int1"); if (errorno) { printk(KERN_ERR "failed to request MCU_INT2 for SSP\n"); goto dt_exit; } errorno = gpio_direction_input(data->mcu_int1); if (errorno) { printk(KERN_ERR "failed to set mcu_int1 as input\n"); goto dt_exit; } errorno = gpio_request(data->mcu_int2, "MCU_INT2"); if (errorno) { printk(KERN_ERR "failed to request MCU_INT2 for SSP\n"); goto dt_exit; } gpio_direction_input(data->mcu_int2); errorno = gpio_request(data->ap_int, "AP_MCU_INT"); if (errorno) { printk(KERN_ERR "failed to request AP_INT for SSP\n"); goto dt_exit; } gpio_direction_output(data->ap_int, 1); errorno = gpio_request(data->rst, "MCU_RST"); if (errorno) { printk(KERN_ERR "failed to request MCU_RST for SSP\n"); goto dt_exit; } gpio_direction_output(data->rst, 1); data->reg_hub = devm_regulator_get(dev, "hub_vreg"); if (IS_ERR(data->reg_hub)) { pr_err("[SSP] could not get hub_vreg, %ld\n", PTR_ERR(data->reg_hub)); } else { regulator_enable(data->reg_hub); } data->reg_sns= devm_regulator_get(dev, "psns_vreg"); if (IS_ERR(data->reg_hub)) { pr_err("[SSP] could not get psns_vreg, %ld\n", PTR_ERR(data->reg_sns)); } else { regulator_enable(data->reg_sns); } dt_exit: return errorno; }
static ssize_t pn544_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset) { struct pn544_dev *pn544_dev = filp->private_data; char tmp[MAX_BUFFER_SIZE]; int ret; if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; pr_debug("%s : reading %zu bytes.\n", __func__, count); mutex_lock(&pn544_dev->read_mutex); if (pn544_dev && (pn544_dev->shutdown_complete == true)) { pr_info(" %s : discarding read as " \ "NFC in shutdown state\n", __func__); mutex_unlock(&pn544_dev->read_mutex); return -ENODEV; } if (!gpio_get_value(pn544_dev->irq_gpio)) { if (filp->f_flags & O_NONBLOCK) { ret = -EAGAIN; goto fail; } pn544_dev->irq_enabled = true; enable_irq(pn544_dev->client->irq); ret = wait_event_interruptible(pn544_dev->read_wq, gpio_get_value(pn544_dev->irq_gpio)); pn544_disable_irq(pn544_dev); if (ret) goto fail; } /* Read data */ mutex_lock(&pn544_dev->shutdown_mutex); ret = i2c_master_recv(pn544_dev->client, tmp, count); mutex_unlock(&pn544_dev->shutdown_mutex); mutex_unlock(&pn544_dev->read_mutex); /* pn544 seems to be slow in handling I2C read requests * so add 1ms delay after recv operation */ udelay(1000); if (ret < 0) { pr_err("%s: i2c_master_recv returned %d\n", __func__, ret); return ret; } if (ret > count) { pr_err("%s: received too many bytes from i2c (%d)\n", __func__, ret); return -EIO; } if (copy_to_user(buf, tmp, ret)) { pr_warning("%s : failed to copy to user space\n", __func__); return -EFAULT; } return ret; fail: mutex_unlock(&pn544_dev->read_mutex); return ret; }
void __init msm_8974_init_gpiomux(void) { int rc; rc = msm_gpiomux_init_dt(); if (rc) { pr_err("%s failed %d\n", __func__, rc); return; } #if defined(CONFIG_KS8851) || defined(CONFIG_KS8851_MODULE) msm_gpiomux_install(msm_eth_configs, ARRAY_SIZE(msm_eth_configs)); #endif msm_gpiomux_install(msm_blsp_configs, ARRAY_SIZE(msm_blsp_configs)); msm_gpiomux_install(msm_blsp2_uart7_configs, ARRAY_SIZE(msm_blsp2_uart7_configs)); msm_gpiomux_install(wcnss_5wire_interface, ARRAY_SIZE(wcnss_5wire_interface)); if (of_board_is_liquid()) msm_gpiomux_install_nowrite(ath_gpio_configs, ARRAY_SIZE(ath_gpio_configs)); msm_gpiomux_install(msm8974_slimbus_config, ARRAY_SIZE(msm8974_slimbus_config)); msm_gpiomux_install(msm_touch_configs, ARRAY_SIZE(msm_touch_configs)); msm_gpiomux_install(hap_lvl_shft_config, ARRAY_SIZE(hap_lvl_shft_config)); msm_gpiomux_install(msm_sensor_configs, ARRAY_SIZE(msm_sensor_configs)); msm_gpiomux_install(&sd_card_det, 1); if (machine_is_apq8074() && (of_board_is_liquid() || \ of_board_is_dragonboard())) msm_gpiomux_sdc3_install(); msm_gpiomux_sdc4_install(); msm_gpiomux_install(msm_taiko_config, ARRAY_SIZE(msm_taiko_config)); msm_gpiomux_install(msm_hsic_configs, ARRAY_SIZE(msm_hsic_configs)); msm_gpiomux_install(msm_hsic_hub_configs, ARRAY_SIZE(msm_hsic_hub_configs)); msm_gpiomux_install(msm_hdmi_configs, ARRAY_SIZE(msm_hdmi_configs)); if (of_board_is_fluid()) msm_gpiomux_install(msm_mhl_configs, ARRAY_SIZE(msm_mhl_configs)); if (of_board_is_liquid()) msm_gpiomux_install(msm8974_pri_ter_auxpcm_configs, ARRAY_SIZE(msm8974_pri_ter_auxpcm_configs)); else msm_gpiomux_install(msm8974_pri_pri_auxpcm_configs, ARRAY_SIZE(msm8974_pri_pri_auxpcm_configs)); msm_gpiomux_install(msm8974_sec_auxpcm_configs, ARRAY_SIZE(msm8974_sec_auxpcm_configs)); msm_gpiomux_install_nowrite(msm_lcd_configs, ARRAY_SIZE(msm_lcd_configs)); if (of_board_is_rumi()) msm_gpiomux_install(msm_rumi_blsp_configs, ARRAY_SIZE(msm_rumi_blsp_configs)); if (socinfo_get_platform_subtype() == PLATFORM_SUBTYPE_MDM) msm_gpiomux_install(mdm_configs, ARRAY_SIZE(mdm_configs)); if (of_board_is_dragonboard() && machine_is_apq8074()) msm_gpiomux_install(apq8074_dragonboard_ts_config, ARRAY_SIZE(apq8074_dragonboard_ts_config)); }