static int __init ledtrig_disk_init(void) { led_trigger_register_simple("disk-activity", &ledtrig_disk); led_trigger_register_simple("disk-read", &ledtrig_disk_read); led_trigger_register_simple("disk-write", &ledtrig_disk_write); led_trigger_register_simple("ide-disk", &ledtrig_ide); return 0; }
static int __init sharpsl_pm_probe(struct platform_device *pdev) { int ret; if (!pdev->dev.platform_data) return -EINVAL; sharpsl_pm.dev = &pdev->dev; sharpsl_pm.machinfo = pdev->dev.platform_data; sharpsl_pm.charge_mode = CHRG_OFF; sharpsl_pm.flags = 0; init_timer(&sharpsl_pm.ac_timer); sharpsl_pm.ac_timer.function = sharpsl_ac_timer; init_timer(&sharpsl_pm.chrg_full_timer); sharpsl_pm.chrg_full_timer.function = sharpsl_chrg_full_timer; led_trigger_register_simple("sharpsl-charge", &sharpsl_charge_led_trigger); sharpsl_pm.machinfo->init(); ret = device_create_file(&pdev->dev, &dev_attr_battery_percentage); ret |= device_create_file(&pdev->dev, &dev_attr_battery_voltage); if (ret != 0) dev_warn(&pdev->dev, "Failed to register attributes (%d)\n", ret); apm_get_power_status = sharpsl_apm_get_power_status; suspend_set_ops(&sharpsl_pm_ops); mod_timer(&sharpsl_pm.ac_timer, jiffies + msecs_to_jiffies(250)); return 0; }
static int __init amoled_init_panel(void) { int ret; printk(KERN_DEBUG "%s\n", __func__); ret = platform_device_register(&msm_device_mdp); if (ret) return ret; #if 0 /* uses spi driver temporarily */ ret = init_spi_hack(); if (ret != 0) return ret; #endif /* set gpio to proper state in the beginning */ if (gpio_switch) (*gpio_switch)(1); ret = platform_device_register(&amoled_lcdc_device); if (ret) return ret; wake_lock_init(&panel_idle_lock, WAKE_LOCK_SUSPEND, "backlight_present"); ret = platform_device_register(&amoled_backlight); if (ret) return ret; led_trigger_register_simple("lcd-backlight-gate", &amoled_lcd_backlight); return 0; }
static int __init ledtrig_sleep_init(void) { led_trigger_register_simple("sleep", &ledtrig_sleep); register_pm_notifier(&ledtrig_sleep_pm_notifier); register_early_suspend(&ledtrig_sleep_early_suspend_handler); return 0; }
int __init eid_init(void) { int rc; vreg_lcm_2v85 = vreg_get(0, "gp4"); if (IS_ERR(vreg_lcm_2v85)) return PTR_ERR(vreg_lcm_2v85); if (machine_is_mega() || machine_is_clickc()){ vreg_lcm_2v6 = vreg_get(0, "rfrx2"); if (IS_ERR(vreg_lcm_2v6)) return PTR_ERR(vreg_lcm_2v6); } rc = platform_device_register(&msm_device_mdp); if (rc) return rc; msm_device_mddi0.dev.platform_data = &eid_pdata; rc = platform_device_register(&msm_device_mddi0); if (rc) return rc; led_trigger_register_simple("lcd-backlight-gate", &eid_lcd_backlight); if (IS_ERR(eid_lcd_backlight)) printk(KERN_ERR "%s: backlight registration failed!\n", __func__); rc = display_sysfs_init() ; if (rc) return rc ; return 0; }
static int __init ledtrig_cpu_init(void) { int cpu; /* Supports up to 9999 cpu cores */ BUILD_BUG_ON(CONFIG_NR_CPUS > 9999); /* * Registering CPU led trigger for each CPU core here * ignores CPU hotplug, but after this CPU hotplug works * fine with this trigger. */ for_each_possible_cpu(cpu) { struct led_trigger_cpu *trig = &per_cpu(cpu_trig, cpu); snprintf(trig->name, MAX_NAME_LEN, "cpu%d", cpu); led_trigger_register_simple(trig->name, &trig->_trig); } register_syscore_ops(&ledtrig_cpu_syscore_ops); register_cpu_notifier(&ledtrig_cpu_nb); pr_info("ledtrig-cpu: registered to indicate activity on CPUs\n"); return 0; }
/* * In boot loader, mddi is powered on already. * * So, we just detect panel here, setting different * power function for each panel. * * Then we did not have to detect panel in each time * mddi_client_power or panel_power is called. * * jay: Nov 20, 08' */ int __init liberty_init_panel(void) { int rc; int panel_type = 0; int panel_id = -1; // struct panel_data *panel_data = &eid_client_data.panel_conf; B(KERN_INFO "%s: enter.\n", __func__); vreg_lcm_2v6 = vreg_get(0, "gp4"); if (IS_ERR(vreg_lcm_2v6)) return PTR_ERR(vreg_lcm_2v6); vreg_lcm_2v85 = vreg_get(0, "rfrx2"); if (IS_ERR(vreg_lcm_2v85)) return PTR_ERR(vreg_lcm_2v85); panel_id = gpio_get_value(LIBERTY_GPIO_LCD_ID0) | (gpio_get_value(LIBERTY_GPIO_LCD_ID1) << 1); B(KERN_INFO "%s: panel_id:%d.\n", __func__,panel_id); switch(panel_id) { case 0: panel_type = 10; break; case 2: panel_type = 9; break; default: return -1; break; } /* panel_data->panel_id = panel_type; panel_data->caps = MSMFB_CAP_CABC; panel_data->pwm = pwm_eid; panel_data->shrink = 1; panel_data->shrink_br = liberty_panel_shrink; panel_data->default_br = 83; */ // msm_device_mdp.dev.platform_data = &liberty_mdp_pdata; rc = platform_device_register(&msm_device_mdp); if (rc) return rc; msm_device_mddi0.dev.platform_data = &liberty_pdata; rc = platform_device_register(&msm_device_mddi0); if (rc) return rc; led_trigger_register_simple("lcd-backlight-gate", &liberty_lcd_backlight); if (IS_ERR(liberty_lcd_backlight)) printk(KERN_ERR "%s: backlight registration failed!\n", __func__); return 0; }
static int power_supply_create_bat_triggers(struct power_supply *psy) { int rc = 0; psy->charging_full_trig_name = kasprintf(GFP_KERNEL, "%s-charging-or-full", psy->name); if (!psy->charging_full_trig_name) goto charging_full_failed; psy->charging_trig_name = kasprintf(GFP_KERNEL, "%s-charging", psy->name); if (!psy->charging_trig_name) goto charging_failed; psy->full_trig_name = kasprintf(GFP_KERNEL, "%s-full", psy->name); if (!psy->full_trig_name) goto full_failed; psy->charging_blink_full_solid_trig_name = kasprintf(GFP_KERNEL, "%s-charging-blink-full-solid", psy->name); if (!psy->charging_blink_full_solid_trig_name) goto charging_blink_full_solid_failed; led_trigger_register_simple(psy->charging_full_trig_name, &psy->charging_full_trig); led_trigger_register_simple(psy->charging_trig_name, &psy->charging_trig); led_trigger_register_simple(psy->full_trig_name, &psy->full_trig); led_trigger_register_simple(psy->charging_blink_full_solid_trig_name, &psy->charging_blink_full_solid_trig); goto success; charging_blink_full_solid_failed: kfree(psy->full_trig_name); full_failed: kfree(psy->charging_trig_name); charging_failed: kfree(psy->charging_full_trig_name); charging_full_failed: rc = -ENOMEM; success: return rc; }
/* * In boot loader, mddi is powered on already. * So, we just detect panel here, setting different power function for each * panel. Then we did not have to detect panel in each time mddi_client_power * or panel_power is called. * * jay: Nov 20, 08' */ int __init desirec_init_panel(void) { int panel, rc; struct panel_data *config = &eid_client_data.panel_conf; if (!machine_is_desirec()) return -1; B(KERN_INFO "%s: enter.\n", __func__); vreg_lcm_2v6 = vreg_get(0, "synt"); if (IS_ERR(vreg_lcm_2v6)) return PTR_ERR(vreg_lcm_2v6); vreg_lcm_2v85 = vreg_get(0, "gp5"); if (IS_ERR(vreg_lcm_2v85)) return PTR_ERR(vreg_lcm_2v85); panel = desirec_panel_detect(); if (panel == PANEL_HEROC_EID_BOTTOM || panel == PANEL_EIDII || panel == PANEL_HEROC_TPO) { printk(KERN_INFO "%s: init %s panel\n", __func__, panel == PANEL_HEROC_TPO ? "TPO" : "EID"); config->panel_id = panel; config->caps = MSMFB_CAP_CABC; if (panel == PANEL_HEROC_EID_BOTTOM || panel == PANEL_EIDII) config->pwm = pwm_eid; else config->pwm = pwm_tpo; config->shrink = 1; config->min_level = 3; } else { printk(KERN_ERR "unknown panel type!\n"); return -EIO; } rc = platform_device_register(&msm_device_mdp); if (rc) return rc; rc = config_vsync(); if (rc) return rc; msm_device_mddi0.dev.platform_data = &desirec_pdata; rc = platform_device_register(&msm_device_mddi0); if (rc) return rc; led_trigger_register_simple("lcd-backlight-gate", &desirec_lcd_backlight); if (IS_ERR(desirec_lcd_backlight)) printk(KERN_ERR "%s: backlight registration failed!\n", __func__); return 0; }
static int __init wmt_bl_init(void) { int rc; rc = parse_backlight_param(); if (rc) return rc; led_trigger_register_simple("genesis", &genesis_led); return platform_device_register(&wm8880_device_pwmbl); }
static int mipi_orise_lcd_init(void) { led_trigger_register_simple("bkl_trigger", &bkl_led_trigger); pr_info("%s: SUCCESS (WLED TRIGGER)\n", __func__); wled_trigger_initialized = 1; atomic_set(&lcd_power_state, 1); mipi_dsi_buf_alloc(&orise_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&orise_rx_buf, DSI_BUF_SIZE); return platform_driver_register(&this_driver); }
/* ------------------------------------------------------------------------- */ static int shcamled_torch_probe(struct platform_device *pdev) { int ret; SHCAMLED_TRACE("%s in\n", __FUNCTION__); led_trigger_register_simple("flash0_trigger", &cam_torch_flash_0_trigger); led_trigger_register_simple("flash1_trigger", &cam_torch_flash_1_trigger); led_trigger_register_simple("torch_trigger", &cam_torch_led_1_trigger); ret = device_create_file(&pdev->dev, &dev_attr_shcamled_torch); if (ret) { SHCAMLED_ERROR("%s failed create file \n", __FUNCTION__); return ret; } init_waitqueue_head(&shcamled_msg_off_wait); init_waitqueue_head(&shcamled_msg_on_wait); p_flash_off_thread = kthread_create(flash_off_thread, &shcamled_mut, "flash_off_thread"); if(p_flash_off_thread != NULL){ wake_up_process(p_flash_off_thread); SHCAMLED_TRACE("%s %d wake_up_process\n", __FUNCTION__, __LINE__); } else { SHCAMLED_TRACE("%s %d p_flash_off_thread =%p\n", __FUNCTION__, __LINE__, p_flash_off_thread); } p_flash_on_thread = kthread_create(flash_on_thread, &shcamled_mut, "flash_on_thread"); if(p_flash_on_thread != NULL){ wake_up_process(p_flash_on_thread); SHCAMLED_TRACE("%s %d wake_up_process\n", __FUNCTION__, __LINE__); } else { SHCAMLED_TRACE("%s %d p_flash_on_thread =%p\n", __FUNCTION__, __LINE__, p_flash_on_thread); } atomic_set(&flash_on_prepare, 0); SHCAMLED_TRACE("%s done ret:%d\n", __FUNCTION__, ret); return ret; }
static int __init ledtrig_cpu_init(void) { int cpu; int ret; /* Supports up to 9999 cpu cores */ BUILD_BUG_ON(CONFIG_NR_CPUS > 9999); /* * Registering a trigger for all CPUs. */ led_trigger_register_simple("cpu", &trig_cpu_all); /* * Registering CPU led trigger for each CPU core here * ignores CPU hotplug, but after this CPU hotplug works * fine with this trigger. */ for_each_possible_cpu(cpu) { struct led_trigger_cpu *trig = &per_cpu(cpu_trig, cpu); snprintf(trig->name, MAX_NAME_LEN, "cpu%d", cpu); led_trigger_register_simple(trig->name, &trig->_trig); } register_syscore_ops(&ledtrig_cpu_syscore_ops); ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "leds/trigger:starting", ledtrig_online_cpu, ledtrig_prepare_down_cpu); if (ret < 0) pr_err("CPU hotplug notifier for ledtrig-cpu could not be registered: %d\n", ret); pr_info("ledtrig-cpu: registered to indicate activity on CPUs\n"); return 0; }
static int mipi_operaul_lcd_init(void) { if(panel_type == PANEL_ID_NONE || board_mfg_mode() == 5) { pr_info("%s panel ID = PANEL_ID_NONE\n", __func__); return 0; } led_trigger_register_simple("bkl_trigger", &bkl_led_trigger); pr_info("%s: SUCCESS (WLED TRIGGER)\n", __func__); wled_trigger_initialized = 1; atomic_set(&lcd_power_state, 1); return platform_driver_register(&this_driver); }
/* Register CAN LED triggers for a CAN device * * This is normally called from a driver's probe function */ void devm_can_led_init(struct net_device *netdev) { struct can_priv *priv = netdev_priv(netdev); void *res; res = devres_alloc(can_led_release, 0, GFP_KERNEL); if (!res) { netdev_err(netdev, "cannot register LED triggers\n"); return; } snprintf(priv->tx_led_trig_name, sizeof(priv->tx_led_trig_name), "%s-tx", netdev->name); snprintf(priv->rx_led_trig_name, sizeof(priv->rx_led_trig_name), "%s-rx", netdev->name); led_trigger_register_simple(priv->tx_led_trig_name, &priv->tx_led_trig); led_trigger_register_simple(priv->rx_led_trig_name, &priv->rx_led_trig); devres_add(&netdev->dev, res); }
static int htcleo_backlight_probe(struct platform_device *pdev) { int rc; rc = device_create_file(&pdev->dev, &dev_attr_auto_bl); printk(KERN_INFO "%s: HTCLeo Backlight connect with microP: " "Probe\n", __func__); led_trigger_register_simple("lcd-backlight-gate", &htcleo_lcd_backlight); rc = led_classdev_register(&pdev->dev, &htcleo_backlight_led); if (rc) LCMDBG("HTCLeo Backlight: failure on register led_classdev\n"); htcleo_brightness_autobacklight(0); return rc; }
static int power_supply_create_gen_triggers(struct power_supply *psy) { int rc = 0; psy->online_trig_name = kasprintf(GFP_KERNEL, "%s-online", psy->name); if (!psy->online_trig_name) goto online_failed; led_trigger_register_simple(psy->online_trig_name, &psy->online_trig); goto success; online_failed: rc = -ENOMEM; success: return rc; }
/* ------------------------------------------------------------------------- */ static int shcamled_torch_probe(struct platform_device *pdev) { int ret; SHCAMLED_TRACE("%s in\n", __FUNCTION__); led_trigger_register_simple("torch_trigger", &cam_torch_led_1_trigger); ret = device_create_file(&pdev->dev, &dev_attr_shcamled_torch); if (ret) { SHCAMLED_ERROR("%s failed create file \n", __FUNCTION__); return ret; } SHCAMLED_TRACE("%s done ret:%d\n", __FUNCTION__, ret); return ret; }
static int mipi_chimei_lcd_init(void) { led_trigger_register_simple("bkl_trigger", &bkl_led_trigger); pr_info("%s: SUCCESS (WLED TRIGGER)\n", __func__); wled_trigger_initialized = 1; mipi_dsi_buf_alloc(&chimei_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&chimei_rx_buf, DSI_BUF_SIZE); #if ESD INIT_DELAYED_WORK(&power_state_detect, power_state_detect_work); //INIT_WORK(&esd_work, check_state_work); #endif return platform_driver_register(&this_driver); }
static void __init ams_delta_init(void) { /* mux pins for uarts */ omap_cfg_reg(UART1_TX); omap_cfg_reg(UART1_RTS); /* parallel camera interface */ omap_cfg_reg(H19_1610_CAM_EXCLK); omap_cfg_reg(J15_1610_CAM_LCLK); omap_cfg_reg(L18_1610_CAM_VS); omap_cfg_reg(L15_1610_CAM_HS); omap_cfg_reg(L19_1610_CAM_D0); omap_cfg_reg(K14_1610_CAM_D1); omap_cfg_reg(K15_1610_CAM_D2); omap_cfg_reg(K19_1610_CAM_D3); omap_cfg_reg(K18_1610_CAM_D4); omap_cfg_reg(J14_1610_CAM_D5); omap_cfg_reg(J19_1610_CAM_D6); omap_cfg_reg(J18_1610_CAM_D7); iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc)); omap_board_config = ams_delta_config; omap_board_config_size = ARRAY_SIZE(ams_delta_config); omap_serial_init(); omap_register_i2c_bus(1, 100, NULL, 0); /* Clear latch2 (NAND, LCD, modem enable) */ ams_delta_latch2_write(~0, 0); omap1_usb_init(&ams_delta_usb_config); omap1_set_camera_info(&ams_delta_camera_platform_data); #ifdef CONFIG_LEDS_TRIGGERS led_trigger_register_simple("ams_delta_camera", &ams_delta_camera_led_trigger); #endif platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); #ifdef CONFIG_AMS_DELTA_FIQ ams_delta_init_fiq(); #endif omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1); }
static int pmic_charger_probe(struct platform_device *pdev) { struct pmic_charger *charger; struct pmic_charger_platform_data *pdata = pdev->dev.platform_data; charger = &pmic_charger; charger->ops = &axp192_charger_ops; charger->master = pdev->dev.parent; charger->type = platform_get_device_id(pdev)->driver_data; charger->pdata = pdata; wake_lock_init(&charger->wakelock, WAKE_LOCK_SUSPEND, pdev->name); led_trigger_register_simple(pdev->name, &charger->led); pmic_sysfs_register_charger(charger->ops); if (pdata->init) pdata->init(); pmic_init_charger(charger); charger->event = EVENT_ACIN_PLUGIN | EVENT_ACIN_PLUGOUT | EVENT_VBUS_PLUGIN | EVENT_VBUS_PLUGOUT | EVENT_ACIN_OVERVOLTAGE | EVENT_VBUS_OVERVOLTAGE | EVENT_CHIP_HOT | EVENT_BATT_HOT | EVENT_BATT_COLD | EVENT_BATT_PLUGIN | EVENT_BATT_CHARGING | 0; charger->nb.notifier_call = pmic_charger_event; pmic_request_irq(charger->master, &charger->nb, charger->event); platform_set_drvdata(pdev, charger); return 0; }
static int __init k2_init_panel(void) { if(panel_type == PANEL_ID_NONE) { PR_DISP_INFO("%s panel ID = PANEL_ID_NONE\n", __func__); return 0; } led_trigger_register_simple("bkl_trigger", &bkl_led_trigger); pr_info("%s: SUCCESS (WLED TRIGGER)\n", __func__); wled_trigger_initialized = 1; atomic_set(&lcd_power_state, 1); mipi_dsi_buf_alloc(&k2_panel_tx_buf, DSI_BUF_SIZE); mipi_dsi_buf_alloc(&k2_panel_rx_buf, DSI_BUF_SIZE); mipi_video_novatek_wvga_pt_init(); return platform_driver_register(&this_driver); }
static int __init h1940bt_probe(struct platform_device *pdev) { /* Configures BT serial port GPIOs */ s3c2410_gpio_cfgpin(S3C2410_GPH0, S3C2410_GPH0_nCTS0); s3c2410_gpio_pullup(S3C2410_GPH0, 1); s3c2410_gpio_cfgpin(S3C2410_GPH1, S3C2410_GPH1_OUTP); s3c2410_gpio_pullup(S3C2410_GPH1, 1); s3c2410_gpio_cfgpin(S3C2410_GPH2, S3C2410_GPH2_TXD0); s3c2410_gpio_pullup(S3C2410_GPH2, 1); s3c2410_gpio_cfgpin(S3C2410_GPH3, S3C2410_GPH3_RXD0); s3c2410_gpio_pullup(S3C2410_GPH3, 1); #ifdef CONFIG_LEDS_H1940 led_trigger_register_simple("h1940-bluetooth", &bt_led_trigger); #endif /* disable BT by default */ h1940bt_enable(0); return device_create_file(&pdev->dev, &dev_attr_enable); }
static int __init amoled_init_panel(void) { int ret; printk(KERN_DEBUG "%s\n", __func__); /* set gpio to proper state in the beginning */ if (panel_power_gpio) (*panel_power_gpio)(1); wake_lock_init(&panel_idle_lock, WAKE_LOCK_SUSPEND, "backlight_present"); ret = platform_device_register(&amoled_backlight); if (ret) return ret; led_trigger_register_simple("lcd-backlight-gate", &amoled_lcd_backlight); return 0; }
static int dsi_panel_parse_backlight(struct platform_device *pdev, struct dsi_panel_common_pdata *panel_data, char *bl_ctrl) { int rc; u32 res[6]; static const char *bl_ctrl_type; bl_ctrl_type = of_get_property(pdev->dev.of_node, "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_debug("%s: SUCCESS-> WLED TRIGGER register\n", __func__); *bl_ctrl = BL_WLED; } rc = of_property_read_u32_array(pdev->dev.of_node, "qcom,mdss-pan-bl-levels", res, 2); panel_data->panel_info.bl_min = (!rc ? res[0] : 0); panel_data->panel_info.bl_max = (!rc ? res[1] : 255); return rc; }
static void __init ams_delta_init(void) { /* mux pins for uarts */ omap_cfg_reg(UART1_TX); omap_cfg_reg(UART1_RTS); /* parallel camera interface */ omap_cfg_reg(H19_1610_CAM_EXCLK); omap_cfg_reg(J15_1610_CAM_LCLK); omap_cfg_reg(L18_1610_CAM_VS); omap_cfg_reg(L15_1610_CAM_HS); omap_cfg_reg(L19_1610_CAM_D0); omap_cfg_reg(K14_1610_CAM_D1); omap_cfg_reg(K15_1610_CAM_D2); omap_cfg_reg(K19_1610_CAM_D3); omap_cfg_reg(K18_1610_CAM_D4); omap_cfg_reg(J14_1610_CAM_D5); omap_cfg_reg(J19_1610_CAM_D6); omap_cfg_reg(J18_1610_CAM_D7); omap_serial_init(); omap_register_i2c_bus(1, 100, NULL, 0); omap1_usb_init(&ams_delta_usb_config); omap1_set_camera_info(&ams_delta_camera_platform_data); #ifdef CONFIG_LEDS_TRIGGERS led_trigger_register_simple("ams_delta_camera", &ams_delta_camera_led_trigger); #endif gpio_led_register_device(-1, &leds_pdata); platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices)); ams_delta_init_fiq(); omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1); omapfb_set_lcd_config(&ams_delta_lcd_config); }
static int mdss_panel_parse_dt(struct platform_device *pdev, struct mdss_panel_common_pdata *panel_data) { struct device_node *np = pdev->dev.of_node; u32 res[6], tmp; u32 fbc_res[7]; int rc, i, len; const char *data; static const char *bl_ctrl_type, *pdest; bool fbc_enabled = false; 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; } panel_data->panel_info.xres = (!rc ? res[0] : 640); panel_data->panel_info.yres = (!rc ? res[1] : 480); rc = of_property_read_u32(np, "qcom,mdss-pan-id", &tmp); if (!rc) mdss_panel_id = tmp; pr_info("%s: Panel ID = %d\n", __func__, mdss_panel_id); mdss_panel_flip_ud = of_property_read_bool(np, "qcom,mdss-pan-flip-ud"); if (mdss_panel_flip_ud) pr_info("%s: Panel FLIP UD\n", __func__); rc = of_property_read_u32_array(np, "qcom,mdss-pan-active-res", res, 2); if (rc == 0) { panel_data->panel_info.lcdc.xres_pad = panel_data->panel_info.xres - res[0]; panel_data->panel_info.lcdc.yres_pad = panel_data->panel_info.yres - res[1]; } 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; } panel_data->panel_info.bpp = (!rc ? tmp : 24); rc = of_property_read_u32(np, "qcom,mdss-pan-width", &tmp); if (rc) pr_warn("%s:%d, panel width not specified\n", __func__, __LINE__); panel_data->panel_info.width = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-height", &tmp); if (rc) pr_warn("%s:%d, panel height not specified\n", __func__, __LINE__); panel_data->panel_info.height = (!rc ? tmp : 0); pdest = of_get_property(pdev->dev.of_node, "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)) panel_data->panel_info.pdest = DISPLAY_1; else if (!strncmp(pdest, "display_2", 9)) panel_data->panel_info.pdest = DISPLAY_2; else { pr_debug("%s: pdest not specified. Set Default\n", __func__); panel_data->panel_info.pdest = DISPLAY_1; } rc = of_property_read_u32_array(np, "qcom,mdss-pan-porch-values", res, 6); panel_data->panel_info.lcdc.h_back_porch = (!rc ? res[0] : 6); panel_data->panel_info.lcdc.h_pulse_width = (!rc ? res[1] : 2); panel_data->panel_info.lcdc.h_front_porch = (!rc ? res[2] : 6); panel_data->panel_info.lcdc.v_back_porch = (!rc ? res[3] : 6); panel_data->panel_info.lcdc.v_pulse_width = (!rc ? res[4] : 2); panel_data->panel_info.lcdc.v_front_porch = (!rc ? res[5] : 6); rc = of_property_read_u32(np, "qcom,mdss-pan-underflow-clr", &tmp); panel_data->panel_info.lcdc.underflow_clr = (!rc ? tmp : 0xff); bl_ctrl_type = of_get_property(pdev->dev.of_node, "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_debug("%s: SUCCESS-> WLED TRIGGER register\n", __func__); panel_data->panel_info.bklt_ctrl = BL_WLED; } else if (!strncmp(bl_ctrl_type, "bl_ctrl_pwm", 11)) { panel_data->panel_info.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; } panel_data->panel_info.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; } panel_data->panel_info.pwm_lpg_chan = tmp; tmp = of_get_named_gpio(np, "qcom,pwm-pmic-gpio", 0); panel_data->panel_info.pwm_pmic_gpio = tmp; } else if (!strncmp(bl_ctrl_type, "bl_ctrl_dcs", 11)) { panel_data->panel_info.bklt_ctrl = BL_DCS_CMD; } else { pr_debug("%s: Unknown backlight control\n", __func__); panel_data->panel_info.bklt_ctrl = UNKNOWN_CTRL; } rc = of_property_read_u32_array(np, "qcom,mdss-pan-bl-levels", res, 2); panel_data->panel_info.bl_min = (!rc ? res[0] : 0); panel_data->panel_info.bl_max = (!rc ? res[1] : 255); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-mode", &tmp); panel_data->panel_info.mipi.mode = (!rc ? tmp : DSI_VIDEO_MODE); rc = of_property_read_u32(np, "qcom,mdss-vsync-enable", &tmp); panel_data->panel_info.mipi.vsync_enable = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-hw-vsync-mode", &tmp); panel_data->panel_info.mipi.hw_vsync_mode = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-h-pulse-mode", &tmp); panel_data->panel_info.mipi.pulse_mode_hsa_he = (!rc ? tmp : false); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-h-power-stop", res, 3); panel_data->panel_info.mipi.hbp_power_stop = (!rc ? res[0] : false); panel_data->panel_info.mipi.hsa_power_stop = (!rc ? res[1] : false); panel_data->panel_info.mipi.hfp_power_stop = (!rc ? res[2] : false); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-bllp-power-stop", res, 2); panel_data->panel_info.mipi.bllp_power_stop = (!rc ? res[0] : false); panel_data->panel_info.mipi.eof_bllp_power_stop = (!rc ? res[1] : false); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-traffic-mode", &tmp); panel_data->panel_info.mipi.traffic_mode = (!rc ? tmp : DSI_NON_BURST_SYNCH_PULSE); rc = of_property_read_u32(np, "qcom,mdss-pan-insert-dcs-cmd", &tmp); panel_data->panel_info.mipi.insert_dcs_cmd = (!rc ? tmp : 1); rc = of_property_read_u32(np, "qcom,mdss-pan-wr-mem-continue", &tmp); panel_data->panel_info.mipi.wr_mem_continue = (!rc ? tmp : 0x3c); rc = of_property_read_u32(np, "qcom,mdss-pan-wr-mem-start", &tmp); panel_data->panel_info.mipi.wr_mem_start = (!rc ? tmp : 0x2c); rc = of_property_read_u32(np, "qcom,mdss-pan-te-sel", &tmp); panel_data->panel_info.mipi.te_sel = (!rc ? tmp : 1); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-dst-format", &tmp); panel_data->panel_info.mipi.dst_format = (!rc ? tmp : DSI_VIDEO_DST_FORMAT_RGB888); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-vc", &tmp); panel_data->panel_info.mipi.vc = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-rgb-swap", &tmp); panel_data->panel_info.mipi.rgb_swap = (!rc ? tmp : DSI_RGB_SWAP_RGB); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-data-lanes", res, 4); panel_data->panel_info.mipi.data_lane0 = (!rc ? res[0] : true); panel_data->panel_info.mipi.data_lane1 = (!rc ? res[1] : false); panel_data->panel_info.mipi.data_lane2 = (!rc ? res[2] : false); panel_data->panel_info.mipi.data_lane3 = (!rc ? res[3] : false); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-dlane-swap", &tmp); panel_data->panel_info.mipi.dlane_swap = (!rc ? tmp : 0); rc = of_property_read_u32_array(np, "qcom,mdss-pan-dsi-t-clk", res, 2); panel_data->panel_info.mipi.t_clk_pre = (!rc ? res[0] : 0x24); panel_data->panel_info.mipi.t_clk_post = (!rc ? res[1] : 0x03); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-stream", &tmp); panel_data->panel_info.mipi.stream = (!rc ? tmp : 0); rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-mdp-tr", &tmp); panel_data->panel_info.mipi.mdp_trigger = (!rc ? tmp : DSI_CMD_TRIGGER_SW); if (panel_data->panel_info.mipi.mdp_trigger > 6) { pr_err("%s:%d, Invalid mdp trigger. Forcing to sw trigger", __func__, __LINE__); panel_data->panel_info.mipi.mdp_trigger = DSI_CMD_TRIGGER_SW; } rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-dma-tr", &tmp); panel_data->panel_info.mipi.dma_trigger = (!rc ? tmp : DSI_CMD_TRIGGER_SW); if (panel_data->panel_info.mipi.dma_trigger > 6) { pr_err("%s:%d, Invalid dma trigger. Forcing to sw trigger", __func__, __LINE__); panel_data->panel_info.mipi.dma_trigger = DSI_CMD_TRIGGER_SW; } rc = of_property_read_u32(np, "qcom,mdss-pan-dsi-frame-rate", &tmp); panel_data->panel_info.mipi.frame_rate = (!rc ? tmp : 60); rc = of_property_read_u32(np, "qcom,mdss-pan-clk-rate", &tmp); panel_data->panel_info.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]; panel_data->panel_info.mipi.dsi_phy_db = &phy_params; fbc_enabled = of_property_read_bool(np, "qcom,fbc-enabled"); if (fbc_enabled) { pr_debug("%s:%d FBC panel enabled.\n", __func__, __LINE__); panel_data->panel_info.fbc.enabled = 1; rc = of_property_read_u32_array(np, "qcom,fbc-mode", fbc_res, 7); panel_data->panel_info.fbc.target_bpp = (!rc ? fbc_res[0] : panel_data->panel_info.bpp); panel_data->panel_info.fbc.comp_mode = (!rc ? fbc_res[1] : 0); panel_data->panel_info.fbc.qerr_enable = (!rc ? fbc_res[2] : 0); panel_data->panel_info.fbc.cd_bias = (!rc ? fbc_res[3] : 0); panel_data->panel_info.fbc.pat_enable = (!rc ? fbc_res[4] : 0); panel_data->panel_info.fbc.vlc_enable = (!rc ? fbc_res[5] : 0); panel_data->panel_info.fbc.bflc_enable = (!rc ? fbc_res[6] : 0); rc = of_property_read_u32_array(np, "qcom,fbc-budget-ctl", fbc_res, 3); panel_data->panel_info.fbc.line_x_budget = (!rc ? fbc_res[0] : 0); panel_data->panel_info.fbc.block_x_budget = (!rc ? fbc_res[1] : 0); panel_data->panel_info.fbc.block_budget = (!rc ? fbc_res[2] : 0); rc = of_property_read_u32_array(np, "qcom,fbc-lossy-mode", fbc_res, 4); panel_data->panel_info.fbc.lossless_mode_thd = (!rc ? fbc_res[0] : 0); panel_data->panel_info.fbc.lossy_mode_thd = (!rc ? fbc_res[1] : 0); panel_data->panel_info.fbc.lossy_rgb_thd = (!rc ? fbc_res[2] : 0); panel_data->panel_info.fbc.lossy_mode_idx = (!rc ? fbc_res[3] : 0); } else { pr_debug("%s:%d Panel does not support FBC.\n", __func__, __LINE__); panel_data->panel_info.fbc.enabled = 0; panel_data->panel_info.fbc.target_bpp = panel_data->panel_info.bpp; } mdss_dsi_parse_dcs_cmds(np, &panel_data->on_cmds, "qcom,panel-on-cmds", "qcom,on-cmds-dsi-state"); mdss_dsi_parse_dcs_cmds(np, &panel_data->off_cmds, "qcom,panel-off-cmds", "qcom,off-cmds-dsi-state"); return 0; error: return -EINVAL; }
static int32_t msm_led_get_dt_data(struct device_node *of_node, struct msm_led_flash_ctrl_t *fctrl) { int32_t rc = 0, i = 0; struct msm_camera_gpio_conf *gconf = NULL; struct device_node *flash_src_node = NULL; struct msm_camera_sensor_board_info *flashdata = NULL; uint32_t count = 0; uint16_t *gpio_array = NULL; uint16_t gpio_array_size = 0; uint32_t id_info[3]; CDBG("called\n"); if (!of_node) { pr_err("of_node NULL\n"); return -EINVAL; } fctrl->flashdata = kzalloc(sizeof( struct msm_camera_sensor_board_info), GFP_KERNEL); if (!fctrl->flashdata) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } flashdata = fctrl->flashdata; flashdata->sensor_init_params = kzalloc(sizeof( struct msm_sensor_init_params), GFP_KERNEL); if (!flashdata->sensor_init_params) { pr_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } rc = of_property_read_u32(of_node, "cell-index", &fctrl->subdev_id); if (rc < 0) { pr_err("failed\n"); return -EINVAL; } CDBG("subdev id %d\n", fctrl->subdev_id); rc = of_property_read_string(of_node, "qcom,flash-name", &flashdata->sensor_name); CDBG("%s qcom,flash-name %s, rc %d\n", __func__, flashdata->sensor_name, rc); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR1; } if (of_get_property(of_node, "qcom,flash-source", &count)) { count /= sizeof(uint32_t); CDBG("count %d\n", count); if (count > MAX_LED_TRIGGERS) { pr_err("failed\n"); return -EINVAL; } for (i = 0; i < count; i++) { flash_src_node = of_parse_phandle(of_node, "qcom,flash-source", i); if (!flash_src_node) { pr_err("flash_src_node NULL\n"); continue; } rc = of_property_read_string(flash_src_node, "linux,default-trigger", &fctrl->led_trigger_name[i]); if (rc < 0) { pr_err("failed\n"); of_node_put(flash_src_node); continue; } CDBG("default trigger %s\n", fctrl->led_trigger_name[i]); rc = of_property_read_u32(flash_src_node, "qcom,max-current", &fctrl->op_current[i]); if (rc < 0) { pr_err("failed rc %d\n", rc); of_node_put(flash_src_node); continue; } of_node_put(flash_src_node); CDBG("max_current[%d] %d\n", i, fctrl->op_current[i]); led_trigger_register_simple( fctrl->led_trigger_name[i], &fctrl->led_trigger[i]); } } else { flashdata->gpio_conf = kzalloc(sizeof(struct msm_camera_gpio_conf), GFP_KERNEL); if (!flashdata->gpio_conf) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; return rc; } gconf = flashdata->gpio_conf; gpio_array_size = of_gpio_count(of_node); CDBG("%s gpio count %d\n", __func__, gpio_array_size); if (gpio_array_size) { gpio_array = kzalloc(sizeof(uint16_t) * gpio_array_size, GFP_KERNEL); if (!gpio_array) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR4; } for (i = 0; i < gpio_array_size; i++) { gpio_array[i] = of_get_gpio(of_node, i); CDBG("%s gpio_array[%d] = %d\n", __func__, i, gpio_array[i]); } rc = msm_sensor_get_dt_gpio_req_tbl(of_node, gconf, gpio_array, gpio_array_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR4; } rc = msm_sensor_get_dt_gpio_set_tbl(of_node, gconf, gpio_array, gpio_array_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR5; } rc = msm_flash_init_gpio_pin_tbl(of_node, gconf, gpio_array, gpio_array_size); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR6; } } flashdata->slave_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL); if (!flashdata->slave_info) { pr_err("%s failed %d\n", __func__, __LINE__); rc = -ENOMEM; goto ERROR8; } rc = of_property_read_u32_array(of_node, "qcom,slave-id", id_info, 3); if (rc < 0) { pr_err("%s failed %d\n", __func__, __LINE__); goto ERROR9; } fctrl->flashdata->slave_info->sensor_slave_addr = id_info[0]; fctrl->flashdata->slave_info->sensor_id_reg_addr = id_info[1]; fctrl->flashdata->slave_info->sensor_id = id_info[2]; kfree(gpio_array); return rc; ERROR9: kfree(fctrl->flashdata->slave_info); ERROR8: kfree(fctrl->flashdata->gpio_conf->gpio_num_info); ERROR6: kfree(gconf->cam_gpio_set_tbl); ERROR5: kfree(gconf->cam_gpio_req_tbl); ERROR4: kfree(gconf); ERROR1: kfree(fctrl->flashdata); kfree(gpio_array); } return rc; }
/* * In boot loader, mddi is powered on already. * * So, we just detect panel here, setting different * power function for each panel. * * Then we did not have to detect panel in each time * mddi_client_power or panel_power is called. * * jay: Nov 20, 08' */ int __init latte_init_panel(void) { int rc; int panel_type = 0; int panel_id = -1; int gpio_lcd_id0, gpio_lcd_id1; uint32_t config; struct panel_data *panel_data = &eid_client_data.panel_conf; if (!machine_is_latte()) return -1; B(KERN_INFO "%s: enter.\n", __func__); vreg_lcm_2v6 = vreg_get(0, "gp4"); if (IS_ERR(vreg_lcm_2v6)) return PTR_ERR(vreg_lcm_2v6); vreg_lcm_2v85 = vreg_get(0, "rfrx2"); if (IS_ERR(vreg_lcm_2v85)) return PTR_ERR(vreg_lcm_2v85); gpio_lcd_id0 = PCOM_GPIO_CFG(LATTE_GPIO_LCD_ID0, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA); gpio_lcd_id1 = PCOM_GPIO_CFG(LATTE_GPIO_LCD_ID1, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA); msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &gpio_lcd_id0, 0); msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &gpio_lcd_id1, 0); panel_id = gpio_get_value(LATTE_GPIO_LCD_ID0) | (gpio_get_value(LATTE_GPIO_LCD_ID1) << 1); B(KERN_INFO "%s: panel_id: %d\n", __func__, panel_id); switch(panel_id) { case 0: panel_type = 8; break; case 1: panel_type = 7; break; default: return -1; break; } panel_data->panel_id = panel_type; panel_data->caps = MSMFB_CAP_CABC; panel_data->pwm = pwm_eid; panel_data->shrink = 1; panel_data->shrink_br = latte_panel_shrink; config = PCOM_GPIO_CFG(LATTE_GPIO_LCD_VSYNC, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA); msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0); rc = platform_device_register(&msm_device_mdp); if (rc) return rc; msm_device_mddi0.dev.platform_data = &latte_pdata; rc = platform_device_register(&msm_device_mddi0); if (rc) return rc; led_trigger_register_simple("lcd-backlight-gate", &latte_lcd_backlight); if (IS_ERR(latte_lcd_backlight)) printk(KERN_ERR "%s: backlight registration failed!\n", __func__); return 0; }
static int __init ledtrig_power_off_init(void) { led_trigger_register_simple("power-off", &power_off_led_trigger); return 0; }