/* drivers/mfd/rt8973.c * Richtek RT8973 Multifunction Device / MUIC Driver * * Copyright (C) 2013 * Author: Patrick Chang * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef SAMSUNG_MVRL_MUIC_RT8973 #include #include #include #endif #define RT8973_DEVICE_NAME "rt8973" #define ALIAS_NAME RT8973_DEVICE_NAME #define RT8973_DRV_VER "2.1.2G" #define RT8973_IRQF_MODE IRQF_TRIGGER_FALLING #define RT8973_REG_CHIP_ID 0x01 #define RT8973_REG_CONTROL 0x02 #define RT8973_REG_INT_FLAG1 0x03 #define RT8973_REG_INT_FLAG2 0x04 #define RT8973_REG_INTERRUPT_MASK1 0x05 #define RT8973_REG_INTERRUPT_MASK2 0x06 #define RT8973_REG_ADC 0x07 #define RT8973_REG_DEVICE1 0x0A #define RT8973_REG_DEVICE2 0x0B #define RT8973_REG_MANUAL_SW1 0x13 #define RT8973_REG_MANUAL_SW2 0x14 #define RT8973_REG_RESET 0x1B #define DCD_T_RETRY 2 #define RT8973_DEVICE1_OTG 0x01 #define RT8973_DEVICE1_SDP 0x04 #define RT8973_DEVICE1_UART 0x08 #define RT8973_DEVICE1_CDPORT 0x20 #define RT8973_DEVICE1_DCPORT 0x40 #ifdef SAMSUNG_MVRL_MUIC_RT8973 static struct gpio_edge_desc muic_int_gpio; #endif static irqreturn_t rt8973_irq_handler(int irq, void *data); struct device_desc { char *name; uint32_t reg_val; int cable_type; }; static const struct device_desc device_to_cable_type_mapping[] = { { .name = "OTG", .reg_val = RT8973_DEVICE1_OTG, .cable_type = MUIC_RT8973_CABLE_TYPE_OTG, }, { .name = "USB SDP", .reg_val = RT8973_DEVICE1_SDP, .cable_type = MUIC_RT8973_CABLE_TYPE_USB, }, { .name = "UART", .reg_val = RT8973_DEVICE1_UART, .cable_type = MUIC_RT8973_CABLE_TYPE_UART, }, { .name = "USB CDP", .reg_val = RT8973_DEVICE1_CDPORT, .cable_type = MUIC_RT8973_CABLE_TYPE_CDP, }, { .name = "USB DCP", .reg_val = RT8973_DEVICE1_DCPORT, .cable_type = MUIC_RT8973_CABLE_TYPE_REGULAR_TA, }, }; struct id_desc { char *name; int cable_type_with_vbus; int cable_type_without_vbus; }; static const struct id_desc id_to_cable_type_mapping[] = { { /* 00000, 0 */ .name = "OTG", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_OTG, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_OTG, }, { /* 00001, 1 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 00010, 2 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 00011, 3 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 00100, 4 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 00101, 5 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 00110, 6 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 00111, 7 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01000, 8 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01001, 9 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01010, 10 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01011, 11 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01100, 12 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01101, 13 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01110, 14 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 01111, 15 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10000, 16 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10001, 17 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10010, 18 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10011, 19 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10100, 20 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10101, 21 */ .name = "ADC0x15 Charger/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_0x15, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10110, 22 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 10111, 23 */ .name = "Type 1 Charger/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 11000, 24 */ .name = "FM BOOT OFF USB/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 11001, 25 */ .name = "FM BOOT ON USB/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_USB_ON, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 11010, 26 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 11011, 27 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 11100, 28 */ .name = "JIG UART BOOT OFF", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF, }, { /* 11101, 29 */ .name = "JIG UART BOOT ON", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_ON, }, { /* 11110, 30 */ .name = "AT&T TA/Unknown", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN, }, { /* 11111, 31 */ .name = "AT&T TA/No cable", .cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA, .cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_NONE, }, }; enum { VBUS_SHIFT = 0, ACCESSORY_SHIFT, OCP_SHIFT, OVP_SHIFT, OTP_SHIFT, ADC_CHG_SHIFT, CABLE_CHG_SHIFT, OTG_SHIFT, DCDT_SHIFT, USB_SHIFT, UART_SHIFT, JIG_SHIFT, L_USB_SHIFT, }; struct rt8973_status { int cable_type; int id_adc; uint8_t irq_flags[2]; uint8_t device_reg[2]; /* Processed useful status * Compare previous and current regs * to get this information */ union { struct { uint32_t vbus_status:1; uint32_t accessory_status:1; uint32_t ocp_status:1; uint32_t ovp_status:1; uint32_t otp_status:1; uint32_t adc_chg_status:1; uint32_t cable_chg_status:1; uint32_t otg_status:1; uint32_t dcdt_status:1; uint32_t usb_connect:1; uint32_t uart_connect:1; uint32_t jig_connect:1; uint32_t l_usb_connect:1; }; uint32_t status; }; }; typedef struct rt8973_chip { struct i2c_client *iic; struct mutex io_lock; struct rt8973_platform_data *pdata; struct device *dev; #ifdef SAMSUNG_MVRL_MUIC_RT8973 struct device *switch_dev; #endif struct workqueue_struct *wq; struct delayed_work irq_work; struct delayed_work init_work; struct wake_lock muic_wake_lock; struct rt8973_status prev_status; struct rt8973_status curr_status; int dcdt_retry_count; int irq; int adc_reg_addr; } rt8973_chip_t; #ifdef SAMSUNG_MVRL_MUIC_RT8973 static struct rt8973_status *current_status; #endif static int32_t rt8973_read(struct rt8973_chip *chip, uint8_t reg, uint8_t nbytes, uint8_t *buff) { int ret; mutex_lock(&chip->io_lock); ret = i2c_smbus_read_i2c_block_data(chip->iic, reg, nbytes, buff); mutex_unlock(&chip->io_lock); return ret; } static int32_t rt8973_reg_read(struct rt8973_chip *chip, int reg) { int ret; mutex_lock(&chip->io_lock); ret = i2c_smbus_read_byte_data(chip->iic, reg); mutex_unlock(&chip->io_lock); return ret; } int32_t rt8973_reg_write(struct rt8973_chip *chip, int reg, unsigned char data) { int ret; mutex_lock(&chip->io_lock); ret = i2c_smbus_write_byte_data(chip->iic, reg, data); mutex_unlock(&chip->io_lock); return ret; } static int32_t rt8973_assign_bits(struct rt8973_chip *chip, int reg, unsigned char mask, unsigned char data) { struct i2c_client *iic; int ret; iic = chip->iic; mutex_lock(&chip->io_lock); ret = i2c_smbus_read_byte_data(iic, reg); if (ret < 0) goto out; ret &= ~mask; ret |= data; ret = i2c_smbus_write_byte_data(iic, reg, ret); out: mutex_unlock(&chip->io_lock); return ret; } int32_t rt8973_set_bits(struct rt8973_chip *chip, int reg, unsigned char mask) { return rt8973_assign_bits(chip, reg, mask, mask); } int32_t rt8973_clr_bits(struct rt8973_chip *chip, int reg, unsigned char mask) { return rt8973_assign_bits(chip, reg, mask, 0); } static inline int rt8973_update_regs(rt8973_chip_t *chip) { int ret; ret = rt8973_read(chip, RT8973_REG_INT_FLAG1, 2, chip->curr_status.irq_flags); if (ret < 0) return ret; ret = rt8973_read(chip, RT8973_REG_DEVICE1, 2, chip->curr_status.device_reg); if (ret < 0) return ret; ret = rt8973_reg_read(chip, chip->adc_reg_addr); if (ret < 0) return ret; chip->curr_status.id_adc = ret; /* invalid id value */ if (ret >= ARRAY_SIZE(id_to_cable_type_mapping)) return -EINVAL; return 0; } static int rt8973_get_cable_type_by_device_reg(rt8973_chip_t *chip) { uint32_t device_reg = chip->curr_status.device_reg[1]; int i; RTINFO("Device = 0x%x, 0x%x\n", (int)chip->curr_status.device_reg[0], (int)chip->curr_status.device_reg[1]); device_reg <<= 8; device_reg |= chip->curr_status.device_reg[0]; for (i = 0; i < ARRAY_SIZE(device_to_cable_type_mapping); i++) { if (device_to_cable_type_mapping[i].reg_val == device_reg) { if (chip->curr_status.dcdt_status == 1) { /* USB ID ==> open, i.e., ADC reading = 0x1f */ return id_to_cable_type_mapping[0x1f].cable_type_with_vbus; } return device_to_cable_type_mapping[i].cable_type; } } /* not found */ return -EINVAL; } static int rt8973_get_cable_type_by_id(rt8973_chip_t *chip) { int id_val = chip->curr_status.id_adc; int cable_type; RTINFO("ID value = 0x%x\n", id_val); if (chip->curr_status.vbus_status) cable_type = id_to_cable_type_mapping[id_val].cable_type_with_vbus; else cable_type = id_to_cable_type_mapping[id_val].cable_type_without_vbus; /* Special case for ID200K USB cable */ if (cable_type == MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER) { /* ID = 200KOhm, VBUS = 1, DCD_T = 0 and CHGDET = 0 ==> 200k SDP*/ if ((chip->curr_status.irq_flags[0]&0x0C) == 0) cable_type = MUIC_RT8973_CABLE_TYPE_L_USB; } /* To remove OTG accessory, VBUS would still exist*/ if ((chip->prev_status.cable_type == MUIC_RT8973_CABLE_TYPE_OTG) && id_val == 0x1f) { cable_type = MUIC_RT8973_CABLE_TYPE_NONE; chip->curr_status.dcdt_status = 0; } return cable_type; } #define USB_RETRY_CNT 10 #define USB_RETRY_DELAY 50 static int rt8973_get_cable_type(rt8973_chip_t *chip) { int i, ret = -1; int dev_type_retry = 1; /* Check dangerous case first and * * it can make system stop charging */ if (chip->curr_status.ovp_status | chip->curr_status.ocp_status) return MUIC_RT8973_CABLE_TYPE_UNKNOWN; /* Only for RT8973A */ if (chip->adc_reg_addr == 0x23) { for (i = 0; i < USB_RETRY_CNT && dev_type_retry == 1; i++) { ret = rt8973_get_cable_type_by_device_reg(chip); /* VBUS = 1 but no DCD_T, * * and not a SDP/CDP/DCP type cable * * and not a L-type USB cable (200k-Ohm) */ if (ret < 0 && chip->curr_status.vbus_status == 1 && chip->curr_status.dcdt_status == 0 && chip->curr_status.id_adc != 0x17) { msleep(USB_RETRY_DELAY); rt8973_read(chip, RT8973_REG_DEVICE1, 2, chip->curr_status.device_reg); pr_info("%s : retry to read DEV1 = 0x%x, DEV2 = 0x%x\n", __func__, (int)chip->curr_status.device_reg[0], (int)chip->curr_status.device_reg[1]); } else { dev_type_retry = 0; } } } else { ret = rt8973_get_cable_type_by_device_reg(chip); } if (ret >= 0) return ret; else return rt8973_get_cable_type_by_id(chip); } static void rt8973_preprocess_status(rt8973_chip_t *chip) { chip->curr_status.ocp_status = (chip->curr_status.irq_flags[1] & 0x60) ? 1 : 0; chip->curr_status.ovp_status = ((chip->curr_status.irq_flags[1] & 0x10) || (chip->curr_status.irq_flags[0] & 0x10)) ? 1 : 0; chip->curr_status.otp_status = ((chip->curr_status.irq_flags[1] & 0x08) || (chip->curr_status.irq_flags[0] & 0x80)) ? 1 : 0; chip->curr_status.dcdt_status = (chip->curr_status.irq_flags[0] & 0x08) ? 1 : 0; chip->curr_status.vbus_status = (chip->curr_status.irq_flags[1] & 0x02) ? 0 : 1; chip->curr_status.cable_type = rt8973_get_cable_type(chip); chip->curr_status.adc_chg_status = (chip->prev_status.id_adc != chip->curr_status.id_adc) ? 1 : 0; chip->curr_status.otg_status = (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_OTG) ? 1 : 0; chip->curr_status.accessory_status = ((chip->curr_status.cable_type != MUIC_RT8973_CABLE_TYPE_NONE) && (chip->curr_status.cable_type != MUIC_RT8973_CABLE_TYPE_UNKNOWN)) ? 1 : 0; chip->curr_status.cable_chg_status = (chip->curr_status.cable_type != chip->prev_status.cable_type) ? 1 : 0; chip->curr_status.usb_connect = ((chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_USB) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_CDP) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_L_USB) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_USB_ON)) ? 1 : 0; chip->curr_status.uart_connect = ((chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_UART) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_ON) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS)) ? 1 : 0; chip->curr_status.jig_connect = ((chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_USB_ON) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_ON) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS) || (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS)) ? 1 : 0; chip->curr_status.l_usb_connect = (chip->curr_status.cable_type == MUIC_RT8973_CABLE_TYPE_L_USB) ? 1 : 0; } #define FLAG_HIGH (0x01) #define FLAG_LOW (0x02) #define FLAG_LOW_TO_HIGH (0x04) #define FLAG_HIGH_TO_LOW (0x08) #define FLAG_RISING FLAG_LOW_TO_HIGH #define FLAG_FALLING FLAG_HIGH_TO_LOW #define FLAG_CHANGED (FLAG_LOW_TO_HIGH | FLAG_HIGH_TO_LOW) static inline uint32_t state_check(unsigned int old_state, unsigned int new_state, unsigned int bit_mask) { unsigned int ret = 0; old_state &= bit_mask; new_state &= bit_mask; if (new_state) ret |= FLAG_HIGH; else ret |= FLAG_LOW; if (old_state != new_state) { if (new_state) ret |= FLAG_LOW_TO_HIGH; else ret |= FLAG_HIGH_TO_LOW; } return ret; } struct rt8973_event_handler { char *name; uint32_t bit_mask; uint32_t type; void (*handler) (struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status); }; static void rt8973_ocp_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTERR("OCP event triggered\n"); if (chip->pdata->ocp_callback) chip->pdata->ocp_callback(); } static void rt8973_ovp_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTERR("OVP event triggered\n"); if (chip->pdata->ovp_callback) chip->pdata->ovp_callback(); } static void rt8973_otp_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTERR("OTP event triggered\n"); if (chip->pdata->otp_callback) chip->pdata->otp_callback(); } struct rt8973_event_handler urgent_event_handlers[] = { { .name = "OCP", .bit_mask = (1 << OCP_SHIFT), .type = FLAG_RISING, .handler = rt8973_ocp_handler, }, { .name = "OVP", .bit_mask = (1 << OVP_SHIFT), .type = FLAG_RISING, .handler = rt8973_ovp_handler, }, { .name = "OTP", .bit_mask = (1 << OTP_SHIFT), .type = FLAG_RISING, .handler = rt8973_otp_handler, }, }; #if RTDBGINFO_LEVEL <= RTDBGLEVEL static char *rt8973_cable_names[] = { "MUIC_RT8973_CABLE_TYPE_NONE", "MUIC_RT8973_CABLE_TYPE_UART", "MUIC_RT8973_CABLE_TYPE_USB", "MUIC_RT8973_CABLE_TYPE_OTG", /* TA Group */ "MUIC_RT8973_CABLE_TYPE_REGULAR_TA", "MUIC_RT8973_CABLE_TYPE_ATT_TA", "MUIC_RT8973_CABLE_TYPE_0x15", "MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER", "MUIC_RT8973_CABLE_TYPE_0x1A", /* JIG Group */ "MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF", "MUIC_RT8973_CABLE_TYPE_JIG_USB_ON", "MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF", "MUIC_RT8973_CABLE_TYPE_JIG_UART_ON", /* JIG type with VBUS */ "MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS", "MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS", "MUIC_RT8973_CABLE_TYPE_CDP", "MUIC_RT8973_CABLE_TYPE_L_USB", "MUIC_RT8973_CABLE_TYPE_UNKNOWN", "MUIC_RT8973_CABLE_TYPE_INVALID", }; #endif /*RTDBGINFO_LEVEL<=RTDBGLEVEL */ #if defined(CONFIG_BATTERY_SAMSUNG) || defined(CONFIG_RT_BATTERY) #define cable_change_callback sec_charger_cb extern void sec_charger_cb(u8 cable_type); #endif static void rt8973_cable_change_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("Cable change to %s\n", rt8973_cable_names[chip->curr_status.cable_type]); #if defined(CONFIG_BATTERY_SAMSUNG) || defined(CONFIG_RT_BATTERY) cable_change_callback(chip->curr_status.cable_type); #endif if (chip->pdata->cable_chg_callback) chip->pdata->cable_chg_callback(chip->curr_status.cable_type); } static void rt8973_otg_attach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("OTG attached\n"); rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x24); /* Disable USBCHDEN and AutoConfig*/ rt8973_clr_bits(chip, RT8973_REG_CONTROL, (1 << 2) | (1 << 6)); if (chip->pdata->otg_callback) chip->pdata->otg_callback(1); } static void rt8973_otg_detach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("OTG detached\n"); rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x00); /* Enable USBCHDEN and AutoConfig*/ rt8973_set_bits(chip, RT8973_REG_CONTROL, (1 << 2) | (1 << 6)); if (chip->pdata->otg_callback) chip->pdata->otg_callback(0); } extern void dwc_udc_startup(void); extern void dwc_udc_shutdown(void); static void rt8973_usb_attach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("USB attached\n"); if (chip->pdata->usb_callback) { chip->pdata->usb_callback(1); } else { dwc_udc_startup(); } } static void rt8973_usb_detach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("USB detached\n"); if (chip->pdata->usb_callback) { chip->pdata->usb_callback(0); } else { dwc_udc_shutdown(); } } static void rt8973_uart_attach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("UART attached\n"); if (chip->pdata->uart_callback) chip->pdata->uart_callback(1); } static void rt8973_uart_detach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("UART detached\n"); if (chip->pdata->uart_callback) chip->pdata->uart_callback(0); } static inline jig_type_t get_jig_type(int cable_type) { jig_type_t type = JIG_USB_BOOT_ON; switch (cable_type) { case MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS: case MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF: type = JIG_UART_BOOT_OFF; break; case MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS: case MUIC_RT8973_CABLE_TYPE_JIG_UART_ON: type = JIG_UART_BOOT_ON; break; case MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF: type = JIG_USB_BOOT_OFF; break; case MUIC_RT8973_CABLE_TYPE_JIG_USB_ON: type = JIG_USB_BOOT_ON; break; } return type; } static void rt8973_jig_attach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { jig_type_t type; type = get_jig_type(chip->curr_status.cable_type); RTINFO("JIG attached (type = %d)\n", (int)type); if (chip->pdata->jig_callback) chip->pdata->jig_callback(type, 1); } static void rt8973_jig_detach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { jig_type_t type; type = get_jig_type(chip->prev_status.cable_type); RTINFO("JIG detached (type = %d)\n", (int)type); if (chip->pdata->jig_callback) chip->pdata->jig_callback(type, 0); } static void rt8973_l_usb_attach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("200k special USB cable attached\n"); /* Make switch connect to USB path */ rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x24); /* Change to manual-config */ rt8973_clr_bits(chip, RT8973_REG_CONTROL, 1 << 2); } static void rt8973_l_usb_detach_handler(struct rt8973_chip *chip, const struct rt8973_event_handler *handler, unsigned int old_status, unsigned int new_status) { RTINFO("200k special USB cable detached\n"); /* Make switch opened */ rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x00); /* Change to auto-config */ rt8973_set_bits(chip, RT8973_REG_CONTROL, 1 << 2); } struct rt8973_event_handler normal_event_handlers[] = { { .name = "200k special USB attached", .bit_mask = (1 << L_USB_SHIFT), .type = FLAG_RISING, .handler = rt8973_l_usb_attach_handler, }, { .name = "200k special USB detached", .bit_mask = (1 << L_USB_SHIFT), .type = FLAG_FALLING, .handler = rt8973_l_usb_detach_handler, }, { .name = "Cable changed", .bit_mask = (1 << CABLE_CHG_SHIFT), .type = FLAG_HIGH, .handler = rt8973_cable_change_handler, }, { .name = "OTG attached", .bit_mask = (1 << OTG_SHIFT), .type = FLAG_RISING, .handler = rt8973_otg_attach_handler, }, { .name = "OTG detached", .bit_mask = (1 << OTG_SHIFT), .type = FLAG_FALLING, .handler = rt8973_otg_detach_handler, }, { .name = "USB attached", .bit_mask = (1 << USB_SHIFT), .type = FLAG_RISING, .handler = rt8973_usb_attach_handler, }, { .name = "USB detached", .bit_mask = (1 << USB_SHIFT), .type = FLAG_FALLING, .handler = rt8973_usb_detach_handler, }, { .name = "UART attached", .bit_mask = (1 << UART_SHIFT), .type = FLAG_RISING, .handler = rt8973_uart_attach_handler, }, { .name = "UART detached", .bit_mask = (1 << UART_SHIFT), .type = FLAG_FALLING, .handler = rt8973_uart_detach_handler, }, { .name = "JIG attached", .bit_mask = (1 << JIG_SHIFT), .type = FLAG_RISING, .handler = rt8973_jig_attach_handler, }, { .name = "JIG detached", .bit_mask = (1 << JIG_SHIFT), .type = FLAG_FALLING, .handler = rt8973_jig_detach_handler, }, }; static void rt8973_process_urgent_evt(rt8973_chip_t *chip) { unsigned int i; unsigned int type, sta_chk; uint32_t prev_status, curr_status; prev_status = chip->prev_status.status; curr_status = chip->curr_status.status; for (i = 0; i < ARRAY_SIZE(urgent_event_handlers); i++) { sta_chk = state_check(prev_status, curr_status, urgent_event_handlers[i].bit_mask); type = urgent_event_handlers[i].type; if (type & sta_chk) { if (urgent_event_handlers[i].handler) urgent_event_handlers[i].handler(chip, urgent_event_handlers + i, prev_status, curr_status); } } } static void rt8973_process_normal_evt(rt8973_chip_t *chip) { unsigned int i; unsigned int type, sta_chk; uint32_t prev_status, curr_status; prev_status = chip->prev_status.status; curr_status = chip->curr_status.status; for (i = 0; i < ARRAY_SIZE(normal_event_handlers); i++) { sta_chk = state_check(prev_status, curr_status, normal_event_handlers[i].bit_mask); type = normal_event_handlers[i].type; if (type & sta_chk) { if (normal_event_handlers[i].handler) normal_event_handlers[i].handler(chip, normal_event_handlers + i, prev_status, curr_status); } } } static void rt8973_irq_work(struct work_struct *work) { int ret; rt8973_chip_t *chip = container_of(to_delayed_work(work), rt8973_chip_t, irq_work); chip->prev_status = chip->curr_status; ret = rt8973_update_regs(chip); if (ret < 0) { RTERR("Error : can't update(read) register status:%d\n", ret); /* roll back status */ chip->curr_status = chip->prev_status; return; } /* for printing out registers -- start */ pr_info("%s : INTF1 = 0x%x, INTF2 = 0x%x\n", __FUNCTION__, (int)chip->curr_status.irq_flags[0], (int)chip->curr_status.irq_flags[1]); pr_info("%s : DEV1 = 0x%x, DEV2 = 0x%x\n", __FUNCTION__, (int)chip->curr_status.device_reg[0], (int)chip->curr_status.device_reg[1]); pr_info("%s : ADC = 0x%x\n", __FUNCTION__, (int)chip->curr_status.id_adc); /* for printint out registers -- end*/ rt8973_preprocess_status(chip); RTINFO("Status : cable type = %d,\n" "vbus = %d, accessory = %d\n" "ocp = %d, ovp = %d, otp = %d,\n" "adc_chg = %d, cable_chg = %d\n" "otg = %d, dcdt = %d, usb = %d,\n" "uart = %d, jig = %d\n" "200k usb cable = %d\n", chip->curr_status.cable_type, chip->curr_status.vbus_status, chip->curr_status.accessory_status, chip->curr_status.ocp_status, chip->curr_status.ovp_status, chip->curr_status.otp_status, chip->curr_status.adc_chg_status, chip->curr_status.cable_chg_status, chip->curr_status.otg_status, chip->curr_status.dcdt_status, chip->curr_status.usb_connect, chip->curr_status.uart_connect, chip->curr_status.jig_connect, chip->curr_status.l_usb_connect); rt8973_process_urgent_evt(chip); if (chip->curr_status.dcdt_status) { if (chip->dcdt_retry_count >= DCD_T_RETRY) { chip->dcdt_retry_count = 0; /* reset counter */ RTINFO("Exceeded maxima retry times\n"); /* continue to process event */ } else { chip->dcdt_retry_count++; /* DCD_T -> roll back previous status */ chip->curr_status = chip->prev_status; RTINFO("DCD_T event triggered, do re-detect\n"); rt8973_clr_bits(chip, RT8973_REG_CONTROL, 0x60); msleep_interruptible(1); rt8973_set_bits(chip, RT8973_REG_CONTROL, 0x60); return; } } rt8973_process_normal_evt(chip); } static irqreturn_t rt8973_irq_handler(int irq, void *data) { struct rt8973_chip *chip = data; wake_lock_timeout(&(chip->muic_wake_lock), msecs_to_jiffies(500)); RTINFO("RT8973 interrupt triggered!\n"); queue_delayed_work(chip->wq, &chip->irq_work, msecs_to_jiffies(250)); return IRQ_HANDLED; } static const struct i2c_device_id rt8973_id_table[] = { {"rt8973", 0}, {}, }; MODULE_DEVICE_TABLE(i2c, rt8973_id_table); static bool rt8973_reset_check(struct i2c_client *iic) { int ret; ret = i2c_smbus_read_byte_data(iic, RT8973_REG_CHIP_ID); if (ret < 0) { RTERR("Error : can't read device ID from IC(%d)\n", ret); return false; } if ((ret & 0x07) != 0x02) { RTERR("Error : vendor ID mismatch (0x%d)!\n", ret); return false; } /* write default value instead of sending reset command*/ /* REG[0x02] = 0xE5, REG[0x14] = 0x01*/ i2c_smbus_write_byte_data(iic, RT8973_REG_CONTROL, 0xE5); i2c_smbus_write_byte_data(iic, RT8973_REG_MANUAL_SW2, 0x01); return true; } #define CHECK_PSY_READY 1 #define BATTERY_PSY_NAME "battery" #define CHARGER_PSY_NAME "sec-charger" #define POLL_DELAY 50 static void rt8973_init_work(struct work_struct *work) { int ret; rt8973_chip_t *chip = container_of(to_delayed_work(work), rt8973_chip_t, init_work); #if CHECK_PSY_READY /* make sure that Samsung battery and battery are ready to receive notification*/ struct power_supply *psy_battery = NULL; struct power_supply *psy_charger = NULL; do { psy_battery = power_supply_get_by_name(BATTERY_PSY_NAME); psy_charger = power_supply_get_by_name(CHARGER_PSY_NAME); if (psy_battery == NULL || psy_charger == NULL) { dev_info(&chip->iic->dev, "RT8973 : Battery and charger are not ready\r\n"); msleep(POLL_DELAY); } } while (psy_battery == NULL || psy_charger == NULL); dev_info(&chip->iic->dev, "RT8973 : Battery and charger are ready\r\n"); #endif /* Dummy read */ rt8973_reg_read(chip, RT8973_REG_INT_FLAG1); rt8973_clr_bits(chip, RT8973_REG_CONTROL, 0x60); msleep_interruptible(1); rt8973_set_bits(chip, RT8973_REG_CONTROL, 0x60); /* enable interrupt */ ret = rt8973_clr_bits(chip, RT8973_REG_CONTROL, 0x01); if (ret < 0) { dev_err(&chip->iic->dev, "can't enable rt8973's INT (%d)\r\n",ret); } /* Execute 1st dectection and report cable type*/ queue_delayed_work(chip->wq, &chip->irq_work, msecs_to_jiffies(50)); } static void rt8973_init_regs(rt8973_chip_t *chip) { int chip_id = rt8973_reg_read(chip, RT8973_REG_CHIP_ID); /* initialize with MUIC_RT8973_CABLE_TYPE_INVALID * to make 1st detection work always report cable type */ chip->curr_status.cable_type = MUIC_RT8973_CABLE_TYPE_INVALID; chip->curr_status.id_adc = 0x1f; /* for rev 0, turn off i2c reset function */ if (((chip_id & 0xf8) >> 3) == 0) rt8973_set_bits(chip, RT8973_REG_CONTROL, 0x08); /* Revision ID >=2 --> RT8973A, it should use Reg[0x23] instead of Reg[0x07] to read ADC */ if (((chip_id & 0xf8) >> 3) >= 2) chip->adc_reg_addr = 0x23; else chip->adc_reg_addr = RT8973_REG_ADC; /* Only mask Connect */ rt8973_reg_write(chip, RT8973_REG_INTERRUPT_MASK1, 0x20); /* Only mask OCP_LATCH and POR */ rt8973_reg_write(chip, RT8973_REG_INTERRUPT_MASK2, 0x24); queue_delayed_work(chip->wq, &chip->init_work, 0); } #ifdef SAMSUNG_MVRL_MUIC_RT8973 static ssize_t adc_show(struct device *dev, struct device_attribute *attr, char *buf) { u8 adc_value[] = "1C"; u8 adc_fail = 0; if (current_status->cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF) { RTINFO("adc_show JIG UART BOOT OFF\n"); return sprintf(buf, "%s\n", adc_value); } else { RTINFO("adc_show no detect\n"); return sprintf(buf, "%d\n", adc_fail); } } static ssize_t usb_state_show_attrs(struct device *dev, struct device_attribute *attr, char *buf) { if (current_status->usb_connect) return sprintf(buf, "USB_STATE_CONFIGURED\n"); else return sprintf(buf, "USB_STATE_NOTCONFIGURED\n"); } static ssize_t usb_sel_show_attrs(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "PDA"); } static DEVICE_ATTR(adc, S_IRUGO | S_IWUSR | S_IWGRP | S_IXOTH /*0665 */ , adc_show, NULL); static DEVICE_ATTR(usb_state, S_IRUGO, usb_state_show_attrs, NULL); static DEVICE_ATTR(usb_sel, S_IRUGO, usb_sel_show_attrs, NULL); static int sec_get_usb_vbus(unsigned int *level) { if (current_status->vbus_status) { RTINFO("set VBUS_HIGH\n"); *level = VBUS_HIGH; } else { RTINFO("set VBUS_LOW\n"); *level = VBUS_LOW; } return 0; } #endif static int rt8973_parse_dt(struct device *dev, struct rt8973_platform_data *pdata) { struct device_node *np = dev->of_node; enum of_gpio_flags irq_gpio_flags; pdata->irq_gpio = of_get_named_gpio_flags(np, "rt8973,irq-gpio", 0, &irq_gpio_flags); return 0; } static int __init rt8973_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct rt8973_platform_data *pdata; struct rt8973_chip *chip; #ifdef SAMSUNG_MVRL_MUIC_RT8973 struct device *switch_dev; #endif int ret; RTINFO("Richtek RT8973 driver %s probing...\n", RT8973_DRV_VER); if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { dev_err(&client->dev, "Failed to allocate memory\n"); ret = -ENOMEM; goto err_nomem; } ret = rt8973_parse_dt(&client->dev, pdata); if (ret < 0) goto err_parse_dt; } else pdata = client->dev.platform_data; #ifdef SAMSUNG_MVRL_MUIC_RT8973 pdata->irq_gpio = pxa_irq_to_gpio(client->irq); RTINFO("GPIO MUIC INT No. = %d\n", pdata->irq_gpio); #endif ret = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK); if (ret < 0) { RTERR("Error : i2c functionality check failed\n"); goto err_i2c_func; } if (!rt8973_reset_check(client)) { ret = -ENODEV; goto err_reset_rt8973_fail; } chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) { ret = -ENOMEM; goto err_nomem; } #ifdef SAMSUNG_MVRL_MUIC_RT8973 current_status = &chip->curr_status; #endif wake_lock_init(&chip->muic_wake_lock, WAKE_LOCK_SUSPEND, "rt8973_wakelock"); ret = gpio_request(pdata->irq_gpio, "RT8973_EINT"); RTWARN_IF(ret < 0, "Warning : failed to request GPIO%d (retval = %d)\n", pdata->irq_gpio, ret); ret = gpio_direction_input(pdata->irq_gpio); RTWARN_IF(ret < 0, "Warning : failed to set GPIO%d as input pin(retval = %d)\n", pdata->irq_gpio, ret); chip->iic = client; chip->dev = &client->dev; chip->pdata = pdata; i2c_set_clientdata(client, chip); chip->wq = create_workqueue("rt8973_workqueue"); INIT_DELAYED_WORK(&chip->irq_work, rt8973_irq_work); INIT_DELAYED_WORK(&chip->init_work, rt8973_init_work); #ifdef SAMSUNG_MVRL_MUIC_RT8973 pxa_usb_set_extern_call(PXA_USB_DEV_OTG, vbus, get_vbus, sec_get_usb_vbus); #endif mutex_init(&chip->io_lock); chip->irq = gpio_to_irq(pdata->irq_gpio); client->irq = chip->irq; RTINFO("Request IRQ %d(GPIO %d)...\n", chip->irq, pdata->irq_gpio); ret = request_irq(chip->irq, rt8973_irq_handler, RT8973_IRQF_MODE | IRQF_NO_SUSPEND, RT8973_DEVICE_NAME, chip); if (ret < 0) { RTERR ("Error : failed to request irq %d (gpio=%d, retval=%d)\n", chip->irq, pdata->irq_gpio, ret); goto err_request_irq_fail; } #ifdef SAMSUNG_MVRL_MUIC_RT8973 switch_dev = device_create(sec_class, NULL, 0, NULL, "switch"); chip->switch_dev = switch_dev; if (device_create_file(switch_dev, &dev_attr_adc) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_adc.attr.name); if (device_create_file(switch_dev, &dev_attr_usb_state) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_usb_state.attr.name); if (device_create_file(switch_dev, &dev_attr_usb_sel) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_usb_sel.attr.name); muic_int_gpio.mfp = pdata->irq_gpio; mmp_gpio_edge_add(&muic_int_gpio); #endif rt8973_init_regs(chip); pr_info("RT8973 : Richtek RT8973 MUIC driver %s initialize successfully\n", RT8973_DRV_VER); return 0; err_request_irq_fail: mutex_destroy(&chip->io_lock); destroy_workqueue(chip->wq); gpio_free(pdata->irq_gpio); wake_lock_destroy(&chip->muic_wake_lock); kfree(chip); err_nomem: err_reset_rt8973_fail: err_i2c_func: err_parse_dt: return ret; } static int __exit rt8973_remove(struct i2c_client *client) { struct rt8973_chip *chip; RTINFO("Richtek RT8973 driver removing...\n"); #ifdef SAMSUNG_MVRL_MUIC_RT8973 mmp_gpio_edge_del(&muic_int_gpio); #endif chip = i2c_get_clientdata(client); if (chip) { free_irq(chip->irq, chip); gpio_free(chip->pdata->irq_gpio); mutex_destroy(&chip->io_lock); if (chip->wq) destroy_workqueue(chip->wq); wake_lock_destroy(&chip->muic_wake_lock); kfree(chip); } return 0; } static void rt8973_shutdown(struct i2c_client *iic) { struct rt8973_chip *chip; chip = i2c_get_clientdata(iic); disable_irq(iic->irq); cancel_delayed_work_sync(&chip->irq_work); pr_info("RT8973 : Shutdown : set rt8973 regs to default setting...\n"); i2c_smbus_write_byte_data(iic, RT8973_REG_CONTROL, 0xE5); i2c_smbus_write_byte_data(iic, RT8973_REG_MANUAL_SW2, 0x01); } #ifdef CONFIG_OF static struct of_device_id rt8973_match_table[] = { { .compatible = "richtek,rt8973",}, {}, }; #else #define rt8973_match_table NULL #endif static struct i2c_driver rt8973_driver = { .driver = { .name = RT8973_DEVICE_NAME, .owner = THIS_MODULE, .of_match_table = rt8973_match_table, }, .probe = rt8973_probe, .remove = rt8973_remove, .shutdown = rt8973_shutdown, .id_table = rt8973_id_table, }; static int __init rt8973_i2c_init(void) { int ret; ret = i2c_add_driver(&rt8973_driver); if (ret != 0) pr_err("Failed to register RT8973 I2C driver: %d\n", ret); return ret; } late_initcall(rt8973_i2c_init); static void __exit rt8973_i2c_exit(void) { i2c_del_driver(&rt8973_driver); } module_exit(rt8973_i2c_exit); MODULE_DESCRIPTION("Richtek RT8973 MUIC Driver"); MODULE_AUTHOR("Patrick Chang "); MODULE_VERSION(RT8973_DRV_VER); MODULE_LICENSE("GPL");