AetherDroid/android_kernel_samsung_on5xelte
1
0
Fork 0
mirror of https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git synced 2025-09-08 09:08:05 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
android_kernel_samsung_on5x.../drivers/muic/universal/muic_regmap_sm5504.c
awab228 f6dfaef42e Fixed MTP to work with TWRP
2018-06-19 23:16:04 +02:00

593 lines
16 KiB
C
Raw Blame History

/*
* muic_regmap_sm5504.c
*
* Copyright (C) 2014 Samsung Electronics
* Thomas Ryu <smilesr.ryu@samsung.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/host_notify.h>
#include <linux/string.h>
#include <linux/muic/muic.h>
#if defined(CONFIG_MUIC_NOTIFIER)
#include <linux/muic/muic_notifier.h>
#endif /* CONFIG_MUIC_NOTIFIER */
#if defined(CONFIG_OF)
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#endif /* CONFIG_OF */
#include "muic-internal.h"
#include "muic_i2c.h"
#include "muic_regmap.h"
enum sm5504_muic_reg_init_value {
REG_INTMASK1_VALUE = (0xDC),
REG_INTMASK2_VALUE = (0x00),
};
/* sm5504 I2C registers */
enum sm5504_muic_reg {
REG_DEVID = 0x01,
REG_CTRL = 0x02,
REG_INT1 = 0x03,
REG_INT2 = 0x04,
REG_INTMASK1 = 0x05,
REG_INTMASK2 = 0x06,
REG_ADC = 0x07,
/* unused registers */
REG_DEVT1 = 0x0a,
REG_DEVT2 = 0x0b,
REG_MANSW1 = 0x13,
REG_MANSW2 = 0x14,
REG_RESET = 0x1B,
REG_SET = 0x20,
/* 0x22 is reserved. */
REG_CHGTYPE = 0x24,
REG_RSVDID4 = 0x3A,
REG_END,
};
#define REG_ITEM(addr, bitp, mask) ((bitp<<16) | (mask<<8) | addr)
/* Field */
enum sm5504_muic_reg_item {
DEVID_VendorID = REG_ITEM(REG_DEVID, _BIT0, _MASK3),
CTRL_USBCHDEN = REG_ITEM(REG_CTRL, _BIT6, _MASK1),
CTRL_SW_OPEN = REG_ITEM(REG_CTRL, _BIT4, _MASK1),
CTRL_RAWDATA = REG_ITEM(REG_CTRL, _BIT3, _MASK1),
CTRL_ManualSW = REG_ITEM(REG_CTRL, _BIT2, _MASK1),
CTRL_MASK_INT = REG_ITEM(REG_CTRL, _BIT0, _MASK1),
INT1_ADC_CHG = REG_ITEM(REG_INT1, _BIT6, _MASK1),
INT1_CONNECT = REG_ITEM(REG_INT1, _BIT5, _MASK1),
INT1_OVP_EVENT = REG_ITEM(REG_INT1, _BIT4, _MASK1),
INT1_DCD_OUT = REG_ITEM(REG_INT1, _BIT3, _MASK1),
INT1_CHG_DET = REG_ITEM(REG_INT1, _BIT2, _MASK1),
INT1_DETACH = REG_ITEM(REG_INT1, _BIT1, _MASK1),
INT1_ATTACH = REG_ITEM(REG_INT1, _BIT0, _MASK1),
INT2_OVP_OCP = REG_ITEM(REG_INT2, _BIT7, _MASK1),
INT2_OCP = REG_ITEM(REG_INT2, _BIT6, _MASK1),
INT2_OCP_LATCH = REG_ITEM(REG_INT2, _BIT5, _MASK1),
INT2_OVP_FET = REG_ITEM(REG_INT2, _BIT4, _MASK1),
INT2_ROP = REG_ITEM(REG_INT2, _BIT2, _MASK1),
INT2_UVLO = REG_ITEM(REG_INT2, _BIT1, _MASK1),
INT2_RID_CHG = REG_ITEM(REG_INT2, _BIT0, _MASK1),
INTMASK1_ADC_CHG = REG_ITEM(REG_INTMASK1, _BIT6, _MASK1),
INTMASK1_CONNECT = REG_ITEM(REG_INTMASK1, _BIT5, _MASK1),
INTMASK1_OVP_EVENT = REG_ITEM(REG_INTMASK1, _BIT4, _MASK1),
INTMASK1_DCD_OUT = REG_ITEM(REG_INTMASK1, _BIT3, _MASK1),
INTMASK1_CHG_DET = REG_ITEM(REG_INTMASK1, _BIT2, _MASK1),
INTMASK1_DETACH = REG_ITEM(REG_INTMASK1, _BIT1, _MASK1),
INTMASK1_ATTACH = REG_ITEM(REG_INTMASK1, _BIT0, _MASK1),
INTMASK2_OVP_OCP = REG_ITEM(REG_INTMASK2, _BIT7, _MASK1),
INTMASK2_OCP = REG_ITEM(REG_INTMASK2, _BIT6, _MASK1),
INTMASK2_OCP_LATCH = REG_ITEM(REG_INTMASK2, _BIT5, _MASK1),
INTMASK2_OVP_FET = REG_ITEM(REG_INTMASK2, _BIT4, _MASK1),
INTMASK2_ROP = REG_ITEM(REG_INTMASK2, _BIT2, _MASK1),
INTMASK2_UVLO = REG_ITEM(REG_INTMASK2, _BIT1, _MASK1),
INTMASK2_RID_CHG = REG_ITEM(REG_INTMASK2, _BIT0, _MASK1),
ADC_VALUE = REG_ITEM(REG_ADC, _BIT0, _MASK5),
DEVT1_DEDICATED_CHG = REG_ITEM(REG_DEVT1, _BIT6, _MASK1),
DEVT1_USB_CHG = REG_ITEM(REG_DEVT1, _BIT5, _MASK1),
DEVT1_CAR_KIT_CHARGER = REG_ITEM(REG_DEVT1, _BIT4, _MASK1),
DEVT1_UART = REG_ITEM(REG_DEVT1, _BIT3, _MASK1),
DEVT1_USB = REG_ITEM(REG_DEVT1, _BIT2, _MASK1),
DEVT1_USB_OTG = REG_ITEM(REG_DEVT1, _BIT0, _MASK1),
DEVT2_UNKOWN = REG_ITEM(REG_DEVT2, _BIT6, _MASK1),
DEVT2_JIG_UART_OFF = REG_ITEM(REG_DEVT2, _BIT3, _MASK1),
DEVT2_JIG_UART_ON = REG_ITEM(REG_DEVT2, _BIT2, _MASK1),
DEVT2_JIG_USB_OFF = REG_ITEM(REG_DEVT2, _BIT1, _MASK1),
DEVT2_JIG_USB_ON = REG_ITEM(REG_DEVT2, _BIT0, _MASK1),
MANSW1_DM_CON_SW = REG_ITEM(REG_MANSW1, _BIT5, _MASK3),
MANSW1_DP_CON_SW = REG_ITEM(REG_MANSW1, _BIT2, _MASK3),
MANSW2_BOOT_SW = REG_ITEM(REG_MANSW2, _BIT3, _MASK1),
MANSW2_JIG_ON = REG_ITEM(REG_MANSW2, _BIT2, _MASK1),
MANSW2_VBUS = REG_ITEM(REG_MANSW2, _BIT0, _MASK1),
RESET_RESET = REG_ITEM(REG_RESET, _BIT0, _MASK1),
CHGTYPE_CHG_TYPE = REG_ITEM(REG_CHGTYPE, _BIT0, _MASK5),
};
enum sm5504_muic_devt1{
SM5504_DEVT1_DCP = (0x1 << 6),
SM5504_DEVT1_CDP = (0x1 << 5),
SM5504_DEVT1_CAR_KIT_CHARGER = (0x1 << 4),
SM5504_DEVT1_UART = (0x1 << 3),
SM5504_DEVT1_USB = (0x1 << 2),
SM5504_DEVT1_USB_OTG = (0x1 << 0),
};
enum sm5504_muic_devt2{
SM5504_DEVT2_UNKOWN = (0x1 << 6),
SM5504_DEVT2_JIG_UART_OFF = (0x1 << 3),
SM5504_DEVT2_JIG_UART_ON = (0x1 << 2),
SM5504_DEVT2_JIG_USB_OFF = (0x1 << 1),
SM5504_DEVT2_JIG_USB_ON = (0x1 << 0),
};
/* sm5504 Control register */
#define CTRL_ADC_EN_SHIFT 7
#define CTRL_USBCHDEN_SHIFT 6
#define CTRL_CHGTYP_SHIFT 5
#define CTRL_SWITCH_OPEN_SHIFT 4
#define CTRL_RAW_DATA_SHIFT 3
#define CTRL_MANUAL_SW_SHIFT 2
#define CTRL_INT_MASK_SHIFT 0
#define CTRL_ADC_EN_MASK (0x1 << CTRL_ADC_EN_SHIFT)
#define CTRL_USBCHDEN_MASK (0x1 << CTRL_USBCHDEN_SHIFT)
#define CTRL_CHGTYP_MASK (0x1 << CTRL_CHGTYP_SHIFT)
#define CTRL_SWITCH_OPEN_MASK (0x0 << CTRL_SWITCH_OPEN_SHIFT)
#define CTRL_RAW_DATA_MASK (0x0 << CTRL_RAW_DATA_SHIFT)
#define CTRL_MANUAL_SW_MASK (0x1 << CTRL_MANUAL_SW_SHIFT)
#define CTRL_INT_MASK_MASK (0x1 << CTRL_INT_MASK_SHIFT)
#define CTRL_MASK (CTRL_ADC_EN_MASK | CTRL_USBCHDEN_MASK | \
CTRL_CHGTYP_MASK | CTRL_SWITCH_OPEN_MASK | \
CTRL_RAW_DATA_MASK | CTRL_MANUAL_SW_MASK | \
CTRL_INT_MASK_MASK)
#define INT2_UVLO_MASK (0x1 << 1)
#define REG_CTRL_INITIAL (CTRL_MASK | CTRL_MANUAL_SW_MASK)
/*
* Manual Switch
* D- [7:5] / D+ [4:2] / Vbus [1:0]
* 000: Open all / 001: USB / 010: AUDIO / 011: UART / 100: V_AUDIO
* 00: Vbus to Open / 01: Vbus to Charger / 10: Vbus to MIC / 11: Vbus to VBout
*/
#define _D_OPEN (0x0)
#define _D_USB (0x1)
#define _D_UART (0x3)
/* COM patch Values */
#define COM_VALUE(dm) ((dm<<5) | (dm<<2))
#define _COM_OPEN COM_VALUE(_D_OPEN)
#define _COM_UART_AP COM_VALUE(_D_UART)
#define _COM_UART_CP _COM_UART_AP
#define _COM_USB_AP COM_VALUE(_D_USB)
#define _COM_USB_CP _COM_USB_AP
static int sm5703_com_value_tbl[] = {
[COM_OPEN] = _COM_OPEN,
[COM_UART_AP] = _COM_UART_AP,
[COM_UART_CP] = _COM_UART_CP,
[COM_USB_AP] = _COM_USB_AP,
[COM_USB_CP] = _COM_USB_CP,
};
#define INIT_VBUS_140MS (0x0E)
#define INIT_VBUS_300MS (0x06)
static regmap_t sm5504_muic_regmap_table[] = {
[REG_DEVID] = {"DeviceID", 0x01, 0x00, INIT_NONE},
[REG_CTRL] = {"CONTROL", 0x1F, 0x00, REG_CTRL_INITIAL,},
[REG_INT1] = {"INT1", 0x00, 0x00, INIT_NONE,},
[REG_INT2] = {"INT2", 0x00, 0x00, INIT_NONE,},
[REG_INTMASK1] = {"INTMASK1", 0x00, 0x00, REG_INTMASK1_VALUE,},
[REG_INTMASK2] = {"INTMASK2", 0x00, 0x00, REG_INTMASK2_VALUE,},
[REG_ADC] = {"ADC", 0x1F, 0x00, INIT_NONE,},
[REG_DEVT1] = {"DEVICETYPE1", 0xFF, 0x00, INIT_NONE,},
[REG_DEVT2] = {"DEVICETYPE2", 0xFF, 0x00, INIT_NONE,},
/* 0x0F ~ 0x12: Reserved */
[REG_MANSW1] = {"ManualSW1", 0x00, 0x00, INIT_NONE,},
[REG_MANSW2] = {"ManualSW2", 0x00, 0x00, INIT_NONE,},
/* 0x16 ~ 0x1A: Reserved */
[REG_RESET] = {"RESET", 0x00, 0x00, INIT_NONE,},
/* 0x1C: Reserved */
/* 0x1E ~ 0x1F: Reserved */
[REG_SET] = {"Reserved_ID2", 0x06, 0x00, INIT_VBUS_140MS,},
/* 0x22: Reserved */
[REG_CHGTYPE] = {"REG_CHG_TYPE", 0xFF, 0x00, INIT_NONE,},
[REG_END] = {NULL, 0, 0, INIT_NONE},
};
static int sm5504_muic_ioctl(struct regmap_desc *pdesc,
int arg1, int *arg2, int *arg3)
{
int ret = 0;
switch (arg1) {
case GET_COM_VAL:
*arg2 = sm5703_com_value_tbl[*arg2];
*arg3 = REG_MANSW1;
break;
case GET_CTLREG:
*arg3 = REG_CTRL;
break;
case GET_ADC:
*arg3 = ADC_VALUE;
break;
case GET_SWITCHING_MODE:
*arg3 = CTRL_ManualSW;
break;
case GET_INT_MASK:
*arg3 = CTRL_MASK_INT;
break;
case GET_REVISION:
*arg3 = DEVID_VendorID;
break;
case GET_OTG_STATUS:
*arg3 = INTMASK2_RID_CHG;
break;
case GET_CHGTYPE:
*arg3 = CHGTYPE_CHG_TYPE;
break;
case GET_RESID3:
*arg3 = CTRL_USBCHDEN;
break;
default:
ret = -1;
break;
}
if (pdesc->trace) {
pr_info("%s: ret:%d arg1:%x,", __func__, ret, arg1);
if (arg2)
pr_info(" arg2:%x,", *arg2);
if (arg3)
pr_info(" arg3:%x - %s", *arg3,
regmap_to_name(pdesc, _ATTR_ADDR(*arg3)));
pr_info("\n");
}
return ret;
}
static int sm5504_attach_ta(struct regmap_desc *pdesc)
{
int attr = 0, value = 0, ret = 0;
pr_info("%s\n", __func__);
do {
attr = REG_MANSW1 | _ATTR_OVERWRITE_M;
value = _COM_OPEN;
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s REG_MANSW1 write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
attr = CTRL_ManualSW;
value = 0; /* manual switching mode */
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s REG_CTRL write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
} while (0);
return ret;
}
static int sm5504_detach_ta(struct regmap_desc *pdesc)
{
int attr = 0, value = 0, ret = 0;
pr_info("%s\n", __func__);
do {
attr = REG_MANSW1 | _ATTR_OVERWRITE_M;
value = _COM_OPEN;
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s REG_MANSW1 write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
attr = CTRL_ManualSW;
value = 1; /* auto switching mode */
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s REG_CTRL write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
} while (0);
return ret;
}
static int sm5504_set_rustproof(struct regmap_desc *pdesc, int op)
{
int attr = 0, value = 0, ret = 0;
pr_info("%s\n", __func__);
do {
attr = MANSW2_JIG_ON;
value = op ? 1 : 0;
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s MANSW2_JIG_ON write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
attr = CTRL_ManualSW;
value = op ? 0 : 1;
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s CTRL_ManualSW write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
} while (0);
return ret;
}
static int sm5504_set_manual_JIGON(struct regmap_desc *pdesc, int jig_attached)
{
int attr = 0, value = 0, ret = 0;
pr_info("%s\n", __func__);
do {
attr = MANSW2_JIG_ON;
value = jig_attached ? 1 : 0; /* 1: LOW, 0: High impedance */
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s MANSW2_JIG_ON write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
attr = CTRL_ManualSW;
value = jig_attached ? 0 : 1; /* 0: manual, 1: auto */
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0) {
pr_err("%s CTRL_ManualSW write fail.\n", __func__);
break;
}
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
} while (0);
return ret;
}
static int sm5504_get_vps_data(struct regmap_desc *pdesc, void *pbuf)
{
muic_data_t *pmuic = pdesc->muic;
vps_data_t *pvps = (vps_data_t *)pbuf;
int attr;
if (pdesc->trace)
pr_info("%s\n", __func__);
*(u8 *)&pvps->s.val1 = muic_i2c_read_byte(pmuic->i2c, REG_DEVT1);
*(u8 *)&pvps->s.val2 = muic_i2c_read_byte(pmuic->i2c, REG_DEVT2);
attr = ADC_VALUE;
*(u8 *)&pvps->s.adc = regmap_read_value(pdesc, attr);
pvps->t.attached_dev = ATTACHED_DEV_UNKNOWN_MUIC;
pvps->s.vbvolt = !(pmuic->intr.intr2 & INT2_UVLO_MASK);
switch (pvps->s.val1) {
case SM5504_DEVT1_CDP:
pvps->t.attached_dev = ATTACHED_DEV_CDP_MUIC;
pr_info("%s : USB_CDP DETECTED\n", MUIC_DEV_NAME);
break;
case SM5504_DEVT1_USB:
pvps->t.attached_dev = ATTACHED_DEV_USB_MUIC;
pr_info("%s : USB DETECTED\n", MUIC_DEV_NAME);
break;
case SM5504_DEVT1_CAR_KIT_CHARGER:
case SM5504_DEVT1_DCP:
if (ADC_CEA936ATYPE1_CHG != pvps->s.adc) {
pvps->t.attached_dev = ATTACHED_DEV_TA_MUIC;
pr_info("%s : DEDICATED CHARGER DETECTED\n", MUIC_DEV_NAME);
}
break;
case SM5504_DEVT1_USB_OTG:
pvps->t.attached_dev = ATTACHED_DEV_OTG_MUIC;
pr_info("%s : USB_OTG DETECTED\n", MUIC_DEV_NAME);
break;
default:
break;
}
switch (pvps->s.val2) {
case SM5504_DEVT2_JIG_UART_OFF:
pvps->t.attached_dev = ATTACHED_DEV_JIG_UART_OFF_MUIC;
pr_info("%s : JIG_UART_OFF DETECTED\n", MUIC_DEV_NAME);
break;
case SM5504_DEVT2_JIG_USB_OFF:
pvps->t.attached_dev = ATTACHED_DEV_JIG_USB_OFF_MUIC;
pr_info("%s : JIG_USB_OFF DETECTED\n", MUIC_DEV_NAME);
break;
case SM5504_DEVT2_JIG_USB_ON:
pvps->t.attached_dev = ATTACHED_DEV_JIG_USB_ON_MUIC;
pr_info("%s : JIG_USB_ON DETECTED\n", MUIC_DEV_NAME);
break;
case SM5504_DEVT2_JIG_UART_ON:
pvps->t.attached_dev = ATTACHED_DEV_JIG_UART_ON_MUIC;
pr_info("%s : JIG_UART_ON DETECTED\n", MUIC_DEV_NAME);
break;
default:
break;
}
return 0;
}
enum switching_mode_val{
_SWMODE_AUTO =1,
_SWMODE_MANUAL =0,
};
static int sm5504_get_switching_mode(struct regmap_desc *pdesc)
{
int attr, value, mode;
pr_info("%s\n",__func__);
attr = CTRL_ManualSW;
value = regmap_read_value(pdesc, attr);
mode = (value == _SWMODE_AUTO) ? SWMODE_AUTO : SWMODE_MANUAL;
return mode;
}
static void sm5504_set_switching_mode(struct regmap_desc *pdesc, int mode)
{
int attr, value;
int ret = 0;
pr_info("%s\n",__func__);
value = (mode == SWMODE_AUTO) ? _SWMODE_AUTO : _SWMODE_MANUAL;
attr = CTRL_ManualSW;
ret = regmap_write_value(pdesc, attr, value);
if (ret < 0)
pr_err("%s REG_CTRL write fail.\n", __func__);
else
_REGMAP_TRACE(pdesc, 'w', ret, attr, value);
}
static void sm5504_get_fromatted_dump(struct regmap_desc *pdesc, char *mesg)
{
muic_data_t *muic = pdesc->muic;
int val;
if (pdesc->trace)
pr_info("%s\n", __func__);
val = i2c_smbus_read_byte_data(muic->i2c, REG_CTRL);
sprintf(mesg, "CT:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_INTMASK1);
sprintf(mesg+strlen(mesg), "IM1:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_INTMASK2);
sprintf(mesg+strlen(mesg), "IM2:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_MANSW1);
sprintf(mesg+strlen(mesg), "MS1:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_MANSW2);
sprintf(mesg+strlen(mesg), "MS2:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_ADC);
sprintf(mesg+strlen(mesg), "ADC:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_DEVT1);
sprintf(mesg+strlen(mesg), "DT1:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_DEVT2);
sprintf(mesg+strlen(mesg), "DT2:%x ", val);
val = i2c_smbus_read_byte_data(muic->i2c, REG_SET);
sprintf(mesg+strlen(mesg), "RS2:%x", val);
}
static int sm5504_get_sizeof_regmap(void)
{
pr_info("%s:%s\n", MUIC_DEV_NAME, __func__);
return (int)ARRAY_SIZE(sm5504_muic_regmap_table);
}
static struct regmap_ops sm5504_muic_regmap_ops = {
.get_size = sm5504_get_sizeof_regmap,
.ioctl = sm5504_muic_ioctl,
.get_formatted_dump = sm5504_get_fromatted_dump,
};
static struct vendor_ops sm5504_muic_vendor_ops = {
.attach_ta = sm5504_attach_ta,
.detach_ta = sm5504_detach_ta,
.get_switch = sm5504_get_switching_mode,
.set_switch = sm5504_set_switching_mode,
.get_vps_data = sm5504_get_vps_data,
.set_rustproof = sm5504_set_rustproof,
.set_manual_JIGON = sm5504_set_manual_JIGON,
};
static struct regmap_desc sm5504_muic_regmap_desc = {
.name = "sm5504-MUIC",
.regmap = sm5504_muic_regmap_table,
.size = REG_END,
.regmapops = &sm5504_muic_regmap_ops,
.vendorops = &sm5504_muic_vendor_ops,
};
void muic_register_sm5504_regmap_desc(struct regmap_desc **pdesc)
{
*pdesc = &sm5504_muic_regmap_desc;
}
Reference in a new issue View git blame Copy permalink