| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (c) 2019 MediaTek Inc. |
| */ |
| |
| #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ |
| |
| #include <linux/types.h> |
| #include <linux/init.h> |
| #include <linux/module.h> |
| #include <linux/device.h> |
| #include <linux/platform_device.h> |
| #include <linux/hrtimer.h> |
| #include <linux/ktime.h> |
| #include <linux/workqueue.h> |
| #include <linux/mutex.h> |
| #include <linux/of.h> |
| #include <linux/list.h> |
| #include <linux/delay.h> |
| |
| #include "mt6336/mt6336.h" |
| #include "flashlight-core.h" |
| #include "flashlight-dt.h" |
| |
| /* device tree should be defined in flashlight-dt.h */ |
| #ifndef MT6336_DTNAME |
| #define MT6336_DTNAME "mediatek,flashlights_mt6336" |
| #endif |
| |
| #define MT6336_NAME "flashlights-mt6336" |
| |
| /* define channel, level */ |
| #define MT6336_CHANNEL_NUM 2 |
| #define MT6336_CHANNEL_CH1 0 |
| #define MT6336_CHANNEL_CH2 1 |
| |
| #define MT6336_NONE (-1) |
| #define MT6336_DISABLE 0 |
| #define MT6336_ENABLE 1 |
| #define MT6336_ENABLE_TORCH 1 |
| #define MT6336_ENABLE_FLASH 2 |
| |
| #define MT6336_LEVEL_NUM 34 |
| #define MT6336_LEVEL_TORCH 8 |
| #define MT6336_WDT_TIMEOUT 600 /* ms */ |
| #define MT6336_HW_TIMEOUT 600 /* ms */ |
| |
| /* define mutex, work queue and timer */ |
| static DEFINE_MUTEX(mt6336_mutex); |
| static struct work_struct mt6336_work_ch1; |
| static struct work_struct mt6336_work_ch2; |
| static struct hrtimer mt6336_timer_ch1; |
| static struct hrtimer mt6336_timer_ch2; |
| static unsigned int mt6336_timeout_ms[MT6336_CHANNEL_NUM]; |
| |
| /* define usage count */ |
| static int use_count; |
| |
| /* mt6336 pmic control handler */ |
| static struct mt6336_ctrl *flashlight_ctrl; |
| |
| /* platform data */ |
| struct mt6336_platform_data { |
| int channel_num; |
| struct flashlight_device_id *dev_id; |
| }; |
| |
| |
| /****************************************************************************** |
| * mt6336 operations |
| *****************************************************************************/ |
| static const int mt6336_current[MT6336_LEVEL_NUM] = { |
| 25, 50, 75, 100, 125, 150, 175, 200, 250, 300, |
| 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, |
| 850, 900, 950, 1000, 1050, 1100, 1150, 1200, 1250, 1300, |
| 1350, 1400, 1450, 1500 |
| }; |
| |
| static const unsigned char mt6336_level[MT6336_LEVEL_NUM] = { |
| 0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F, 0x13, 0x17, |
| 0x1B, 0x1F, 0x23, 0x27, 0x2B, 0x2F, 0x33, 0x37, 0x3B, 0x3F, |
| 0x43, 0x47, 0x4B, 0x4F, 0x53, 0x57, 0x5B, 0x5F, 0x63, 0x67, |
| 0x6B, 0x6F, 0x73, 0x77 |
| }; |
| |
| static int is_preenable; |
| static int mt6336_decouple_mode; |
| static int mt6336_en_ch1; |
| static int mt6336_en_ch2; |
| static int mt6336_level_ch1; |
| static int mt6336_level_ch2; |
| |
| static int mt6336_is_torch(int level) |
| { |
| if (level >= MT6336_LEVEL_TORCH) |
| return -1; |
| |
| return 0; |
| } |
| |
| static int mt6336_verify_level(int level) |
| { |
| if (level < 0) |
| level = 0; |
| else if (level >= MT6336_LEVEL_NUM) |
| level = MT6336_LEVEL_NUM - 1; |
| |
| return level; |
| } |
| |
| /* pre-enable steps before enable flashlight */ |
| static int mt6336_preenable(void) |
| { |
| int ret; |
| |
| ret = mt6336_set_register_value(0x0519, 0x0A); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_EN, 0x06); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_CLAMP_EN, 0x01); |
| */ |
| |
| ret = mt6336_set_register_value(0x0520, 0x00); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_TUNE_SYS_MSB, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x055A, 0x01); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_SWCHR_RSV_TRIM_MSB, 0x01); |
| */ |
| |
| ret = mt6336_set_register_value(0x0455, 0x00); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_EN_HW_GAIN_SET, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x03C9, 0x00); |
| /* mt6336_set_flag_register_value( |
| * MT6336_AUXADC_HWGAIN_EN, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x0553, 0x54); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_DTC, 0x01); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_SRCEH, 0x01); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_SRC, 0x01); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_VTHSEL, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x055F, 0xE0); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_FTR_RC, 0x03); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_FTR_DROP, 0x04); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_FTR_SHOOT_EN, 0x00); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_FTR_DROP_EN, 0x00); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_SWCHR_ZCD_TRIM_EN, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x053D, 0x45); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_VRAMP_SLP, 0x04); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_VRAMP_DCOS, 0x05); |
| */ |
| |
| /* only way to verify register is to get again */ |
| ret = 0; |
| |
| return ret; |
| } |
| |
| /* post-enable steps after enable flashlight */ |
| static int mt6336_postenable(void) |
| { |
| int ret; |
| |
| ret = mt6336_set_register_value(0x052A, 0x88); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_RSV_LSB, 0x88); |
| */ |
| |
| ret = mt6336_set_register_value(0x0553, 0x14); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_DTC, 0x00); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_SRCEH, 0x01); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_SRC, 0x01); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_PWR_LG_VTHSEL, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x0519, 0x3E); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_EN, 0x1F); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_CLAMP_EN, 0x01); |
| */ |
| |
| ret = mt6336_set_register_value(0x051E, 0x02); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_TUNE_ICHIN_MSB, 0x02); |
| */ |
| |
| ret = mt6336_set_register_value(0x0520, 0x04); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_TUNE_SYS_MSB, 0x04); |
| */ |
| |
| ret = mt6336_set_register_value(0x055A, 0x00); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_SWCHR_RSV_TRIM_MSB, 0x00); |
| */ |
| |
| ret = mt6336_set_register_value(0x0455, 0x01); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_EN_HW_GAIN_SET, 0x01); |
| */ |
| |
| ret = mt6336_set_register_value(0x03C9, 0x10); |
| /* mt6336_set_flag_register_value( |
| * MT6336_AUXADC_HWGAIN_EN, 0x01); |
| */ |
| |
| ret = mt6336_set_register_value(0x03CF, 0x03); |
| /* mt6336_set_flag_register_value( |
| * MT6336_AUXADC_HWGAIN_DET_PRD_M, 0x03); |
| */ |
| |
| ret = mt6336_set_register_value(0x0402, 0x03); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_DIS_REVFET, 0x00); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_T_TERM_EXT, 0x00); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_EN_TERM, 0x01); |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_EN_RECHARGE, 0x01); |
| */ |
| |
| ret = mt6336_set_register_value(0x0529, 0x80); |
| /* mt6336_set_flag_register_value( |
| * MT6336_RG_A_LOOP_GM_RSV_MSB, 0x88); |
| */ |
| |
| ret = mt6336_set_register_value(0x051F, 0x84); |
| ret = mt6336_set_register_value(0x053D, 0x47); |
| |
| /* only way to verify register is to get again */ |
| ret = 0; |
| |
| return ret; |
| } |
| |
| /* flashlight enable function */ |
| static int mt6336_enable(void) |
| { |
| u8 buck_enable_status; |
| |
| mt6336_ctrl_enable(flashlight_ctrl); |
| |
| if ((mt6336_en_ch1 == MT6336_ENABLE_FLASH) |
| || (mt6336_en_ch2 == MT6336_ENABLE_FLASH)) { |
| /* flash mode */ |
| if (!mt6336_get_flag_register_value( |
| MT6336_DA_QI_OTG_MODE_MUX)) { |
| |
| /* disable charging */ |
| /* mt6336_set_register_value(0x0400, 0x00); */ |
| buck_enable_status = mt6336_get_flag_register_value( |
| MT6336_RG_EN_BUCK); |
| mt6336_set_flag_register_value(MT6336_RG_EN_BUCK, 0x00); |
| /* |
| * mt6336_set_flag_register_value( |
| * MT6336_RG_EN_CHARGE, 0x00); |
| */ |
| |
| /* pre-enable steps */ |
| mt6336_preenable(); |
| is_preenable = 1; |
| |
| /* enable flash mode, source current */ |
| if (mt6336_en_ch1) |
| mt6336_set_flag_register_value( |
| MT6336_RG_EN_IFLA1, 0x01); |
| if (mt6336_en_ch2) |
| mt6336_set_flag_register_value( |
| MT6336_RG_EN_IFLA2, 0x01); |
| mt6336_set_flag_register_value( |
| MT6336_RG_EN_LEDCS, 0x01); |
| |
| /* enable flash and apply previous buck setting */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_BUCK, |
| buck_enable_status); |
| mt6336_set_flag_register_value(MT6336_RG_EN_FLASH, |
| 0x01); |
| } else { |
| /* failed in OTG mode */ |
| pr_info("Failed to turn on flash mode since in OTG mode.\n"); |
| } |
| |
| } else { |
| /* torch mode */ |
| |
| /* pre-enable steps */ |
| if (!mt6336_get_flag_register_value( |
| MT6336_DA_QI_OTG_MODE_MUX) && |
| !mt6336_get_flag_register_value( |
| MT6336_DA_QI_VBUS_PLUGIN_MUX)) { |
| mt6336_preenable(); |
| is_preenable = 1; |
| } |
| |
| /* enable torch mode, source current and enable torch */ |
| if (mt6336_en_ch1) |
| mt6336_set_flag_register_value( |
| MT6336_RG_EN_ITOR1, 0x01); |
| if (mt6336_en_ch2) |
| mt6336_set_flag_register_value( |
| MT6336_RG_EN_ITOR2, 0x01); |
| mt6336_set_flag_register_value(MT6336_RG_EN_LEDCS, 0x01); |
| mt6336_set_flag_register_value(MT6336_RG_EN_TORCH, 0x01); |
| } |
| |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| mt6336_en_ch1 = MT6336_NONE; |
| mt6336_en_ch2 = MT6336_NONE; |
| |
| return 0; |
| } |
| |
| /* flashlight disable function */ |
| static int mt6336_disable(void) |
| { |
| mt6336_ctrl_enable(flashlight_ctrl); |
| |
| /* disable torch/flash mode */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_ITOR1, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_ITOR2, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_IFLA1, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_IFLA2, 0x00); |
| |
| /* pre-enable steps */ |
| if (is_preenable) { |
| mt6336_postenable(); |
| is_preenable = 0; |
| } |
| |
| /* disable source current and disable torch/flash */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_LEDCS, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_TORCH, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_FLASH, 0x00); |
| |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| mt6336_en_ch1 = MT6336_NONE; |
| mt6336_en_ch2 = MT6336_NONE; |
| |
| return 0; |
| } |
| |
| /* set flashlight level */ |
| static int mt6336_set_level_ch1(int level) |
| { |
| level = mt6336_verify_level(level); |
| mt6336_level_ch1 = level; |
| |
| /* set brightness level */ |
| mt6336_ctrl_enable(flashlight_ctrl); |
| mt6336_set_flag_register_value(MT6336_RG_ITOR1, mt6336_level[level]); |
| mt6336_set_flag_register_value(MT6336_RG_IFLA1, mt6336_level[level]); |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| return 0; |
| } |
| |
| static int mt6336_set_level_ch2(int level) |
| { |
| level = mt6336_verify_level(level); |
| mt6336_level_ch2 = level; |
| |
| /* set brightness level */ |
| mt6336_ctrl_enable(flashlight_ctrl); |
| mt6336_set_flag_register_value(MT6336_RG_ITOR2, mt6336_level[level]); |
| mt6336_set_flag_register_value(MT6336_RG_IFLA2, mt6336_level[level]); |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| return 0; |
| } |
| |
| static int mt6336_set_level(int channel, int level) |
| { |
| if (channel == MT6336_CHANNEL_CH1) |
| mt6336_set_level_ch1(level); |
| else if (channel == MT6336_CHANNEL_CH2) |
| mt6336_set_level_ch2(level); |
| else { |
| pr_info("Error channel\n"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int mt6336_set_scenario(int scenario) |
| { |
| /* set decouple mode */ |
| mt6336_decouple_mode = scenario & FLASHLIGHT_SCENARIO_DECOUPLE_MASK; |
| |
| return 0; |
| } |
| |
| /* flashlight init */ |
| int mt6336_init(void) |
| { |
| int ret = 0; |
| |
| mt6336_ctrl_enable(flashlight_ctrl); |
| |
| /* clear flash/torch mode enable register */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_IFLA1, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_IFLA2, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_ITOR1, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_ITOR2, 0x00); |
| |
| /* clear current source register */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_LEDCS, 0x00); |
| |
| /* clear flash/torch enable register */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_FLASH, 0x00); |
| mt6336_set_flag_register_value(MT6336_RG_EN_TORCH, 0x00); |
| |
| /* setup flash mode output regulation voltage (default: 5.0 V) */ |
| mt6336_set_flag_register_value(MT6336_RG_VFLA, 0x05); |
| |
| /* setup flash mode current step up/down timing (default: 10 us) */ |
| mt6336_set_flag_register_value(MT6336_RG_TSTEP_ILED, 0x01); |
| |
| /* setup flash/torch watchdog timeout (default: 600 ms) */ |
| mt6336_set_flag_register_value(MT6336_RG_FLA_WDT, 0x10); |
| |
| /* enable flash watchdog (default) */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_FLA_WDT, 0x01); |
| |
| /* disable torch watchdog (default) */ |
| mt6336_set_flag_register_value(MT6336_RG_EN_TOR_WDT, 0x00); |
| |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| /* clear flashlight state */ |
| mt6336_en_ch1 = MT6336_NONE; |
| mt6336_en_ch2 = MT6336_NONE; |
| |
| /* clear decouple mode */ |
| mt6336_decouple_mode = FLASHLIGHT_SCENARIO_COUPLE; |
| |
| is_preenable = 0; |
| |
| return ret; |
| } |
| |
| /* flashlight uninit */ |
| int mt6336_uninit(void) |
| { |
| /* clear flashlight state */ |
| mt6336_en_ch1 = MT6336_NONE; |
| mt6336_en_ch2 = MT6336_NONE; |
| |
| /* clear decouple mode */ |
| mt6336_decouple_mode = FLASHLIGHT_SCENARIO_COUPLE; |
| |
| return mt6336_disable(); |
| } |
| |
| |
| /****************************************************************************** |
| * Timer and work queue |
| *****************************************************************************/ |
| void mt6336_isr_short_ch1(void) |
| { |
| schedule_work(&mt6336_work_ch1); |
| } |
| |
| void mt6336_isr_short_ch2(void) |
| { |
| schedule_work(&mt6336_work_ch2); |
| } |
| |
| /****************************************************************************** |
| * Timer and work queue |
| *****************************************************************************/ |
| static void mt6336_work_disable_ch1(struct work_struct *data) |
| { |
| pr_debug("ht work queue callback\n"); |
| mt6336_disable(); |
| } |
| |
| static void mt6336_work_disable_ch2(struct work_struct *data) |
| { |
| pr_debug("lt work queue callback\n"); |
| mt6336_disable(); |
| } |
| |
| static enum hrtimer_restart mt6336_timer_func_ch1(struct hrtimer *timer) |
| { |
| schedule_work(&mt6336_work_ch1); |
| return HRTIMER_NORESTART; |
| } |
| |
| static enum hrtimer_restart mt6336_timer_func_ch2(struct hrtimer *timer) |
| { |
| schedule_work(&mt6336_work_ch2); |
| return HRTIMER_NORESTART; |
| } |
| |
| static int mt6336_timer_start(int channel, ktime_t ktime) |
| { |
| if (channel == MT6336_CHANNEL_CH1) |
| hrtimer_start(&mt6336_timer_ch1, ktime, HRTIMER_MODE_REL); |
| else if (channel == MT6336_CHANNEL_CH2) |
| hrtimer_start(&mt6336_timer_ch2, ktime, HRTIMER_MODE_REL); |
| else { |
| pr_info("Error channel\n"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int mt6336_timer_cancel(int channel) |
| { |
| if (channel == MT6336_CHANNEL_CH1) |
| hrtimer_cancel(&mt6336_timer_ch1); |
| else if (channel == MT6336_CHANNEL_CH2) |
| hrtimer_cancel(&mt6336_timer_ch2); |
| else { |
| pr_info("Error channel\n"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| /****************************************************************************** |
| * Flashlight operation wrapper function |
| *****************************************************************************/ |
| static int mt6336_operate(int channel, int enable) |
| { |
| ktime_t ktime; |
| unsigned int s; |
| unsigned int ns; |
| |
| /* setup enable/disable */ |
| if (channel == MT6336_CHANNEL_CH1) { |
| mt6336_en_ch1 = enable; |
| if (mt6336_en_ch1) |
| if (mt6336_is_torch(mt6336_level_ch1)) |
| mt6336_en_ch1 = MT6336_ENABLE_FLASH; |
| } else if (channel == MT6336_CHANNEL_CH2) { |
| mt6336_en_ch2 = enable; |
| if (mt6336_en_ch2) |
| if (mt6336_is_torch(mt6336_level_ch2)) |
| mt6336_en_ch2 = MT6336_ENABLE_FLASH; |
| } else { |
| pr_info("Error channel\n"); |
| return -1; |
| } |
| |
| /* decouple mode */ |
| if (mt6336_decouple_mode) { |
| if (channel == MT6336_CHANNEL_CH1) |
| mt6336_en_ch2 = MT6336_DISABLE; |
| else if (channel == MT6336_CHANNEL_CH2) |
| mt6336_en_ch1 = MT6336_DISABLE; |
| } |
| |
| /* operate flashlight and setup timer */ |
| if ((mt6336_en_ch1 != MT6336_NONE) && (mt6336_en_ch2 != MT6336_NONE)) { |
| if ((mt6336_en_ch1 == MT6336_DISABLE) && |
| (mt6336_en_ch2 == MT6336_DISABLE)) { |
| mt6336_disable(); |
| mt6336_timer_cancel(MT6336_CHANNEL_CH1); |
| mt6336_timer_cancel(MT6336_CHANNEL_CH2); |
| } else { |
| if (mt6336_timeout_ms[MT6336_CHANNEL_CH1]) { |
| s = mt6336_timeout_ms[MT6336_CHANNEL_CH1] / |
| 1000; |
| ns = mt6336_timeout_ms[MT6336_CHANNEL_CH1] % |
| 1000 * 1000000; |
| ktime = ktime_set(s, ns); |
| mt6336_timer_start(MT6336_CHANNEL_CH1, ktime); |
| } |
| if (mt6336_timeout_ms[MT6336_CHANNEL_CH2]) { |
| s = mt6336_timeout_ms[MT6336_CHANNEL_CH2] / |
| 1000; |
| ns = mt6336_timeout_ms[MT6336_CHANNEL_CH2] % |
| 1000 * 1000000; |
| ktime = ktime_set(s, ns); |
| mt6336_timer_start(MT6336_CHANNEL_CH2, ktime); |
| } |
| mt6336_enable(); |
| } |
| |
| /* clear flashlight state */ |
| mt6336_en_ch1 = MT6336_NONE; |
| mt6336_en_ch2 = MT6336_NONE; |
| } |
| |
| return 0; |
| } |
| |
| /****************************************************************************** |
| * Flashlight operations |
| *****************************************************************************/ |
| static int mt6336_ioctl(unsigned int cmd, unsigned long arg) |
| { |
| struct flashlight_dev_arg *fl_arg; |
| int channel; |
| |
| fl_arg = (struct flashlight_dev_arg *)arg; |
| channel = fl_arg->channel; |
| |
| /* verify channel */ |
| if (channel < 0 || channel >= MT6336_CHANNEL_NUM) { |
| pr_info("Failed with error channel\n"); |
| return -EINVAL; |
| } |
| |
| switch (cmd) { |
| case FLASH_IOC_SET_TIME_OUT_TIME_MS: |
| pr_debug("FLASH_IOC_SET_TIME_OUT_TIME_MS(%d): %d\n", |
| channel, (int)fl_arg->arg); |
| mt6336_timeout_ms[channel] = fl_arg->arg; |
| break; |
| |
| case FLASH_IOC_SET_DUTY: |
| pr_debug("FLASH_IOC_SET_DUTY(%d): %d\n", |
| channel, (int)fl_arg->arg); |
| mt6336_set_level(channel, fl_arg->arg); |
| break; |
| |
| case FLASH_IOC_SET_SCENARIO: |
| pr_debug("FLASH_IOC_SET_SCENARIO(%d): %d\n", |
| channel, (int)fl_arg->arg); |
| mt6336_set_scenario(fl_arg->arg); |
| break; |
| |
| case FLASH_IOC_SET_ONOFF: |
| pr_debug("FLASH_IOC_SET_ONOFF(%d): %d\n", |
| channel, (int)fl_arg->arg); |
| mt6336_operate(channel, fl_arg->arg); |
| break; |
| |
| case FLASH_IOC_GET_DUTY_NUMBER: |
| pr_debug("FLASH_IOC_GET_DUTY_NUMBER(%d)\n", channel); |
| fl_arg->arg = MT6336_LEVEL_NUM; |
| break; |
| |
| case FLASH_IOC_GET_MAX_TORCH_DUTY: |
| pr_debug("FLASH_IOC_GET_MAX_TORCH_DUTY(%d)\n", channel); |
| fl_arg->arg = MT6336_LEVEL_TORCH - 1; |
| break; |
| |
| case FLASH_IOC_GET_DUTY_CURRENT: |
| fl_arg->arg = mt6336_verify_level(fl_arg->arg); |
| pr_debug("FLASH_IOC_GET_DUTY_CURRENT(%d): %d\n", |
| channel, (int)fl_arg->arg); |
| fl_arg->arg = mt6336_current[fl_arg->arg]; |
| break; |
| |
| case FLASH_IOC_GET_HW_TIMEOUT: |
| pr_debug("FLASH_IOC_GET_HW_TIMEOUT(%d)\n", channel); |
| fl_arg->arg = MT6336_HW_TIMEOUT; |
| break; |
| |
| default: |
| pr_info("No such command and arg(%d): (%d, %d)\n", |
| channel, _IOC_NR(cmd), (int)fl_arg->arg); |
| return -ENOTTY; |
| } |
| |
| return 0; |
| } |
| |
| static int mt6336_open(void) |
| { |
| /* Move to set driver for saving power */ |
| return 0; |
| } |
| |
| static int mt6336_release(void) |
| { |
| /* Move to set driver for saving power */ |
| return 0; |
| } |
| |
| static int mt6336_set_driver(int set) |
| { |
| int ret = 0; |
| |
| /* set chip and usage count */ |
| mutex_lock(&mt6336_mutex); |
| if (set) { |
| if (!use_count) |
| ret = mt6336_init(); |
| use_count++; |
| pr_debug("Set driver: %d\n", use_count); |
| } else { |
| use_count--; |
| if (!use_count) |
| ret = mt6336_uninit(); |
| if (use_count < 0) |
| use_count = 0; |
| pr_debug("Unset driver: %d\n", use_count); |
| } |
| mutex_unlock(&mt6336_mutex); |
| |
| return ret; |
| } |
| |
| static ssize_t mt6336_strobe_store(struct flashlight_arg arg) |
| { |
| mt6336_set_driver(1); |
| mt6336_set_scenario(FLASHLIGHT_SCENARIO_COUPLE); |
| mt6336_set_level(arg.channel, arg.level); |
| mt6336_timeout_ms[arg.channel] = 0; |
| |
| if (arg.level < 0) |
| mt6336_operate(arg.channel, MT6336_DISABLE); |
| else |
| mt6336_operate(arg.channel, MT6336_ENABLE); |
| |
| msleep(arg.dur); |
| mt6336_operate(arg.channel, MT6336_DISABLE); |
| mt6336_set_driver(0); |
| |
| return 0; |
| } |
| |
| static struct flashlight_operations mt6336_ops = { |
| mt6336_open, |
| mt6336_release, |
| mt6336_ioctl, |
| mt6336_strobe_store, |
| mt6336_set_driver |
| }; |
| |
| |
| /****************************************************************************** |
| * Platform device and driver |
| *****************************************************************************/ |
| static int mt6336_parse_dt(struct device *dev, |
| struct mt6336_platform_data *pdata) |
| { |
| struct device_node *np, *cnp; |
| u32 decouple = 0; |
| int i = 0; |
| |
| if (!dev || !dev->of_node || !pdata) |
| return -ENODEV; |
| |
| np = dev->of_node; |
| |
| pdata->channel_num = of_get_child_count(np); |
| if (!pdata->channel_num) { |
| pr_info("Parse no dt, node.\n"); |
| return 0; |
| } |
| pr_info("Channel number(%d).\n", pdata->channel_num); |
| |
| if (of_property_read_u32(np, "decouple", &decouple)) |
| pr_info("Parse no dt, decouple.\n"); |
| |
| pdata->dev_id = devm_kzalloc(dev, |
| pdata->channel_num * |
| sizeof(struct flashlight_device_id), |
| GFP_KERNEL); |
| if (!pdata->dev_id) |
| return -ENOMEM; |
| |
| for_each_child_of_node(np, cnp) { |
| if (of_property_read_u32(cnp, "type", &pdata->dev_id[i].type)) |
| goto err_node_put; |
| if (of_property_read_u32(cnp, "ct", &pdata->dev_id[i].ct)) |
| goto err_node_put; |
| if (of_property_read_u32(cnp, "part", &pdata->dev_id[i].part)) |
| goto err_node_put; |
| snprintf(pdata->dev_id[i].name, FLASHLIGHT_NAME_SIZE, |
| MT6336_NAME); |
| pdata->dev_id[i].channel = i; |
| pdata->dev_id[i].decouple = decouple; |
| |
| pr_info("Parse dt (type,ct,part,name,channel,decouple)=(%d,%d,%d,%s,%d,%d).\n", |
| pdata->dev_id[i].type, pdata->dev_id[i].ct, |
| pdata->dev_id[i].part, pdata->dev_id[i].name, |
| pdata->dev_id[i].channel, |
| pdata->dev_id[i].decouple); |
| i++; |
| } |
| |
| return 0; |
| |
| err_node_put: |
| of_node_put(cnp); |
| return -EINVAL; |
| } |
| |
| |
| static int mt6336_probe(struct platform_device *pdev) |
| { |
| struct mt6336_platform_data *pdata = dev_get_platdata(&pdev->dev); |
| int ret; |
| int i; |
| |
| pr_debug("Probe start.\n"); |
| |
| /* parse dt */ |
| if (!pdata) { |
| pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); |
| if (!pdata) |
| return -ENOMEM; |
| pdev->dev.platform_data = pdata; |
| ret = mt6336_parse_dt(&pdev->dev, pdata); |
| if (ret) |
| return ret; |
| } |
| |
| /* init work queue */ |
| INIT_WORK(&mt6336_work_ch1, mt6336_work_disable_ch1); |
| INIT_WORK(&mt6336_work_ch2, mt6336_work_disable_ch2); |
| |
| /* init timer */ |
| hrtimer_init(&mt6336_timer_ch1, CLOCK_MONOTONIC, HRTIMER_MODE_REL); |
| mt6336_timer_ch1.function = mt6336_timer_func_ch1; |
| hrtimer_init(&mt6336_timer_ch2, CLOCK_MONOTONIC, HRTIMER_MODE_REL); |
| mt6336_timer_ch2.function = mt6336_timer_func_ch2; |
| mt6336_timeout_ms[MT6336_CHANNEL_CH1] = 600; |
| mt6336_timeout_ms[MT6336_CHANNEL_CH2] = 600; |
| |
| /* get mt6336 pmic control handler */ |
| flashlight_ctrl = mt6336_ctrl_get("mt6336_flashlight"); |
| |
| /* register and enable mt6336 pmic ISR */ |
| mt6336_ctrl_enable(flashlight_ctrl); |
| mt6336_register_interrupt_callback( |
| MT6336_INT_LED1_SHORT, mt6336_isr_short_ch1); |
| mt6336_register_interrupt_callback( |
| MT6336_INT_LED2_SHORT, mt6336_isr_short_ch2); |
| /* mt6336_register_interrupt_callback(MT6336_INT_LED1_OPEN, NULL); */ |
| /* mt6336_register_interrupt_callback(MT6336_INT_LED2_OPEN, NULL); */ |
| mt6336_enable_interrupt(MT6336_INT_LED1_SHORT, "flashlight"); |
| mt6336_enable_interrupt(MT6336_INT_LED2_SHORT, "flashlight"); |
| /* mt6336_enable_interrupt(MT6336_INT_LED1_OPEN, "flashlight"); */ |
| /* mt6336_enable_interrupt(MT6336_INT_LED2_OPEN, "flashlight"); */ |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| /* clear usage count */ |
| use_count = 0; |
| |
| /* register flashlight device */ |
| if (pdata->channel_num) { |
| for (i = 0; i < pdata->channel_num; i++) |
| if (flashlight_dev_register_by_device_id( |
| &pdata->dev_id[i], |
| &mt6336_ops)) |
| return -EFAULT; |
| } else { |
| if (flashlight_dev_register(MT6336_NAME, &mt6336_ops)) |
| return -EFAULT; |
| } |
| |
| pr_debug("Probe done.\n"); |
| |
| return 0; |
| } |
| |
| static int mt6336_remove(struct platform_device *pdev) |
| { |
| struct mt6336_platform_data *pdata = dev_get_platdata(&pdev->dev); |
| int i; |
| |
| pr_debug("Remove start.\n"); |
| |
| pdev->dev.platform_data = NULL; |
| |
| /* unregister flashlight device */ |
| if (pdata && pdata->channel_num) |
| for (i = 0; i < pdata->channel_num; i++) |
| flashlight_dev_unregister_by_device_id( |
| &pdata->dev_id[i]); |
| else |
| flashlight_dev_unregister(MT6336_NAME); |
| |
| /* flush work queue */ |
| flush_work(&mt6336_work_ch1); |
| flush_work(&mt6336_work_ch2); |
| |
| /* disable mt6336 pmic ISR */ |
| mt6336_ctrl_enable(flashlight_ctrl); |
| mt6336_disable_interrupt(MT6336_INT_LED1_SHORT, "flashlight"); |
| mt6336_disable_interrupt(MT6336_INT_LED2_SHORT, "flashlight"); |
| /* mt6336_disable_interrupt(MT6336_INT_LED1_OPEN, "flashlight"); */ |
| /* mt6336_disable_interrupt(MT6336_INT_LED2_OPEN, "flashlight"); */ |
| mt6336_ctrl_disable(flashlight_ctrl); |
| |
| pr_debug("Remove done.\n"); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_OF |
| static const struct of_device_id mt6336_of_match[] = { |
| {.compatible = MT6336_DTNAME}, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, mt6336_of_match); |
| #else |
| static struct platform_device mt6336_platform_device[] = { |
| { |
| .name = MT6336_NAME, |
| .id = 0, |
| .dev = {} |
| }, |
| {} |
| }; |
| MODULE_DEVICE_TABLE(platform, mt6336_platform_device); |
| #endif |
| |
| static struct platform_driver mt6336_platform_driver = { |
| .probe = mt6336_probe, |
| .remove = mt6336_remove, |
| .driver = { |
| .name = MT6336_NAME, |
| .owner = THIS_MODULE, |
| #ifdef CONFIG_OF |
| .of_match_table = mt6336_of_match, |
| #endif |
| }, |
| }; |
| |
| static int __init flashlight_mt6336_init(void) |
| { |
| int ret; |
| |
| pr_debug("Init start.\n"); |
| |
| #ifndef CONFIG_OF |
| ret = platform_device_register(&mt6336_platform_device); |
| if (ret) { |
| pr_info("Failed to register platform device\n"); |
| return ret; |
| } |
| #endif |
| |
| ret = platform_driver_register(&mt6336_platform_driver); |
| if (ret) { |
| pr_info("Failed to register platform driver\n"); |
| return ret; |
| } |
| |
| pr_debug("Init done.\n"); |
| |
| return 0; |
| } |
| |
| static void __exit flashlight_mt6336_exit(void) |
| { |
| pr_debug("Exit start.\n"); |
| |
| platform_driver_unregister(&mt6336_platform_driver); |
| |
| pr_debug("Exit done.\n"); |
| } |
| |
| /* replace module_init() since conflict in kernel init process */ |
| late_initcall(flashlight_mt6336_init); |
| module_exit(flashlight_mt6336_exit); |
| |
| MODULE_LICENSE("GPL"); |
| MODULE_AUTHOR("Simon Wang <Simon-TCH.Wang@mediatek.com>"); |
| MODULE_DESCRIPTION("MTK Flashlight MT6336 Driver"); |
| |
