// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2019 MediaTek Inc. */ #define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "flashlight-core.h" #include "flashlight-dt.h" /* device tree should be defined in flashlight-dt.h */ #ifndef LM3644_DTNAME #define LM3644_DTNAME "mediatek,flashlights_lm3644" #endif #ifndef LM3644_DTNAME_I2C #define LM3644_DTNAME_I2C "mediatek,flashlights_lm3644_i2c" #endif #define LM3644_NAME "flashlights-lm3644" /* define registers */ #define LM3644_REG_ENABLE (0x01) #define LM3644_MASK_ENABLE_LED1 (0x01) #define LM3644_MASK_ENABLE_LED2 (0x02) #define LM3644_DISABLE (0x00) #define LM3644_ENABLE_LED1 (0x01) #define LM3644_ENABLE_LED1_TORCH (0x09) #define LM3644_ENABLE_LED1_FLASH (0x0D) #define LM3644_ENABLE_LED2 (0x02) #define LM3644_ENABLE_LED2_TORCH (0x0A) #define LM3644_ENABLE_LED2_FLASH (0x0E) #define LM3644_REG_TORCH_LEVEL_LED1 (0x05) #define LM3644_REG_FLASH_LEVEL_LED1 (0x03) #define LM3644_REG_TORCH_LEVEL_LED2 (0x06) #define LM3644_REG_FLASH_LEVEL_LED2 (0x04) #define LM3644_DEVICE_ID (0x0C) #define LM3644_REG_TIMING_CONF (0x08) #define LM3644_TORCH_RAMP_TIME (0x00) #define LM3644_FLASH_TIMEOUT (0x0F) #define LM3644TT_FLASH_TIMEOUT (0x09) #define LM3644_REG_DEVICE_ID (0x0C) /* define channel, level */ #define LM3644_CHANNEL_NUM 2 #define LM3644_CHANNEL_CH1 0 #define LM3644_CHANNEL_CH2 1 #define LM3644_LEVEL_NUM 39 #define LM3644_LEVEL_TORCH 7 #define LM3644_HW_TIMEOUT 400 /* ms */ /* define mutex and work queue */ static DEFINE_MUTEX(lm3644_mutex); static struct work_struct lm3644_work_ch1; static struct work_struct lm3644_work_ch2; /* define pinctrl */ #define LM3644_PINCTRL_PIN_HWEN 0 #define LM3644_PINCTRL_PINSTATE_LOW 0 #define LM3644_PINCTRL_PINSTATE_HIGH 1 #define LM3644_PINCTRL_STATE_HWEN_HIGH "hwen_high" #define LM3644_PINCTRL_STATE_HWEN_LOW "hwen_low" static struct pinctrl *lm3644_pinctrl; static struct pinctrl_state *lm3644_hwen_high; static struct pinctrl_state *lm3644_hwen_low; /* lm3644 revision */ static int is_lm3644tt; /* define usage count */ static int use_count; /* define i2c */ static struct i2c_client *lm3644_i2c_client; /* platform data */ struct lm3644_platform_data { int channel_num; struct flashlight_device_id *dev_id; }; static struct lm3644_platform_data *lm3644_pdata; /* lm3644 chip data */ struct lm3644_chip_data { struct i2c_client *client; struct lm3644_platform_data *pdata; struct mutex lock; }; /****************************************************************************** * Pinctrl configuration *****************************************************************************/ static int lm3644_pinctrl_init(struct platform_device *pdev) { int ret = 0; /* get pinctrl */ lm3644_pinctrl = devm_pinctrl_get(&pdev->dev); if (IS_ERR(lm3644_pinctrl)) { pr_info("Failed to get flashlight pinctrl.\n"); ret = PTR_ERR(lm3644_pinctrl); return ret; } /* Flashlight HWEN pin initialization */ lm3644_hwen_high = pinctrl_lookup_state( lm3644_pinctrl, LM3644_PINCTRL_STATE_HWEN_HIGH); if (IS_ERR(lm3644_hwen_high)) { pr_info("Failed to init (%s)\n", LM3644_PINCTRL_STATE_HWEN_HIGH); ret = PTR_ERR(lm3644_hwen_high); } lm3644_hwen_low = pinctrl_lookup_state( lm3644_pinctrl, LM3644_PINCTRL_STATE_HWEN_LOW); if (IS_ERR(lm3644_hwen_low)) { pr_info("Failed to init (%s)\n", LM3644_PINCTRL_STATE_HWEN_LOW); ret = PTR_ERR(lm3644_hwen_low); } return ret; } static int lm3644_pinctrl_set(int pin, int state) { int ret = 0; if (IS_ERR(lm3644_pinctrl)) { pr_info("pinctrl is not available\n"); return -1; } switch (pin) { case LM3644_PINCTRL_PIN_HWEN: if (state == LM3644_PINCTRL_PINSTATE_LOW && !IS_ERR(lm3644_hwen_low)) pinctrl_select_state(lm3644_pinctrl, lm3644_hwen_low); else if (state == LM3644_PINCTRL_PINSTATE_HIGH && !IS_ERR(lm3644_hwen_high)) pinctrl_select_state(lm3644_pinctrl, lm3644_hwen_high); else pr_info("set err, pin(%d) state(%d)\n", pin, state); break; default: pr_info("set err, pin(%d) state(%d)\n", pin, state); break; } pr_debug("pin(%d) state(%d)\n", pin, state); return ret; } /****************************************************************************** * lm3644 operations *****************************************************************************/ static const int lm3644_current[LM3644_LEVEL_NUM] = { 22, 46, 70, 93, 116, 140, 163, 187, 210, 234, 257, 281, 304, 327, 351, 374, 398, 421, 445, 468, 492, 515, 539, 562, 585, 609, 632, 656, 679, 703, 726, 761, 796, 832, 869, 902, 937, 972, 1008 }; static const unsigned char lm3644tt_torch_level[LM3644_LEVEL_NUM] = { 0x07, 0x10, 0x18, 0x21, 0x29, 0x31, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const unsigned char lm3644_torch_level[LM3644_LEVEL_NUM] = { 0x0F, 0x20, 0x31, 0x42, 0x52, 0x63, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const unsigned char lm3644_flash_level[LM3644_LEVEL_NUM] = { 0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F, 0x11, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F, 0x21, 0x23, 0x25, 0x27, 0x29, 0x2B, 0x2D, 0x2F, 0x31, 0x33, 0x35, 0x37, 0x39, 0x3B, 0x3D, 0x40, 0x43, 0x46, 0x49, 0x4C, 0x4F, 0x52, 0x54 }; static unsigned char lm3644_reg_enable; static int lm3644_level_ch1 = -1; static int lm3644_level_ch2 = -1; static int lm3644_is_torch(int level) { if (level >= LM3644_LEVEL_TORCH) return -1; return 0; } static int lm3644_verify_level(int level) { if (level < 0) level = 0; else if (level >= LM3644_LEVEL_NUM) level = LM3644_LEVEL_NUM - 1; return level; } /* i2c wrapper function */ static int lm3644_write_reg(struct i2c_client *client, u8 reg, u8 val) { int ret; struct lm3644_chip_data *chip = i2c_get_clientdata(client); mutex_lock(&chip->lock); ret = i2c_smbus_write_byte_data(client, reg, val); mutex_unlock(&chip->lock); if (ret < 0) pr_info("failed writing at 0x%02x\n", reg); return ret; } static int lm3644_read_reg(struct i2c_client *client, u8 reg) { int val = 0; struct lm3644_chip_data *chip = i2c_get_clientdata(client); mutex_lock(&chip->lock); val = i2c_smbus_read_byte_data(client, reg); mutex_unlock(&chip->lock); return val; } /* flashlight enable function */ static int lm3644_enable_ch1(void) { unsigned char reg, val; reg = LM3644_REG_ENABLE; if (!lm3644_is_torch(lm3644_level_ch1)) { /* torch mode */ lm3644_reg_enable |= LM3644_ENABLE_LED1_TORCH; } else { /* flash mode */ lm3644_reg_enable |= LM3644_ENABLE_LED1_FLASH; } val = lm3644_reg_enable; return lm3644_write_reg(lm3644_i2c_client, reg, val); } static int lm3644_enable_ch2(void) { unsigned char reg, val; reg = LM3644_REG_ENABLE; if (!lm3644_is_torch(lm3644_level_ch2)) { /* torch mode */ lm3644_reg_enable |= LM3644_ENABLE_LED2_TORCH; } else { /* flash mode */ lm3644_reg_enable |= LM3644_ENABLE_LED2_FLASH; } val = lm3644_reg_enable; return lm3644_write_reg(lm3644_i2c_client, reg, val); } static int lm3644_enable(int channel) { if (channel == LM3644_CHANNEL_CH1) lm3644_enable_ch1(); else if (channel == LM3644_CHANNEL_CH2) lm3644_enable_ch2(); else { pr_info("Error channel\n"); return -1; } return 0; } /* flashlight disable function */ static int lm3644_disable_ch1(void) { unsigned char reg, val; reg = LM3644_REG_ENABLE; if (lm3644_reg_enable & LM3644_MASK_ENABLE_LED2) { /* if LED 2 is enable, disable LED 1 */ lm3644_reg_enable &= (~LM3644_ENABLE_LED1); } else { /* if LED 2 is disable, disable LED 1 and clear mode */ lm3644_reg_enable &= (~LM3644_ENABLE_LED1_FLASH); } val = lm3644_reg_enable; return lm3644_write_reg(lm3644_i2c_client, reg, val); } static int lm3644_disable_ch2(void) { unsigned char reg, val; reg = LM3644_REG_ENABLE; if (lm3644_reg_enable & LM3644_MASK_ENABLE_LED1) { /* if LED 1 is enable, disable LED 2 */ lm3644_reg_enable &= (~LM3644_ENABLE_LED2); } else { /* if LED 1 is disable, disable LED 2 and clear mode */ lm3644_reg_enable &= (~LM3644_ENABLE_LED2_FLASH); } val = lm3644_reg_enable; return lm3644_write_reg(lm3644_i2c_client, reg, val); } static int lm3644_disable(int channel) { if (channel == LM3644_CHANNEL_CH1) lm3644_disable_ch1(); else if (channel == LM3644_CHANNEL_CH2) lm3644_disable_ch2(); else { pr_info("Error channel\n"); return -1; } return 0; } /* set flashlight level */ static int lm3644_set_level_ch1(int level) { int ret; unsigned char reg, val; level = lm3644_verify_level(level); /* set torch brightness level */ reg = LM3644_REG_TORCH_LEVEL_LED1; if (is_lm3644tt) val = lm3644tt_torch_level[level]; else val = lm3644_torch_level[level]; ret = lm3644_write_reg(lm3644_i2c_client, reg, val); lm3644_level_ch1 = level; /* set flash brightness level */ reg = LM3644_REG_FLASH_LEVEL_LED1; val = lm3644_flash_level[level]; ret = lm3644_write_reg(lm3644_i2c_client, reg, val); return ret; } static int lm3644_set_level_ch2(int level) { int ret; unsigned char reg, val; level = lm3644_verify_level(level); /* set torch brightness level */ reg = LM3644_REG_TORCH_LEVEL_LED2; if (is_lm3644tt) val = lm3644tt_torch_level[level]; else val = lm3644_torch_level[level]; ret = lm3644_write_reg(lm3644_i2c_client, reg, val); lm3644_level_ch2 = level; /* set flash brightness level */ reg = LM3644_REG_FLASH_LEVEL_LED2; val = lm3644_flash_level[level]; ret = lm3644_write_reg(lm3644_i2c_client, reg, val); return ret; } static int lm3644_set_level(int channel, int level) { if (channel == LM3644_CHANNEL_CH1) lm3644_set_level_ch1(level); else if (channel == LM3644_CHANNEL_CH2) lm3644_set_level_ch2(level); else { pr_info("Error channel\n"); return -1; } return 0; } /* flashlight init */ int lm3644_init(void) { int ret; unsigned char reg, val; lm3644_pinctrl_set( LM3644_PINCTRL_PIN_HWEN, LM3644_PINCTRL_PINSTATE_HIGH); msleep(20); /* get silicon revision */ is_lm3644tt = lm3644_read_reg(lm3644_i2c_client, LM3644_REG_DEVICE_ID); pr_info("LM3644(TT) revision(%d).\n", is_lm3644tt); /* clear enable register */ reg = LM3644_REG_ENABLE; val = LM3644_DISABLE; ret = lm3644_write_reg(lm3644_i2c_client, reg, val); lm3644_reg_enable = val; /* set torch current ramp time and flash timeout */ reg = LM3644_REG_TIMING_CONF; if (is_lm3644tt) val = LM3644_TORCH_RAMP_TIME | LM3644TT_FLASH_TIMEOUT; else val = LM3644_TORCH_RAMP_TIME | LM3644_FLASH_TIMEOUT; ret = lm3644_write_reg(lm3644_i2c_client, reg, val); return ret; } /* flashlight uninit */ int lm3644_uninit(void) { lm3644_disable(LM3644_CHANNEL_CH1); lm3644_disable(LM3644_CHANNEL_CH2); lm3644_pinctrl_set( LM3644_PINCTRL_PIN_HWEN, LM3644_PINCTRL_PINSTATE_LOW); return 0; } /****************************************************************************** * Timer and work queue *****************************************************************************/ static struct hrtimer lm3644_timer_ch1; static struct hrtimer lm3644_timer_ch2; static unsigned int lm3644_timeout_ms[LM3644_CHANNEL_NUM]; static void lm3644_work_disable_ch1(struct work_struct *data) { pr_debug("ht work queue callback\n"); lm3644_disable_ch1(); } static void lm3644_work_disable_ch2(struct work_struct *data) { pr_debug("lt work queue callback\n"); lm3644_disable_ch2(); } static enum hrtimer_restart lm3644_timer_func_ch1(struct hrtimer *timer) { schedule_work(&lm3644_work_ch1); return HRTIMER_NORESTART; } static enum hrtimer_restart lm3644_timer_func_ch2(struct hrtimer *timer) { schedule_work(&lm3644_work_ch2); return HRTIMER_NORESTART; } static int lm3644_timer_start(int channel, ktime_t ktime) { if (channel == LM3644_CHANNEL_CH1) hrtimer_start(&lm3644_timer_ch1, ktime, HRTIMER_MODE_REL); else if (channel == LM3644_CHANNEL_CH2) hrtimer_start(&lm3644_timer_ch2, ktime, HRTIMER_MODE_REL); else { pr_info("Error channel\n"); return -1; } return 0; } static int lm3644_timer_cancel(int channel) { if (channel == LM3644_CHANNEL_CH1) hrtimer_cancel(&lm3644_timer_ch1); else if (channel == LM3644_CHANNEL_CH2) hrtimer_cancel(&lm3644_timer_ch2); else { pr_info("Error channel\n"); return -1; } return 0; } /****************************************************************************** * Flashlight operations *****************************************************************************/ static int lm3644_ioctl(unsigned int cmd, unsigned long arg) { struct flashlight_dev_arg *fl_arg; int channel; ktime_t ktime; unsigned int s; unsigned int ns; fl_arg = (struct flashlight_dev_arg *)arg; channel = fl_arg->channel; /* verify channel */ if (channel < 0 || channel >= LM3644_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); lm3644_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); lm3644_set_level(channel, fl_arg->arg); break; case FLASH_IOC_SET_ONOFF: pr_debug("FLASH_IOC_SET_ONOFF(%d): %d\n", channel, (int)fl_arg->arg); if (fl_arg->arg == 1) { if (lm3644_timeout_ms[channel]) { s = lm3644_timeout_ms[channel] / 1000; ns = lm3644_timeout_ms[channel] % 1000 * 1000000; ktime = ktime_set(s, ns); lm3644_timer_start(channel, ktime); } lm3644_enable(channel); } else { lm3644_disable(channel); lm3644_timer_cancel(channel); } break; case FLASH_IOC_GET_DUTY_NUMBER: pr_debug("FLASH_IOC_GET_DUTY_NUMBER(%d)\n", channel); fl_arg->arg = LM3644_LEVEL_NUM; break; case FLASH_IOC_GET_MAX_TORCH_DUTY: pr_debug("FLASH_IOC_GET_MAX_TORCH_DUTY(%d)\n", channel); fl_arg->arg = LM3644_LEVEL_TORCH - 1; break; case FLASH_IOC_GET_DUTY_CURRENT: fl_arg->arg = lm3644_verify_level(fl_arg->arg); pr_debug("FLASH_IOC_GET_DUTY_CURRENT(%d): %d\n", channel, (int)fl_arg->arg); fl_arg->arg = lm3644_current[fl_arg->arg]; break; case FLASH_IOC_GET_HW_TIMEOUT: pr_debug("FLASH_IOC_GET_HW_TIMEOUT(%d)\n", channel); fl_arg->arg = LM3644_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 lm3644_open(void) { /* Move to set driver for saving power */ return 0; } static int lm3644_release(void) { /* Move to set driver for saving power */ return 0; } static int lm3644_set_driver(int set) { int ret = 0; /* set chip and usage count */ mutex_lock(&lm3644_mutex); if (set) { if (!use_count) ret = lm3644_init(); use_count++; pr_debug("Set driver: %d\n", use_count); } else { use_count--; if (!use_count) ret = lm3644_uninit(); if (use_count < 0) use_count = 0; pr_debug("Unset driver: %d\n", use_count); } mutex_unlock(&lm3644_mutex); return ret; } static ssize_t lm3644_strobe_store(struct flashlight_arg arg) { lm3644_set_driver(1); lm3644_set_level(arg.channel, arg.level); lm3644_timeout_ms[arg.channel] = 0; lm3644_enable(arg.channel); msleep(arg.dur); lm3644_disable(arg.channel); lm3644_set_driver(0); return 0; } static struct flashlight_operations lm3644_ops = { lm3644_open, lm3644_release, lm3644_ioctl, lm3644_strobe_store, lm3644_set_driver }; /****************************************************************************** * I2C device and driver *****************************************************************************/ static int lm3644_chip_init(struct lm3644_chip_data *chip) { /* NOTE: Chip initialication move to "set driver" for power saving. * lm3644_init(); */ return 0; } static int lm3644_parse_dt(struct device *dev, struct lm3644_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, LM3644_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 lm3644_i2c_probe( struct i2c_client *client, const struct i2c_device_id *id) { struct lm3644_chip_data *chip; int err; int i; pr_debug("i2c probe start.\n"); /* check i2c */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_info("Failed to check i2c functionality.\n"); err = -ENODEV; goto err_out; } /* init chip private data */ chip = kzalloc(sizeof(struct lm3644_chip_data), GFP_KERNEL); if (!chip) { err = -ENOMEM; goto err_out; } chip->client = client; i2c_set_clientdata(client, chip); lm3644_i2c_client = client; /* init mutex and spinlock */ mutex_init(&chip->lock); /* init chip hw */ lm3644_chip_init(chip); /* check flashlight device */ pr_info("lm3644 LM3644_DEVICE_ID = %d\n", lm3644_read_reg(lm3644_i2c_client, LM3644_DEVICE_ID)); if (lm3644_read_reg(lm3644_i2c_client, LM3644_DEVICE_ID) != 0x02) { pr_info("lm3644 in not available\n"); if (lm3644_pdata->channel_num) { for (i = 0; i < lm3644_pdata->channel_num; i++) flashlight_dev_unregister_by_device_id( &lm3644_pdata->dev_id[i]); } if (lm3644_pinctrl) devm_pinctrl_put(lm3644_pinctrl); err = -EFAULT; goto err_free; } pr_debug("i2c probe done.\n"); return 0; err_free: i2c_set_clientdata(client, NULL); kfree(chip); err_out: return err; } static int lm3644_i2c_remove(struct i2c_client *client) { struct lm3644_chip_data *chip = i2c_get_clientdata(client); pr_debug("Remove start.\n"); client->dev.platform_data = NULL; /* free resource */ kfree(chip); pr_debug("Remove done.\n"); return 0; } static const struct i2c_device_id lm3644_i2c_id[] = { {LM3644_NAME, 0}, {} }; #ifdef CONFIG_OF static const struct of_device_id lm3644_i2c_of_match[] = { {.compatible = LM3644_DTNAME_I2C}, {}, }; #endif static struct i2c_driver lm3644_i2c_driver = { .driver = { .name = LM3644_NAME, #ifdef CONFIG_OF .of_match_table = lm3644_i2c_of_match, #endif }, .probe = lm3644_i2c_probe, .remove = lm3644_i2c_remove, .id_table = lm3644_i2c_id, }; /****************************************************************************** * Platform device and driver *****************************************************************************/ static int lm3644_probe(struct platform_device *pdev) { struct lm3644_platform_data *pdata = dev_get_platdata(&pdev->dev); int err; int i; pr_debug("Probe start.\n"); /* init pinctrl */ if (lm3644_pinctrl_init(pdev)) { pr_debug("Failed to init pinctrl.\n"); return -1; } if (i2c_add_driver(&lm3644_i2c_driver)) { pr_debug("Failed to add i2c driver.\n"); return -1; } /* init platform data */ if (!pdata) { pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { err = -ENOMEM; goto err_free; } pdev->dev.platform_data = pdata; err = lm3644_parse_dt(&pdev->dev, pdata); if (err) goto err_free; } lm3644_pdata = pdata; /* init work queue */ INIT_WORK(&lm3644_work_ch1, lm3644_work_disable_ch1); INIT_WORK(&lm3644_work_ch2, lm3644_work_disable_ch2); /* init timer */ hrtimer_init(&lm3644_timer_ch1, CLOCK_MONOTONIC, HRTIMER_MODE_REL); lm3644_timer_ch1.function = lm3644_timer_func_ch1; hrtimer_init(&lm3644_timer_ch2, CLOCK_MONOTONIC, HRTIMER_MODE_REL); lm3644_timer_ch2.function = lm3644_timer_func_ch2; lm3644_timeout_ms[LM3644_CHANNEL_CH1] = 100; lm3644_timeout_ms[LM3644_CHANNEL_CH2] = 100; /* 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], &lm3644_ops)) { err = -EFAULT; goto err_free; } } else { if (flashlight_dev_register(LM3644_NAME, &lm3644_ops)) { err = -EFAULT; goto err_free; } } pr_debug("Probe done.\n"); return 0; err_free: return err; } static int lm3644_remove(struct platform_device *pdev) { struct lm3644_platform_data *pdata = dev_get_platdata(&pdev->dev); int i; pr_debug("Remove start.\n"); i2c_del_driver(&lm3644_i2c_driver); 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(LM3644_NAME); /* flush work queue */ flush_work(&lm3644_work_ch1); flush_work(&lm3644_work_ch2); pr_debug("Remove done.\n"); return 0; } #ifdef CONFIG_OF static const struct of_device_id lm3644_of_match[] = { {.compatible = LM3644_DTNAME}, {}, }; MODULE_DEVICE_TABLE(of, lm3644_of_match); #else static struct platform_device lm3644_platform_device[] = { { .name = LM3644_NAME, .id = 0, .dev = {} }, {} }; MODULE_DEVICE_TABLE(platform, lm3644_platform_device); #endif static struct platform_driver lm3644_platform_driver = { .probe = lm3644_probe, .remove = lm3644_remove, .driver = { .name = LM3644_NAME, .owner = THIS_MODULE, #ifdef CONFIG_OF .of_match_table = lm3644_of_match, #endif }, }; static int __init flashlight_lm3644_init(void) { int ret; pr_debug("Init start.\n"); #ifndef CONFIG_OF ret = platform_device_register(&lm3644_platform_device); if (ret) { pr_info("Failed to register platform device\n"); return ret; } #endif ret = platform_driver_register(&lm3644_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_lm3644_exit(void) { pr_debug("Exit start.\n"); platform_driver_unregister(&lm3644_platform_driver); pr_debug("Exit done.\n"); } module_init(flashlight_lm3644_init); module_exit(flashlight_lm3644_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Ziyu Jiang "); MODULE_DESCRIPTION("MTK Flashlight LM3644 Driver");