mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-10-31 08:38:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
linux/drivers/extcon/extcon-max14526.c
Randy Dunlap 67c74613f2 extcon: max14526: avoid defined but not used warning 
SIMPLE_PM_DEV_OPS() is deprecated according to <linux/pm.h>.
Use DEFINE_SIMPLE_PM_DEV_OPS() instead. This avoids a build warning
when CONFIG_PM is not enabled:

drivers/extcon/extcon-max14526.c:265:12: warning: ‘max14526_resume’ defined but not used [-Wunused-function]
  265 | static int max14526_resume(struct device *dev)

Fixes: 145af3ddd1 ("extcon: Add basic support for Maxim MAX14526 MUIC")
Signed-off-by: Randy Dunlap <rdunlap@infradead.org>
Link: https://lore.kernel.org/lkml/20250513210252.1139749-1-rdunlap@infradead.org/
Signed-off-by: Chanwoo Choi <cw00.choi@samsung.com>
2025-09-08 15:12:54 +09:00

302 lines
7.3 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/device.h>
#include <linux/devm-helpers.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/extcon-provider.h>
#include <linux/i2c.h>
#include <linux/mod_devicetable.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/pm.h>
#include <linux/regmap.h>
/* I2C addresses of MUIC internal registers */
#define MAX14526_DEVICE_ID 0x00
#define MAX14526_ID 0x02
/* CONTROL_1 register masks */
#define MAX14526_CONTROL_1 0x01
#define ID_2P2 BIT(6)
#define ID_620 BIT(5)
#define ID_200 BIT(4)
#define VLDO BIT(3)
#define SEMREN BIT(2)
#define ADC_EN BIT(1)
#define CP_EN BIT(0)
/* CONTROL_2 register masks */
#define MAX14526_CONTROL_2 0x02
#define INTPOL BIT(7)
#define INT_EN BIT(6)
#define MIC_LP BIT(5)
#define CP_AUD BIT(4)
#define CHG_TYPE BIT(1)
#define USB_DET_DIS BIT(0)
/* SW_CONTROL register masks */
#define MAX14526_SW_CONTROL 0x03
#define SW_DATA 0x00
#define SW_UART 0x01
#define SW_AUDIO 0x02
#define SW_OPEN 0x07
/* INT_STATUS register masks */
#define MAX14526_INT_STAT 0x04
#define CHGDET BIT(7)
#define MR_COMP BIT(6)
#define SENDEND BIT(5)
#define V_VBUS BIT(4)
/* STATUS register masks */
#define MAX14526_STATUS 0x05
#define CPORT BIT(7)
#define CHPORT BIT(6)
#define C1COMP BIT(0)
enum max14526_idno_resistance {
MAX14526_GND,
MAX14526_24KOHM,
MAX14526_56KOHM,
MAX14526_100KOHM,
MAX14526_130KOHM,
MAX14526_180KOHM,
MAX14526_240KOHM,
MAX14526_330KOHM,
MAX14526_430KOHM,
MAX14526_620KOHM,
MAX14526_910KOHM,
MAX14526_OPEN
};
enum max14526_field_idx {
VENDOR_ID, CHIP_REV, /* DEVID */
DM, DP, /* SW_CONTROL */
MAX14526_N_REGMAP_FIELDS
};
static const struct reg_field max14526_reg_field[MAX14526_N_REGMAP_FIELDS] = {
[VENDOR_ID] = REG_FIELD(MAX14526_DEVICE_ID, 4, 7),
[CHIP_REV] = REG_FIELD(MAX14526_DEVICE_ID, 0, 3),
[DM] = REG_FIELD(MAX14526_SW_CONTROL, 0, 2),
[DP] = REG_FIELD(MAX14526_SW_CONTROL, 3, 5),
};
struct max14526_data {
struct i2c_client *client;
struct extcon_dev *edev;
struct regmap *regmap;
struct regmap_field *rfield[MAX14526_N_REGMAP_FIELDS];
int last_state;
int cable;
};
enum max14526_muic_modes {
MAX14526_OTG = MAX14526_GND, /* no power */
MAX14526_MHL = MAX14526_56KOHM, /* no power */
MAX14526_OTG_Y = MAX14526_GND | V_VBUS,
MAX14526_MHL_CHG = MAX14526_GND | V_VBUS | CHGDET,
MAX14526_NONE = MAX14526_OPEN,
MAX14526_USB = MAX14526_OPEN | V_VBUS,
MAX14526_CHG = MAX14526_OPEN | V_VBUS | CHGDET,
};
static const unsigned int max14526_extcon_cable[] = {
EXTCON_USB,
EXTCON_USB_HOST,
EXTCON_CHG_USB_FAST,
EXTCON_DISP_MHL,
EXTCON_NONE,
};
static int max14526_ap_usb_mode(struct max14526_data *priv)
{
struct device *dev = &priv->client->dev;
int ret;
/* Enable USB Path */
ret = regmap_field_write(priv->rfield[DM], SW_DATA);
if (ret)
return ret;
ret = regmap_field_write(priv->rfield[DP], SW_DATA);
if (ret)
return ret;
/* Enable 200K, Charger Pump and ADC */
ret = regmap_write(priv->regmap, MAX14526_CONTROL_1,
ID_200 | ADC_EN | CP_EN);
if (ret)
return ret;
dev_dbg(dev, "AP USB mode set\n");
return 0;
}
static irqreturn_t max14526_interrupt(int irq, void *dev_id)
{
struct max14526_data *priv = dev_id;
struct device *dev = &priv->client->dev;
int state, ret;
/*
* Upon an MUIC IRQ (MUIC_INT_N falls), wait at least 70ms
* before reading INT_STAT and STATUS. After the reads,
* MUIC_INT_N returns to high (but the INT_STAT and STATUS
* contents will be held).
*/
msleep(100);
ret = regmap_read(priv->regmap, MAX14526_INT_STAT, &state);
if (ret)
dev_err(dev, "failed to read MUIC state %d\n", ret);
if (state == priv->last_state)
return IRQ_HANDLED;
/* Detach previous device */
extcon_set_state_sync(priv->edev, priv->cable, false);
switch (state) {
case MAX14526_USB:
priv->cable = EXTCON_USB;
break;
case MAX14526_CHG:
priv->cable = EXTCON_CHG_USB_FAST;
break;
case MAX14526_OTG:
case MAX14526_OTG_Y:
priv->cable = EXTCON_USB_HOST;
break;
case MAX14526_MHL:
case MAX14526_MHL_CHG:
priv->cable = EXTCON_DISP_MHL;
break;
case MAX14526_NONE:
default:
priv->cable = EXTCON_NONE;
break;
}
extcon_set_state_sync(priv->edev, priv->cable, true);
priv->last_state = state;
return IRQ_HANDLED;
}
static const struct regmap_config max14526_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = MAX14526_STATUS,
};
static int max14526_probe(struct i2c_client *client)
{
struct device *dev = &client->dev;
struct max14526_data *priv;
int ret, dev_id, rev, i;
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->client = client;
i2c_set_clientdata(client, priv);
priv->regmap = devm_regmap_init_i2c(client, &max14526_regmap_config);
if (IS_ERR(priv->regmap))
return dev_err_probe(dev, PTR_ERR(priv->regmap), "cannot allocate regmap\n");
for (i = 0; i < MAX14526_N_REGMAP_FIELDS; i++) {
priv->rfield[i] = devm_regmap_field_alloc(dev, priv->regmap,
max14526_reg_field[i]);
if (IS_ERR(priv->rfield[i]))
return dev_err_probe(dev, PTR_ERR(priv->rfield[i]),
"cannot allocate regmap field\n");
}
/* Detect if MUIC version is supported */
ret = regmap_field_read(priv->rfield[VENDOR_ID], &dev_id);
if (ret)
return dev_err_probe(dev, ret, "failed to read MUIC ID\n");
regmap_field_read(priv->rfield[CHIP_REV], &rev);
if (dev_id == MAX14526_ID)
dev_info(dev, "detected MAX14526 MUIC with id 0x%x, rev 0x%x\n", dev_id, rev);
else
dev_err_probe(dev, -EINVAL, "MUIC vendor id 0x%X is not recognized\n", dev_id);
priv->edev = devm_extcon_dev_allocate(dev, max14526_extcon_cable);
if (IS_ERR(priv->edev))
return dev_err_probe(dev, (IS_ERR(priv->edev)),
"failed to allocate extcon device\n");
ret = devm_extcon_dev_register(dev, priv->edev);
if (ret < 0)
return dev_err_probe(dev, ret, "failed to register extcon device\n");
ret = max14526_ap_usb_mode(priv);
if (ret < 0)
return dev_err_probe(dev, ret, "failed to set AP USB mode\n");
regmap_write_bits(priv->regmap, MAX14526_CONTROL_2, INT_EN, INT_EN);
regmap_write_bits(priv->regmap, MAX14526_CONTROL_2, USB_DET_DIS, (u32)~USB_DET_DIS);
ret = devm_request_threaded_irq(dev, client->irq, NULL, &max14526_interrupt,
IRQF_ONESHOT | IRQF_SHARED, client->name, priv);
if (ret)
return dev_err_probe(dev, ret, "failed to register IRQ\n");
irq_wake_thread(client->irq, priv);
return 0;
}
static int max14526_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct max14526_data *priv = i2c_get_clientdata(client);
irq_wake_thread(client->irq, priv);
return 0;
}
static DEFINE_SIMPLE_DEV_PM_OPS(max14526_pm_ops, NULL, max14526_resume);
static const struct of_device_id max14526_match[] = {
{ .compatible = "maxim,max14526" },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, max14526_match);
static const struct i2c_device_id max14526_id[] = {
{ "max14526" },
{ }
};
MODULE_DEVICE_TABLE(i2c, max14526_id);
static struct i2c_driver max14526_driver = {
.driver = {
.name = "max14526",
.of_match_table = max14526_match,
.pm = &max14526_pm_ops,
},
.probe = max14526_probe,
.id_table = max14526_id,
};
module_i2c_driver(max14526_driver);
MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>");
MODULE_DESCRIPTION("MAX14526 extcon driver to support MUIC");
MODULE_LICENSE("GPL");
Reference in a new issue View git blame Copy permalink