android/android_kernel_samsung_sm8650
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update extcon next for v5.14

Browse Source 
Detailed description for this pull request:
 1. Update extcon-sm5502 provider driver
 - Convert devicetree binding document sytle with yaml
   for extcon-sm5502.c and add support for SM5504 chip to extcon-sm5502.c.
 - Use devm_regmap_add_irq_chip and probe_new for extcon-sm5502.c
 
 2. Add missing modalias string for extcon-max8997.c.
 
 3. Initialize the status data of extcon-intel-mrfld.c on probe time
 in order to prevent the mismatch issue.
 -----BEGIN PGP SIGNATURE-----
 
 iQJKBAABCgA0FiEEsSpuqBtbWtRe4rLGnM3fLN7rz1MFAmDTBJcWHGN3MDAuY2hv
 aUBzYW1zdW5nLmNvbQAKCRCczd8s3uvPU+BqD/43BUdxAadlCldrM0VOtr2WcVfo
 oyvc/ibTnQvufq99t74P2J653w2R4dnQOeGBTZqozB8QSn2NmZ9VtBCTPXbK542C
 y/04zRmg6pajBbMu3f54N9YJdTBWxAiA5+/mLN6BpEyokTFKO53eDJrCdLdr8M4m
 mhuYy2dJwze0RZcVO9OukQicp+YRWsoLY7kUSS5beMz9Z2/2QfCVoaw5XavYMzfG
 dbrxnM+Z/d8KO+AQyQ9Tnm8qD4Grii6gEY0dNtobs+ULAcqqnIc37FFK/bd5y4ud
 3v0a3k2is12lkqHZHI7nPJKi7gkE5IN1je7NJE9MDYzxTBg0mQeKsxYjneKdt5dq
 g6tmGxnYhOCz7WME+OsSXP3cSEQAS15yeCAlkFqim/kw/mcK/IB93srz0/vUR8B0
 zR6saNXSpRcmcfs7CpQVg/byUPIrTGgKhyONCkx6/0B2e61caIhhl3+CO+BeW57p
 G9fYUU0ESGbx1BTGANU8D9bCgdObTwua3Lag80Vyvoh09OLzMGjOBYownzx7ViRY
 cZOx0fUT9bGA0SkAk7TkHziRuLgT/4XW4Br1S68g7+iH2+gn7L/b958kBQGOnSBF
 qw0b9dQTvFi48v8nhCTFRsr9F8bjeidEvnrftcJfVXyMgBwJaHYaBkTcAC45MHg8
 b900on5V4v+W0pZl7g==
 =RcdY
 -----END PGP SIGNATURE-----

Merge tag 'extcon-next-for-5.14' of git://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/extcon into char-misc-next

Chanwoo writes:

Update extcon next for v5.14

Detailed description for this pull request:
1. Update extcon-sm5502 provider driver
- Convert devicetree binding document sytle with yaml
  for extcon-sm5502.c and add support for SM5504 chip to extcon-sm5502.c.
- Use devm_regmap_add_irq_chip and probe_new for extcon-sm5502.c

2. Add missing modalias string for extcon-max8997.c.

3. Initialize the status data of extcon-intel-mrfld.c on probe time
in order to prevent the mismatch issue.

* tag 'extcon-next-for-5.14' of git://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/extcon:
  extcon: sm5502: Add support for SM5504
  extcon: sm5502: Refactor driver to use chip-specific struct
  dt-bindings: extcon: sm5502: Document siliconmitus,sm5504-muic
  dt-bindings: extcon: sm5502: Convert to DT schema
  extcon: sm5502: Implement i2c_driver->probe_new()
  extcon: sm5502: Use devm_regmap_add_irq_chip()
  extcon: max8997: Add missing modalias string
  extcon: sm5502: Drop invalid register write in sm5502_reg_data
  extcon: intel-mrfld: Sync hardware and software state on init
This commit is contained in:
Greg Kroah-Hartman 2021-06-23 13:37:29 +02:00
commit d4e1406618
7 changed files with 310 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Documentation/devicetree/bindings/extcon/extcon-sm5502.txt
View File

@ -1,21 +0,0 @@
* SM5502 MUIC (Micro-USB Interface Controller) device
The Silicon Mitus SM5502 is a MUIC (Micro-USB Interface Controller) device
which can detect the state of external accessory when external accessory is
attached or detached and button is pressed or released. It is interfaced to
the host controller using an I2C interface.
Required properties:
- compatible: Should be "siliconmitus,sm5502-muic"
- reg: Specifies the I2C slave address of the MUIC block. It should be 0x25
- interrupts: Interrupt specifiers for detection interrupt sources.
Example:
sm5502@25 {
compatible = "siliconmitus,sm5502-muic";
interrupt-parent = <&gpx1>;
interrupts = <5 0>;
reg = <0x25>;
};

52
Documentation/devicetree/bindings/extcon/siliconmitus,sm5502-muic.yaml Normal file
View File

@ -0,0 +1,52 @@
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
%YAML 1.2
---
$id: http://devicetree.org/schemas/extcon/siliconmitus,sm5502-muic.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: SM5502/SM5504 MUIC (Micro-USB Interface Controller) device
maintainers:
- Chanwoo Choi <cw00.choi@samsung.com>
description:
The Silicon Mitus SM5502 is a MUIC (Micro-USB Interface Controller) device
which can detect the state of external accessory when external accessory is
attached or detached and button is pressed or released. It is interfaced to
the host controller using an I2C interface.
properties:
compatible:
enum:
- siliconmitus,sm5502-muic
- siliconmitus,sm5504-muic
reg:
maxItems: 1
description: I2C slave address of the device. Usually 0x25 for SM5502,
0x14 for SM5504.
interrupts:
maxItems: 1
required:
- compatible
- reg
- interrupts
additionalProperties: false
examples:
- |
#include <dt-bindings/interrupt-controller/irq.h>
i2c {
#address-cells = <1>;
#size-cells = <0>;
extcon@25 {
compatible = "siliconmitus,sm5502-muic";
reg = <0x25>;
interrupt-parent = <&msmgpio>;
interrupts = <12 IRQ_TYPE_EDGE_FALLING>;
};
};

2
drivers/extcon/Kconfig
View File

@ -154,7 +154,7 @@ config EXTCON_RT8973A
from abnormal high input voltage (up to 28V).
config EXTCON_SM5502
tristate "Silicon Mitus SM5502 EXTCON support"
tristate "Silicon Mitus SM5502/SM5504 EXTCON support"
depends on I2C
select IRQ_DOMAIN
select REGMAP_I2C

9
drivers/extcon/extcon-intel-mrfld.c
View File

@ -197,6 +197,7 @@ static int mrfld_extcon_probe(struct platform_device *pdev)
struct intel_soc_pmic *pmic = dev_get_drvdata(dev->parent);
struct regmap *regmap = pmic->regmap;
struct mrfld_extcon_data *data;
unsigned int status;
unsigned int id;
int irq, ret;
@ -244,6 +245,14 @@ static int mrfld_extcon_probe(struct platform_device *pdev)
/* Get initial state */
mrfld_extcon_role_detect(data);
/*
* Cached status value is used for cable detection, see comments
* in mrfld_extcon_cable_detect(), we need to sync cached value
* with a real state of the hardware.
*/
regmap_read(regmap, BCOVE_SCHGRIRQ1, &status);
data->status = status;
mrfld_extcon_clear(data, BCOVE_MIRQLVL1, BCOVE_LVL1_CHGR);
mrfld_extcon_clear(data, BCOVE_MCHGRIRQ1, BCOVE_CHGRIRQ_ALL);

1
drivers/extcon/extcon-max8997.c
View File

@ -788,3 +788,4 @@ module_platform_driver(max8997_muic_driver);
MODULE_DESCRIPTION("Maxim MAX8997 Extcon driver");
MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:max8997-muic");

212
drivers/extcon/extcon-sm5502.c
View File

@ -40,17 +40,13 @@ struct sm5502_muic_info {
struct i2c_client *i2c;
struct regmap *regmap;
const struct sm5502_type *type;
struct regmap_irq_chip_data *irq_data;
struct muic_irq *muic_irqs;
unsigned int num_muic_irqs;
int irq;
bool irq_attach;
bool irq_detach;
struct work_struct irq_work;
struct reg_data *reg_data;
unsigned int num_reg_data;
struct mutex mutex;
/*
@ -62,6 +58,18 @@ struct sm5502_muic_info {
struct delayed_work wq_detcable;
};
struct sm5502_type {
struct muic_irq *muic_irqs;
unsigned int num_muic_irqs;
const struct regmap_irq_chip *irq_chip;
struct reg_data *reg_data;
unsigned int num_reg_data;
unsigned int otg_dev_type1;
int (*parse_irq)(struct sm5502_muic_info *info, int irq_type);
};
/* Default value of SM5502 register to bring up MUIC device. */
static struct reg_data sm5502_reg_data[] = {
{
@ -88,7 +96,33 @@ static struct reg_data sm5502_reg_data[] = {
| SM5502_REG_INTM2_MHL_MASK,
.invert = true,
},
{ }
};
/* Default value of SM5504 register to bring up MUIC device. */
static struct reg_data sm5504_reg_data[] = {
{
.reg = SM5502_REG_RESET,
.val = SM5502_REG_RESET_MASK,
.invert = true,
}, {
.reg = SM5502_REG_INTMASK1,
.val = SM5504_REG_INTM1_ATTACH_MASK
| SM5504_REG_INTM1_DETACH_MASK,
.invert = false,
}, {
.reg = SM5502_REG_INTMASK2,
.val = SM5504_REG_INTM2_RID_CHG_MASK
| SM5504_REG_INTM2_UVLO_MASK
| SM5504_REG_INTM2_POR_MASK,
.invert = true,
}, {
.reg = SM5502_REG_CONTROL,
.val = SM5502_REG_CONTROL_MANUAL_SW_MASK
| SM5504_REG_CONTROL_CHGTYP_MASK
| SM5504_REG_CONTROL_USBCHDEN_MASK
| SM5504_REG_CONTROL_ADC_EN_MASK,
.invert = true,
},
};
/* List of detectable cables */
@ -199,6 +233,55 @@ static const struct regmap_irq_chip sm5502_muic_irq_chip = {
.num_irqs = ARRAY_SIZE(sm5502_irqs),
};
/* List of supported interrupt for SM5504 */
static struct muic_irq sm5504_muic_irqs[] = {
{ SM5504_IRQ_INT1_ATTACH, "muic-attach" },
{ SM5504_IRQ_INT1_DETACH, "muic-detach" },
{ SM5504_IRQ_INT1_CHG_DET, "muic-chg-det" },
{ SM5504_IRQ_INT1_DCD_OUT, "muic-dcd-out" },
{ SM5504_IRQ_INT1_OVP_EVENT, "muic-ovp-event" },
{ SM5504_IRQ_INT1_CONNECT, "muic-connect" },
{ SM5504_IRQ_INT1_ADC_CHG, "muic-adc-chg" },
{ SM5504_IRQ_INT2_RID_CHG, "muic-rid-chg" },
{ SM5504_IRQ_INT2_UVLO, "muic-uvlo" },
{ SM5504_IRQ_INT2_POR, "muic-por" },
{ SM5504_IRQ_INT2_OVP_FET, "muic-ovp-fet" },
{ SM5504_IRQ_INT2_OCP_LATCH, "muic-ocp-latch" },
{ SM5504_IRQ_INT2_OCP_EVENT, "muic-ocp-event" },
{ SM5504_IRQ_INT2_OVP_OCP_EVENT, "muic-ovp-ocp-event" },
};
/* Define interrupt list of SM5504 to register regmap_irq */
static const struct regmap_irq sm5504_irqs[] = {
/* INT1 interrupts */
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_ATTACH_MASK, },
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_DETACH_MASK, },
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_CHG_DET_MASK, },
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_DCD_OUT_MASK, },
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_OVP_MASK, },
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_CONNECT_MASK, },
{ .reg_offset = 0, .mask = SM5504_IRQ_INT1_ADC_CHG_MASK, },
/* INT2 interrupts */
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_RID_CHG_MASK,},
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_UVLO_MASK, },
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_POR_MASK, },
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_OVP_FET_MASK, },
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_OCP_LATCH_MASK, },
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_OCP_EVENT_MASK, },
{ .reg_offset = 1, .mask = SM5504_IRQ_INT2_OVP_OCP_EVENT_MASK, },
};
static const struct regmap_irq_chip sm5504_muic_irq_chip = {
.name = "sm5504",
.status_base = SM5502_REG_INT1,
.mask_base = SM5502_REG_INTMASK1,
.mask_invert = false,
.num_regs = 2,
.irqs = sm5504_irqs,
.num_irqs = ARRAY_SIZE(sm5504_irqs),
};
/* Define regmap configuration of SM5502 for I2C communication */
static bool sm5502_muic_volatile_reg(struct device *dev, unsigned int reg)
{
@ -302,11 +385,9 @@ static unsigned int sm5502_muic_get_cable_type(struct sm5502_muic_info *info)
return ret;
}
switch (dev_type1) {
case SM5502_REG_DEV_TYPE1_USB_OTG_MASK:
if (dev_type1 == info->type->otg_dev_type1) {
cable_type = SM5502_MUIC_ADC_GROUND_USB_OTG;
break;
default:
} else {
dev_dbg(info->dev,
"cannot identify the cable type: adc(0x%x), dev_type1(0x%x)\n",
adc, dev_type1);
@ -359,6 +440,11 @@ static unsigned int sm5502_muic_get_cable_type(struct sm5502_muic_info *info)
return ret;
}
if (dev_type1 == info->type->otg_dev_type1) {
cable_type = SM5502_MUIC_ADC_OPEN_USB_OTG;
break;
}
switch (dev_type1) {
case SM5502_REG_DEV_TYPE1_USB_SDP_MASK:
cable_type = SM5502_MUIC_ADC_OPEN_USB;
@ -366,9 +452,6 @@ static unsigned int sm5502_muic_get_cable_type(struct sm5502_muic_info *info)
case SM5502_REG_DEV_TYPE1_DEDICATED_CHG_MASK:
cable_type = SM5502_MUIC_ADC_OPEN_TA;
break;
case SM5502_REG_DEV_TYPE1_USB_OTG_MASK:
cable_type = SM5502_MUIC_ADC_OPEN_USB_OTG;
break;
default:
dev_dbg(info->dev,
"cannot identify the cable type: adc(0x%x)\n",
@ -498,16 +581,44 @@ static int sm5502_parse_irq(struct sm5502_muic_info *info, int irq_type)
return 0;
}
static int sm5504_parse_irq(struct sm5502_muic_info *info, int irq_type)
{
switch (irq_type) {
case SM5504_IRQ_INT1_ATTACH:
info->irq_attach = true;
break;
case SM5504_IRQ_INT1_DETACH:
info->irq_detach = true;
break;
case SM5504_IRQ_INT1_CHG_DET:
case SM5504_IRQ_INT1_DCD_OUT:
case SM5504_IRQ_INT1_OVP_EVENT:
case SM5504_IRQ_INT1_CONNECT:
case SM5504_IRQ_INT1_ADC_CHG:
case SM5504_IRQ_INT2_RID_CHG:
case SM5504_IRQ_INT2_UVLO:
case SM5504_IRQ_INT2_POR:
case SM5504_IRQ_INT2_OVP_FET:
case SM5504_IRQ_INT2_OCP_LATCH:
case SM5504_IRQ_INT2_OCP_EVENT:
case SM5504_IRQ_INT2_OVP_OCP_EVENT:
default:
break;
}
return 0;
}
static irqreturn_t sm5502_muic_irq_handler(int irq, void *data)
{
struct sm5502_muic_info *info = data;
int i, irq_type = -1, ret;
for (i = 0; i < info->num_muic_irqs; i++)
if (irq == info->muic_irqs[i].virq)
irq_type = info->muic_irqs[i].irq;
for (i = 0; i < info->type->num_muic_irqs; i++)
if (irq == info->type->muic_irqs[i].virq)
irq_type = info->type->muic_irqs[i].irq;
ret = sm5502_parse_irq(info, irq_type);
ret = info->type->parse_irq(info, irq_type);
if (ret < 0) {
dev_warn(info->dev, "cannot handle is interrupt:%d\n",
irq_type);
@ -552,19 +663,18 @@ static void sm5502_init_dev_type(struct sm5502_muic_info *info)
version_id, vendor_id);
/* Initiazle the register of SM5502 device to bring-up */
for (i = 0; i < info->num_reg_data; i++) {
for (i = 0; i < info->type->num_reg_data; i++) {
unsigned int val = 0;
if (!info->reg_data[i].invert)
val |= ~info->reg_data[i].val;
if (!info->type->reg_data[i].invert)
val |= ~info->type->reg_data[i].val;
else
val = info->reg_data[i].val;
regmap_write(info->regmap, info->reg_data[i].reg, val);
val = info->type->reg_data[i].val;
regmap_write(info->regmap, info->type->reg_data[i].reg, val);
}
}
static int sm5022_muic_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
static int sm5022_muic_i2c_probe(struct i2c_client *i2c)
{
struct device_node *np = i2c->dev.of_node;
struct sm5502_muic_info *info;
@ -581,10 +691,13 @@ static int sm5022_muic_i2c_probe(struct i2c_client *i2c,
info->dev = &i2c->dev;
info->i2c = i2c;
info->irq = i2c->irq;
info->muic_irqs = sm5502_muic_irqs;
info->num_muic_irqs = ARRAY_SIZE(sm5502_muic_irqs);
info->reg_data = sm5502_reg_data;
info->num_reg_data = ARRAY_SIZE(sm5502_reg_data);
info->type = device_get_match_data(info->dev);
if (!info->type)
return -EINVAL;
if (!info->type->parse_irq) {
dev_err(info->dev, "parse_irq missing in struct sm5502_type\n");
return -EINVAL;
}
mutex_init(&info->mutex);
@ -600,16 +713,17 @@ static int sm5022_muic_i2c_probe(struct i2c_client *i2c,
/* Support irq domain for SM5502 MUIC device */
irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED;
ret = regmap_add_irq_chip(info->regmap, info->irq, irq_flags, 0,
&sm5502_muic_irq_chip, &info->irq_data);
ret = devm_regmap_add_irq_chip(info->dev, info->regmap, info->irq,
irq_flags, 0, info->type->irq_chip,
&info->irq_data);
if (ret != 0) {
dev_err(info->dev, "failed to request IRQ %d: %d\n",
info->irq, ret);
return ret;
}
for (i = 0; i < info->num_muic_irqs; i++) {
struct muic_irq *muic_irq = &info->muic_irqs[i];
for (i = 0; i < info->type->num_muic_irqs; i++) {
struct muic_irq *muic_irq = &info->type->muic_irqs[i];
int virq = 0;
virq = regmap_irq_get_virq(info->irq_data, muic_irq->irq);
@ -661,17 +775,29 @@ static int sm5022_muic_i2c_probe(struct i2c_client *i2c,
return 0;
}
static int sm5502_muic_i2c_remove(struct i2c_client *i2c)
{
struct sm5502_muic_info *info = i2c_get_clientdata(i2c);
static const struct sm5502_type sm5502_data = {
.muic_irqs = sm5502_muic_irqs,
.num_muic_irqs = ARRAY_SIZE(sm5502_muic_irqs),
.irq_chip = &sm5502_muic_irq_chip,
.reg_data = sm5502_reg_data,
.num_reg_data = ARRAY_SIZE(sm5502_reg_data),
.otg_dev_type1 = SM5502_REG_DEV_TYPE1_USB_OTG_MASK,
.parse_irq = sm5502_parse_irq,
};
regmap_del_irq_chip(info->irq, info->irq_data);
return 0;
}
static const struct sm5502_type sm5504_data = {
.muic_irqs = sm5504_muic_irqs,
.num_muic_irqs = ARRAY_SIZE(sm5504_muic_irqs),
.irq_chip = &sm5504_muic_irq_chip,
.reg_data = sm5504_reg_data,
.num_reg_data = ARRAY_SIZE(sm5504_reg_data),
.otg_dev_type1 = SM5504_REG_DEV_TYPE1_USB_OTG_MASK,
.parse_irq = sm5504_parse_irq,
};
static const struct of_device_id sm5502_dt_match[] = {
{ .compatible = "siliconmitus,sm5502-muic" },
{ .compatible = "siliconmitus,sm5502-muic", .data = &sm5502_data },
{ .compatible = "siliconmitus,sm5504-muic", .data = &sm5504_data },
{ },
};
MODULE_DEVICE_TABLE(of, sm5502_dt_match);
@ -702,7 +828,8 @@ static SIMPLE_DEV_PM_OPS(sm5502_muic_pm_ops,
sm5502_muic_suspend, sm5502_muic_resume);
static const struct i2c_device_id sm5502_i2c_id[] = {
{ "sm5502", TYPE_SM5502 },
{ "sm5502", (kernel_ulong_t)&sm5502_data },
{ "sm5504", (kernel_ulong_t)&sm5504_data },
{ }
};
MODULE_DEVICE_TABLE(i2c, sm5502_i2c_id);
@ -713,8 +840,7 @@ static struct i2c_driver sm5502_muic_i2c_driver = {
.pm = &sm5502_muic_pm_ops,
.of_match_table = sm5502_dt_match,
},
.probe = sm5022_muic_i2c_probe,
.remove = sm5502_muic_i2c_remove,
.probe_new = sm5022_muic_i2c_probe,
.id_table = sm5502_i2c_id,
};

82
drivers/extcon/extcon-sm5502.h
View File

@ -8,10 +8,6 @@
#ifndef __LINUX_EXTCON_SM5502_H
#define __LINUX_EXTCON_SM5502_H
enum sm5502_types {
TYPE_SM5502,
};
/* SM5502 registers */
enum sm5502_reg {
SM5502_REG_DEVICE_ID = 0x01,
@ -93,6 +89,13 @@ enum sm5502_reg {
#define SM5502_REG_CONTROL_RAW_DATA_MASK (0x1 << SM5502_REG_CONTROL_RAW_DATA_SHIFT)
#define SM5502_REG_CONTROL_SW_OPEN_MASK (0x1 << SM5502_REG_CONTROL_SW_OPEN_SHIFT)
#define SM5504_REG_CONTROL_CHGTYP_SHIFT 5
#define SM5504_REG_CONTROL_USBCHDEN_SHIFT 6
#define SM5504_REG_CONTROL_ADC_EN_SHIFT 7
#define SM5504_REG_CONTROL_CHGTYP_MASK (0x1 << SM5504_REG_CONTROL_CHGTYP_SHIFT)
#define SM5504_REG_CONTROL_USBCHDEN_MASK (0x1 << SM5504_REG_CONTROL_USBCHDEN_SHIFT)
#define SM5504_REG_CONTROL_ADC_EN_MASK (0x1 << SM5504_REG_CONTROL_ADC_EN_SHIFT)
#define SM5502_REG_INTM1_ATTACH_SHIFT 0
#define SM5502_REG_INTM1_DETACH_SHIFT 1
#define SM5502_REG_INTM1_KP_SHIFT 2
@ -123,6 +126,36 @@ enum sm5502_reg {
#define SM5502_REG_INTM2_STUCK_KEY_RCV_MASK (0x1 << SM5502_REG_INTM2_STUCK_KEY_RCV_SHIFT)
#define SM5502_REG_INTM2_MHL_MASK (0x1 << SM5502_REG_INTM2_MHL_SHIFT)
#define SM5504_REG_INTM1_ATTACH_SHIFT 0
#define SM5504_REG_INTM1_DETACH_SHIFT 1
#define SM5504_REG_INTM1_CHG_DET_SHIFT 2
#define SM5504_REG_INTM1_DCD_OUT_SHIFT 3
#define SM5504_REG_INTM1_OVP_EVENT_SHIFT 4
#define SM5504_REG_INTM1_CONNECT_SHIFT 5
#define SM5504_REG_INTM1_ADC_CHG_SHIFT 6
#define SM5504_REG_INTM1_ATTACH_MASK (0x1 << SM5504_REG_INTM1_ATTACH_SHIFT)
#define SM5504_REG_INTM1_DETACH_MASK (0x1 << SM5504_REG_INTM1_DETACH_SHIFT)
#define SM5504_REG_INTM1_CHG_DET_MASK (0x1 << SM5504_REG_INTM1_CHG_DET_SHIFT)
#define SM5504_REG_INTM1_DCD_OUT_MASK (0x1 << SM5504_REG_INTM1_DCD_OUT_SHIFT)
#define SM5504_REG_INTM1_OVP_EVENT_MASK (0x1 << SM5504_REG_INTM1_OVP_EVENT_SHIFT)
#define SM5504_REG_INTM1_CONNECT_MASK (0x1 << SM5504_REG_INTM1_CONNECT_SHIFT)
#define SM5504_REG_INTM1_ADC_CHG_MASK (0x1 << SM5504_REG_INTM1_ADC_CHG_SHIFT)
#define SM5504_REG_INTM2_RID_CHG_SHIFT 0
#define SM5504_REG_INTM2_UVLO_SHIFT 1
#define SM5504_REG_INTM2_POR_SHIFT 2
#define SM5504_REG_INTM2_OVP_FET_SHIFT 4
#define SM5504_REG_INTM2_OCP_LATCH_SHIFT 5
#define SM5504_REG_INTM2_OCP_EVENT_SHIFT 6
#define SM5504_REG_INTM2_OVP_OCP_EVENT_SHIFT 7
#define SM5504_REG_INTM2_RID_CHG_MASK (0x1 << SM5504_REG_INTM2_RID_CHG_SHIFT)
#define SM5504_REG_INTM2_UVLO_MASK (0x1 << SM5504_REG_INTM2_UVLO_SHIFT)
#define SM5504_REG_INTM2_POR_MASK (0x1 << SM5504_REG_INTM2_POR_SHIFT)
#define SM5504_REG_INTM2_OVP_FET_MASK (0x1 << SM5504_REG_INTM2_OVP_FET_SHIFT)
#define SM5504_REG_INTM2_OCP_LATCH_MASK (0x1 << SM5504_REG_INTM2_OCP_LATCH_SHIFT)
#define SM5504_REG_INTM2_OCP_EVENT_MASK (0x1 << SM5504_REG_INTM2_OCP_EVENT_SHIFT)
#define SM5504_REG_INTM2_OVP_OCP_EVENT_MASK (0x1 << SM5504_REG_INTM2_OVP_OCP_EVENT_SHIFT)
#define SM5502_REG_ADC_SHIFT 0
#define SM5502_REG_ADC_MASK (0x1f << SM5502_REG_ADC_SHIFT)
@ -199,6 +232,9 @@ enum sm5502_reg {
#define SM5502_REG_DEV_TYPE1_DEDICATED_CHG_MASK (0x1 << SM5502_REG_DEV_TYPE1_DEDICATED_CHG_SHIFT)
#define SM5502_REG_DEV_TYPE1_USB_OTG_MASK (0x1 << SM5502_REG_DEV_TYPE1_USB_OTG_SHIFT)
#define SM5504_REG_DEV_TYPE1_USB_OTG_SHIFT 0
#define SM5504_REG_DEV_TYPE1_USB_OTG_MASK (0x1 << SM5504_REG_DEV_TYPE1_USB_OTG_SHIFT)
#define SM5502_REG_DEV_TYPE2_JIG_USB_ON_SHIFT 0
#define SM5502_REG_DEV_TYPE2_JIG_USB_OFF_SHIFT 1
#define SM5502_REG_DEV_TYPE2_JIG_UART_ON_SHIFT 2
@ -277,4 +313,42 @@ enum sm5502_irq {
#define SM5502_IRQ_INT2_STUCK_KEY_RCV_MASK BIT(4)
#define SM5502_IRQ_INT2_MHL_MASK BIT(5)
/* SM5504 Interrupts */
enum sm5504_irq {
/* INT1 */
SM5504_IRQ_INT1_ATTACH,
SM5504_IRQ_INT1_DETACH,
SM5504_IRQ_INT1_CHG_DET,
SM5504_IRQ_INT1_DCD_OUT,
SM5504_IRQ_INT1_OVP_EVENT,
SM5504_IRQ_INT1_CONNECT,
SM5504_IRQ_INT1_ADC_CHG,
/* INT2 */
SM5504_IRQ_INT2_RID_CHG,
SM5504_IRQ_INT2_UVLO,
SM5504_IRQ_INT2_POR,
SM5504_IRQ_INT2_OVP_FET,
SM5504_IRQ_INT2_OCP_LATCH,
SM5504_IRQ_INT2_OCP_EVENT,
SM5504_IRQ_INT2_OVP_OCP_EVENT,
SM5504_IRQ_NUM,
};
#define SM5504_IRQ_INT1_ATTACH_MASK BIT(0)
#define SM5504_IRQ_INT1_DETACH_MASK BIT(1)
#define SM5504_IRQ_INT1_CHG_DET_MASK BIT(2)
#define SM5504_IRQ_INT1_DCD_OUT_MASK BIT(3)
#define SM5504_IRQ_INT1_OVP_MASK BIT(4)
#define SM5504_IRQ_INT1_CONNECT_MASK BIT(5)
#define SM5504_IRQ_INT1_ADC_CHG_MASK BIT(6)
#define SM5504_IRQ_INT2_RID_CHG_MASK BIT(0)
#define SM5504_IRQ_INT2_UVLO_MASK BIT(1)
#define SM5504_IRQ_INT2_POR_MASK BIT(2)
#define SM5504_IRQ_INT2_OVP_FET_MASK BIT(4)
#define SM5504_IRQ_INT2_OCP_LATCH_MASK BIT(5)
#define SM5504_IRQ_INT2_OCP_EVENT_MASK BIT(6)
#define SM5504_IRQ_INT2_OVP_OCP_EVENT_MASK BIT(7)
#endif /* __LINUX_EXTCON_SM5502_H */