1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * extcon-rt8973a.c - Richtek RT8973A extcon driver to support USB switches 4 * 5 * Copyright (c) 2014 Samsung Electronics Co., Ltd 6 * Author: Chanwoo Choi <cw00.choi@samsung.com> 7 */ 8 9 #include <linux/err.h> 10 #include <linux/i2c.h> 11 #include <linux/input.h> 12 #include <linux/interrupt.h> 13 #include <linux/irqdomain.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/platform_device.h> 17 #include <linux/regmap.h> 18 #include <linux/slab.h> 19 #include <linux/extcon-provider.h> 20 21 #include "extcon-rt8973a.h" 22 23 #define DELAY_MS_DEFAULT 20000 /* unit: millisecond */ 24 25 struct muic_irq { 26 unsigned int irq; 27 const char *name; 28 unsigned int virq; 29 }; 30 31 struct reg_data { 32 u8 reg; 33 u8 mask; 34 u8 val; 35 bool invert; 36 }; 37 38 struct rt8973a_muic_info { 39 struct device *dev; 40 struct extcon_dev *edev; 41 42 struct i2c_client *i2c; 43 struct regmap *regmap; 44 45 struct regmap_irq_chip_data *irq_data; 46 struct muic_irq *muic_irqs; 47 unsigned int num_muic_irqs; 48 int irq; 49 bool irq_attach; 50 bool irq_detach; 51 bool irq_ovp; 52 bool irq_otp; 53 struct work_struct irq_work; 54 55 struct reg_data *reg_data; 56 unsigned int num_reg_data; 57 bool auto_config; 58 59 struct mutex mutex; 60 61 /* 62 * Use delayed workqueue to detect cable state and then 63 * notify cable state to notifiee/platform through uevent. 64 * After completing the booting of platform, the extcon provider 65 * driver should notify cable state to upper layer. 66 */ 67 struct delayed_work wq_detcable; 68 }; 69 70 /* Default value of RT8973A register to bring up MUIC device. */ 71 static struct reg_data rt8973a_reg_data[] = { 72 { 73 .reg = RT8973A_REG_CONTROL1, 74 .mask = RT8973A_REG_CONTROL1_ADC_EN_MASK 75 | RT8973A_REG_CONTROL1_USB_CHD_EN_MASK 76 | RT8973A_REG_CONTROL1_CHGTYP_MASK 77 | RT8973A_REG_CONTROL1_SWITCH_OPEN_MASK 78 | RT8973A_REG_CONTROL1_AUTO_CONFIG_MASK 79 | RT8973A_REG_CONTROL1_INTM_MASK, 80 .val = RT8973A_REG_CONTROL1_ADC_EN_MASK 81 | RT8973A_REG_CONTROL1_USB_CHD_EN_MASK 82 | RT8973A_REG_CONTROL1_CHGTYP_MASK, 83 .invert = false, 84 }, 85 { /* sentinel */ } 86 }; 87 88 /* List of detectable cables */ 89 static const unsigned int rt8973a_extcon_cable[] = { 90 EXTCON_USB, 91 EXTCON_USB_HOST, 92 EXTCON_CHG_USB_SDP, 93 EXTCON_CHG_USB_DCP, 94 EXTCON_JIG, 95 EXTCON_NONE, 96 }; 97 98 /* Define OVP (Over Voltage Protection), OTP (Over Temperature Protection) */ 99 enum rt8973a_event_type { 100 RT8973A_EVENT_ATTACH = 1, 101 RT8973A_EVENT_DETACH, 102 RT8973A_EVENT_OVP, 103 RT8973A_EVENT_OTP, 104 }; 105 106 /* Define supported accessory type */ 107 enum rt8973a_muic_acc_type { 108 RT8973A_MUIC_ADC_OTG = 0x0, 109 RT8973A_MUIC_ADC_AUDIO_SEND_END_BUTTON, 110 RT8973A_MUIC_ADC_AUDIO_REMOTE_S1_BUTTON, 111 RT8973A_MUIC_ADC_AUDIO_REMOTE_S2_BUTTON, 112 RT8973A_MUIC_ADC_AUDIO_REMOTE_S3_BUTTON, 113 RT8973A_MUIC_ADC_AUDIO_REMOTE_S4_BUTTON, 114 RT8973A_MUIC_ADC_AUDIO_REMOTE_S5_BUTTON, 115 RT8973A_MUIC_ADC_AUDIO_REMOTE_S6_BUTTON, 116 RT8973A_MUIC_ADC_AUDIO_REMOTE_S7_BUTTON, 117 RT8973A_MUIC_ADC_AUDIO_REMOTE_S8_BUTTON, 118 RT8973A_MUIC_ADC_AUDIO_REMOTE_S9_BUTTON, 119 RT8973A_MUIC_ADC_AUDIO_REMOTE_S10_BUTTON, 120 RT8973A_MUIC_ADC_AUDIO_REMOTE_S11_BUTTON, 121 RT8973A_MUIC_ADC_AUDIO_REMOTE_S12_BUTTON, 122 RT8973A_MUIC_ADC_RESERVED_ACC_1, 123 RT8973A_MUIC_ADC_RESERVED_ACC_2, 124 RT8973A_MUIC_ADC_RESERVED_ACC_3, 125 RT8973A_MUIC_ADC_RESERVED_ACC_4, 126 RT8973A_MUIC_ADC_RESERVED_ACC_5, 127 RT8973A_MUIC_ADC_AUDIO_TYPE2, 128 RT8973A_MUIC_ADC_PHONE_POWERED_DEV, 129 RT8973A_MUIC_ADC_UNKNOWN_ACC_1, 130 RT8973A_MUIC_ADC_UNKNOWN_ACC_2, 131 RT8973A_MUIC_ADC_TA, 132 RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_OFF_USB, 133 RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_ON_USB, 134 RT8973A_MUIC_ADC_UNKNOWN_ACC_3, 135 RT8973A_MUIC_ADC_UNKNOWN_ACC_4, 136 RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_OFF_UART, 137 RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_ON_UART, 138 RT8973A_MUIC_ADC_UNKNOWN_ACC_5, 139 RT8973A_MUIC_ADC_OPEN = 0x1f, 140 141 /* 142 * The below accessories has same ADC value (0x1f). 143 * So, Device type1 is used to separate specific accessory. 144 */ 145 /* |---------|--ADC| */ 146 /* | [7:5]|[4:0]| */ 147 RT8973A_MUIC_ADC_USB = 0x3f, /* | 001|11111| */ 148 }; 149 150 /* List of supported interrupt for RT8973A */ 151 static struct muic_irq rt8973a_muic_irqs[] = { 152 { RT8973A_INT1_ATTACH, "muic-attach" }, 153 { RT8973A_INT1_DETACH, "muic-detach" }, 154 { RT8973A_INT1_CHGDET, "muic-chgdet" }, 155 { RT8973A_INT1_DCD_T, "muic-dcd-t" }, 156 { RT8973A_INT1_OVP, "muic-ovp" }, 157 { RT8973A_INT1_CONNECT, "muic-connect" }, 158 { RT8973A_INT1_ADC_CHG, "muic-adc-chg" }, 159 { RT8973A_INT1_OTP, "muic-otp" }, 160 { RT8973A_INT2_UVLO, "muic-uvlo" }, 161 { RT8973A_INT2_POR, "muic-por" }, 162 { RT8973A_INT2_OTP_FET, "muic-otp-fet" }, 163 { RT8973A_INT2_OVP_FET, "muic-ovp-fet" }, 164 { RT8973A_INT2_OCP_LATCH, "muic-ocp-latch" }, 165 { RT8973A_INT2_OCP, "muic-ocp" }, 166 { RT8973A_INT2_OVP_OCP, "muic-ovp-ocp" }, 167 }; 168 169 /* Define interrupt list of RT8973A to register regmap_irq */ 170 static const struct regmap_irq rt8973a_irqs[] = { 171 /* INT1 interrupts */ 172 { .reg_offset = 0, .mask = RT8973A_INT1_ATTACH_MASK, }, 173 { .reg_offset = 0, .mask = RT8973A_INT1_DETACH_MASK, }, 174 { .reg_offset = 0, .mask = RT8973A_INT1_CHGDET_MASK, }, 175 { .reg_offset = 0, .mask = RT8973A_INT1_DCD_T_MASK, }, 176 { .reg_offset = 0, .mask = RT8973A_INT1_OVP_MASK, }, 177 { .reg_offset = 0, .mask = RT8973A_INT1_CONNECT_MASK, }, 178 { .reg_offset = 0, .mask = RT8973A_INT1_ADC_CHG_MASK, }, 179 { .reg_offset = 0, .mask = RT8973A_INT1_OTP_MASK, }, 180 181 /* INT2 interrupts */ 182 { .reg_offset = 1, .mask = RT8973A_INT2_UVLOT_MASK,}, 183 { .reg_offset = 1, .mask = RT8973A_INT2_POR_MASK, }, 184 { .reg_offset = 1, .mask = RT8973A_INT2_OTP_FET_MASK, }, 185 { .reg_offset = 1, .mask = RT8973A_INT2_OVP_FET_MASK, }, 186 { .reg_offset = 1, .mask = RT8973A_INT2_OCP_LATCH_MASK, }, 187 { .reg_offset = 1, .mask = RT8973A_INT2_OCP_MASK, }, 188 { .reg_offset = 1, .mask = RT8973A_INT2_OVP_OCP_MASK, }, 189 }; 190 191 static const struct regmap_irq_chip rt8973a_muic_irq_chip = { 192 .name = "rt8973a", 193 .status_base = RT8973A_REG_INT1, 194 .mask_base = RT8973A_REG_INTM1, 195 .mask_invert = false, 196 .num_regs = 2, 197 .irqs = rt8973a_irqs, 198 .num_irqs = ARRAY_SIZE(rt8973a_irqs), 199 }; 200 201 /* Define regmap configuration of RT8973A for I2C communication */ 202 static bool rt8973a_muic_volatile_reg(struct device *dev, unsigned int reg) 203 { 204 switch (reg) { 205 case RT8973A_REG_INTM1: 206 case RT8973A_REG_INTM2: 207 return true; 208 default: 209 break; 210 } 211 return false; 212 } 213 214 static const struct regmap_config rt8973a_muic_regmap_config = { 215 .reg_bits = 8, 216 .val_bits = 8, 217 .volatile_reg = rt8973a_muic_volatile_reg, 218 .max_register = RT8973A_REG_END, 219 }; 220 221 /* Change DM_CON/DP_CON/VBUSIN switch according to cable type */ 222 static int rt8973a_muic_set_path(struct rt8973a_muic_info *info, 223 unsigned int con_sw, bool attached) 224 { 225 int ret; 226 227 /* 228 * Don't need to set h/w path according to cable type 229 * if Auto-configuration mode of CONTROL1 register is true. 230 */ 231 if (info->auto_config) 232 return 0; 233 234 if (!attached) 235 con_sw = DM_DP_SWITCH_UART; 236 237 switch (con_sw) { 238 case DM_DP_SWITCH_OPEN: 239 case DM_DP_SWITCH_USB: 240 case DM_DP_SWITCH_UART: 241 ret = regmap_update_bits(info->regmap, RT8973A_REG_MANUAL_SW1, 242 RT8973A_REG_MANUAL_SW1_DP_MASK | 243 RT8973A_REG_MANUAL_SW1_DM_MASK, 244 con_sw); 245 if (ret < 0) { 246 dev_err(info->dev, 247 "cannot update DM_CON/DP_CON switch\n"); 248 return ret; 249 } 250 break; 251 default: 252 dev_err(info->dev, "Unknown DM_CON/DP_CON switch type (%d)\n", 253 con_sw); 254 return -EINVAL; 255 } 256 257 return 0; 258 } 259 260 static int rt8973a_muic_get_cable_type(struct rt8973a_muic_info *info) 261 { 262 unsigned int adc, dev1; 263 int ret, cable_type; 264 265 /* Read ADC value according to external cable or button */ 266 ret = regmap_read(info->regmap, RT8973A_REG_ADC, &adc); 267 if (ret) { 268 dev_err(info->dev, "failed to read ADC register\n"); 269 return ret; 270 } 271 cable_type = adc & RT8973A_REG_ADC_MASK; 272 273 /* Read Device 1 reigster to identify correct cable type */ 274 ret = regmap_read(info->regmap, RT8973A_REG_DEV1, &dev1); 275 if (ret) { 276 dev_err(info->dev, "failed to read DEV1 register\n"); 277 return ret; 278 } 279 280 switch (adc) { 281 case RT8973A_MUIC_ADC_OPEN: 282 if (dev1 & RT8973A_REG_DEV1_USB_MASK) 283 cable_type = RT8973A_MUIC_ADC_USB; 284 else if (dev1 & RT8973A_REG_DEV1_DCPORT_MASK) 285 cable_type = RT8973A_MUIC_ADC_TA; 286 else 287 cable_type = RT8973A_MUIC_ADC_OPEN; 288 break; 289 default: 290 break; 291 } 292 293 return cable_type; 294 } 295 296 static int rt8973a_muic_cable_handler(struct rt8973a_muic_info *info, 297 enum rt8973a_event_type event) 298 { 299 static unsigned int prev_cable_type; 300 unsigned int con_sw = DM_DP_SWITCH_UART; 301 int ret, cable_type; 302 unsigned int id; 303 bool attached = false; 304 305 switch (event) { 306 case RT8973A_EVENT_ATTACH: 307 cable_type = rt8973a_muic_get_cable_type(info); 308 attached = true; 309 break; 310 case RT8973A_EVENT_DETACH: 311 cable_type = prev_cable_type; 312 attached = false; 313 break; 314 case RT8973A_EVENT_OVP: 315 case RT8973A_EVENT_OTP: 316 dev_warn(info->dev, 317 "happen Over %s issue. Need to disconnect all cables\n", 318 event == RT8973A_EVENT_OVP ? "Voltage" : "Temperature"); 319 cable_type = prev_cable_type; 320 attached = false; 321 break; 322 default: 323 dev_err(info->dev, 324 "Cannot handle this event (event:%d)\n", event); 325 return -EINVAL; 326 } 327 prev_cable_type = cable_type; 328 329 switch (cable_type) { 330 case RT8973A_MUIC_ADC_OTG: 331 id = EXTCON_USB_HOST; 332 con_sw = DM_DP_SWITCH_USB; 333 break; 334 case RT8973A_MUIC_ADC_TA: 335 id = EXTCON_CHG_USB_DCP; 336 con_sw = DM_DP_SWITCH_OPEN; 337 break; 338 case RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_OFF_USB: 339 case RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_ON_USB: 340 id = EXTCON_JIG; 341 con_sw = DM_DP_SWITCH_USB; 342 break; 343 case RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_OFF_UART: 344 case RT8973A_MUIC_ADC_FACTORY_MODE_BOOT_ON_UART: 345 id = EXTCON_JIG; 346 con_sw = DM_DP_SWITCH_UART; 347 break; 348 case RT8973A_MUIC_ADC_USB: 349 id = EXTCON_USB; 350 con_sw = DM_DP_SWITCH_USB; 351 break; 352 case RT8973A_MUIC_ADC_OPEN: 353 return 0; 354 case RT8973A_MUIC_ADC_UNKNOWN_ACC_1: 355 case RT8973A_MUIC_ADC_UNKNOWN_ACC_2: 356 case RT8973A_MUIC_ADC_UNKNOWN_ACC_3: 357 case RT8973A_MUIC_ADC_UNKNOWN_ACC_4: 358 case RT8973A_MUIC_ADC_UNKNOWN_ACC_5: 359 dev_warn(info->dev, 360 "Unknown accessory type (adc:0x%x)\n", cable_type); 361 return 0; 362 case RT8973A_MUIC_ADC_AUDIO_SEND_END_BUTTON: 363 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S1_BUTTON: 364 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S2_BUTTON: 365 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S3_BUTTON: 366 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S4_BUTTON: 367 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S5_BUTTON: 368 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S6_BUTTON: 369 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S7_BUTTON: 370 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S8_BUTTON: 371 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S9_BUTTON: 372 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S10_BUTTON: 373 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S11_BUTTON: 374 case RT8973A_MUIC_ADC_AUDIO_REMOTE_S12_BUTTON: 375 case RT8973A_MUIC_ADC_AUDIO_TYPE2: 376 dev_warn(info->dev, 377 "Audio device/button type (adc:0x%x)\n", cable_type); 378 return 0; 379 case RT8973A_MUIC_ADC_RESERVED_ACC_1: 380 case RT8973A_MUIC_ADC_RESERVED_ACC_2: 381 case RT8973A_MUIC_ADC_RESERVED_ACC_3: 382 case RT8973A_MUIC_ADC_RESERVED_ACC_4: 383 case RT8973A_MUIC_ADC_RESERVED_ACC_5: 384 case RT8973A_MUIC_ADC_PHONE_POWERED_DEV: 385 return 0; 386 default: 387 dev_err(info->dev, 388 "Cannot handle this cable_type (adc:0x%x)\n", 389 cable_type); 390 return -EINVAL; 391 } 392 393 /* Change internal hardware path(DM_CON/DP_CON) */ 394 ret = rt8973a_muic_set_path(info, con_sw, attached); 395 if (ret < 0) 396 return ret; 397 398 /* Change the state of external accessory */ 399 extcon_set_state_sync(info->edev, id, attached); 400 if (id == EXTCON_USB) 401 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, 402 attached); 403 404 return 0; 405 } 406 407 static void rt8973a_muic_irq_work(struct work_struct *work) 408 { 409 struct rt8973a_muic_info *info = container_of(work, 410 struct rt8973a_muic_info, irq_work); 411 int ret = 0; 412 413 if (!info->edev) 414 return; 415 416 mutex_lock(&info->mutex); 417 418 /* Detect attached or detached cables */ 419 if (info->irq_attach) { 420 ret = rt8973a_muic_cable_handler(info, RT8973A_EVENT_ATTACH); 421 info->irq_attach = false; 422 } 423 424 if (info->irq_detach) { 425 ret = rt8973a_muic_cable_handler(info, RT8973A_EVENT_DETACH); 426 info->irq_detach = false; 427 } 428 429 if (info->irq_ovp) { 430 ret = rt8973a_muic_cable_handler(info, RT8973A_EVENT_OVP); 431 info->irq_ovp = false; 432 } 433 434 if (info->irq_otp) { 435 ret = rt8973a_muic_cable_handler(info, RT8973A_EVENT_OTP); 436 info->irq_otp = false; 437 } 438 439 if (ret < 0) 440 dev_err(info->dev, "failed to handle MUIC interrupt\n"); 441 442 mutex_unlock(&info->mutex); 443 } 444 445 static irqreturn_t rt8973a_muic_irq_handler(int irq, void *data) 446 { 447 struct rt8973a_muic_info *info = data; 448 int i, irq_type = -1; 449 450 for (i = 0; i < info->num_muic_irqs; i++) 451 if (irq == info->muic_irqs[i].virq) 452 irq_type = info->muic_irqs[i].irq; 453 454 switch (irq_type) { 455 case RT8973A_INT1_ATTACH: 456 info->irq_attach = true; 457 break; 458 case RT8973A_INT1_DETACH: 459 info->irq_detach = true; 460 break; 461 case RT8973A_INT1_OVP: 462 info->irq_ovp = true; 463 break; 464 case RT8973A_INT1_OTP: 465 info->irq_otp = true; 466 break; 467 case RT8973A_INT1_CHGDET: 468 case RT8973A_INT1_DCD_T: 469 case RT8973A_INT1_CONNECT: 470 case RT8973A_INT1_ADC_CHG: 471 case RT8973A_INT2_UVLO: 472 case RT8973A_INT2_POR: 473 case RT8973A_INT2_OTP_FET: 474 case RT8973A_INT2_OVP_FET: 475 case RT8973A_INT2_OCP_LATCH: 476 case RT8973A_INT2_OCP: 477 case RT8973A_INT2_OVP_OCP: 478 default: 479 dev_dbg(info->dev, 480 "Cannot handle this interrupt (%d)\n", irq_type); 481 break; 482 } 483 484 schedule_work(&info->irq_work); 485 486 return IRQ_HANDLED; 487 } 488 489 static void rt8973a_muic_detect_cable_wq(struct work_struct *work) 490 { 491 struct rt8973a_muic_info *info = container_of(to_delayed_work(work), 492 struct rt8973a_muic_info, wq_detcable); 493 int ret; 494 495 /* Notify the state of connector cable or not */ 496 ret = rt8973a_muic_cable_handler(info, RT8973A_EVENT_ATTACH); 497 if (ret < 0) 498 dev_warn(info->dev, "failed to detect cable state\n"); 499 } 500 501 static void rt8973a_init_dev_type(struct rt8973a_muic_info *info) 502 { 503 unsigned int data, vendor_id, version_id; 504 int i, ret; 505 506 /* To test I2C, Print version_id and vendor_id of RT8973A */ 507 ret = regmap_read(info->regmap, RT8973A_REG_DEVICE_ID, &data); 508 if (ret) { 509 dev_err(info->dev, 510 "failed to read DEVICE_ID register: %d\n", ret); 511 return; 512 } 513 514 vendor_id = ((data & RT8973A_REG_DEVICE_ID_VENDOR_MASK) >> 515 RT8973A_REG_DEVICE_ID_VENDOR_SHIFT); 516 version_id = ((data & RT8973A_REG_DEVICE_ID_VERSION_MASK) >> 517 RT8973A_REG_DEVICE_ID_VERSION_SHIFT); 518 519 dev_info(info->dev, "Device type: version: 0x%x, vendor: 0x%x\n", 520 version_id, vendor_id); 521 522 /* Initiazle the register of RT8973A device to bring-up */ 523 for (i = 0; i < info->num_reg_data; i++) { 524 u8 reg = info->reg_data[i].reg; 525 u8 mask = info->reg_data[i].mask; 526 u8 val = 0; 527 528 if (info->reg_data[i].invert) 529 val = ~info->reg_data[i].val; 530 else 531 val = info->reg_data[i].val; 532 533 regmap_update_bits(info->regmap, reg, mask, val); 534 } 535 536 /* Check whether RT8973A is auto switching mode or not */ 537 ret = regmap_read(info->regmap, RT8973A_REG_CONTROL1, &data); 538 if (ret) { 539 dev_err(info->dev, 540 "failed to read CONTROL1 register: %d\n", ret); 541 return; 542 } 543 544 data &= RT8973A_REG_CONTROL1_AUTO_CONFIG_MASK; 545 if (data) { 546 info->auto_config = true; 547 dev_info(info->dev, 548 "Enable Auto-configuration for internal path\n"); 549 } 550 } 551 552 static int rt8973a_muic_i2c_probe(struct i2c_client *i2c, 553 const struct i2c_device_id *id) 554 { 555 struct device_node *np = i2c->dev.of_node; 556 struct rt8973a_muic_info *info; 557 int i, ret, irq_flags; 558 559 if (!np) 560 return -EINVAL; 561 562 info = devm_kzalloc(&i2c->dev, sizeof(*info), GFP_KERNEL); 563 if (!info) 564 return -ENOMEM; 565 i2c_set_clientdata(i2c, info); 566 567 info->dev = &i2c->dev; 568 info->i2c = i2c; 569 info->irq = i2c->irq; 570 info->muic_irqs = rt8973a_muic_irqs; 571 info->num_muic_irqs = ARRAY_SIZE(rt8973a_muic_irqs); 572 info->reg_data = rt8973a_reg_data; 573 info->num_reg_data = ARRAY_SIZE(rt8973a_reg_data); 574 575 mutex_init(&info->mutex); 576 577 INIT_WORK(&info->irq_work, rt8973a_muic_irq_work); 578 579 info->regmap = devm_regmap_init_i2c(i2c, &rt8973a_muic_regmap_config); 580 if (IS_ERR(info->regmap)) { 581 ret = PTR_ERR(info->regmap); 582 dev_err(info->dev, "failed to allocate register map: %d\n", 583 ret); 584 return ret; 585 } 586 587 /* Support irq domain for RT8973A MUIC device */ 588 irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED; 589 ret = regmap_add_irq_chip(info->regmap, info->irq, irq_flags, 0, 590 &rt8973a_muic_irq_chip, &info->irq_data); 591 if (ret != 0) { 592 dev_err(info->dev, "failed to add irq_chip (irq:%d, err:%d)\n", 593 info->irq, ret); 594 return ret; 595 } 596 597 for (i = 0; i < info->num_muic_irqs; i++) { 598 struct muic_irq *muic_irq = &info->muic_irqs[i]; 599 int virq = 0; 600 601 virq = regmap_irq_get_virq(info->irq_data, muic_irq->irq); 602 if (virq <= 0) 603 return -EINVAL; 604 muic_irq->virq = virq; 605 606 ret = devm_request_threaded_irq(info->dev, virq, NULL, 607 rt8973a_muic_irq_handler, 608 IRQF_NO_SUSPEND | IRQF_ONESHOT, 609 muic_irq->name, info); 610 if (ret) { 611 dev_err(info->dev, 612 "failed: irq request (IRQ: %d, error :%d)\n", 613 muic_irq->irq, ret); 614 return ret; 615 } 616 } 617 618 /* Allocate extcon device */ 619 info->edev = devm_extcon_dev_allocate(info->dev, rt8973a_extcon_cable); 620 if (IS_ERR(info->edev)) { 621 dev_err(info->dev, "failed to allocate memory for extcon\n"); 622 return -ENOMEM; 623 } 624 625 /* Register extcon device */ 626 ret = devm_extcon_dev_register(info->dev, info->edev); 627 if (ret) { 628 dev_err(info->dev, "failed to register extcon device\n"); 629 return ret; 630 } 631 632 /* 633 * Detect accessory after completing the initialization of platform 634 * 635 * - Use delayed workqueue to detect cable state and then 636 * notify cable state to notifiee/platform through uevent. 637 * After completing the booting of platform, the extcon provider 638 * driver should notify cable state to upper layer. 639 */ 640 INIT_DELAYED_WORK(&info->wq_detcable, rt8973a_muic_detect_cable_wq); 641 queue_delayed_work(system_power_efficient_wq, &info->wq_detcable, 642 msecs_to_jiffies(DELAY_MS_DEFAULT)); 643 644 /* Initialize RT8973A device and print vendor id and version id */ 645 rt8973a_init_dev_type(info); 646 647 return 0; 648 } 649 650 static int rt8973a_muic_i2c_remove(struct i2c_client *i2c) 651 { 652 struct rt8973a_muic_info *info = i2c_get_clientdata(i2c); 653 654 regmap_del_irq_chip(info->irq, info->irq_data); 655 656 return 0; 657 } 658 659 static const struct of_device_id rt8973a_dt_match[] = { 660 { .compatible = "richtek,rt8973a-muic" }, 661 { }, 662 }; 663 MODULE_DEVICE_TABLE(of, rt8973a_dt_match); 664 665 #ifdef CONFIG_PM_SLEEP 666 static int rt8973a_muic_suspend(struct device *dev) 667 { 668 struct i2c_client *i2c = to_i2c_client(dev); 669 struct rt8973a_muic_info *info = i2c_get_clientdata(i2c); 670 671 enable_irq_wake(info->irq); 672 673 return 0; 674 } 675 676 static int rt8973a_muic_resume(struct device *dev) 677 { 678 struct i2c_client *i2c = to_i2c_client(dev); 679 struct rt8973a_muic_info *info = i2c_get_clientdata(i2c); 680 681 disable_irq_wake(info->irq); 682 683 return 0; 684 } 685 #endif 686 687 static SIMPLE_DEV_PM_OPS(rt8973a_muic_pm_ops, 688 rt8973a_muic_suspend, rt8973a_muic_resume); 689 690 static const struct i2c_device_id rt8973a_i2c_id[] = { 691 { "rt8973a", TYPE_RT8973A }, 692 { } 693 }; 694 MODULE_DEVICE_TABLE(i2c, rt8973a_i2c_id); 695 696 static struct i2c_driver rt8973a_muic_i2c_driver = { 697 .driver = { 698 .name = "rt8973a", 699 .pm = &rt8973a_muic_pm_ops, 700 .of_match_table = rt8973a_dt_match, 701 }, 702 .probe = rt8973a_muic_i2c_probe, 703 .remove = rt8973a_muic_i2c_remove, 704 .id_table = rt8973a_i2c_id, 705 }; 706 707 static int __init rt8973a_muic_i2c_init(void) 708 { 709 return i2c_add_driver(&rt8973a_muic_i2c_driver); 710 } 711 subsys_initcall(rt8973a_muic_i2c_init); 712 713 MODULE_DESCRIPTION("Richtek RT8973A Extcon driver"); 714 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>"); 715 MODULE_LICENSE("GPL"); 716