1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // extcon-max8997.c - MAX8997 extcon driver to support MAX8997 MUIC 4 // 5 // Copyright (C) 2012 Samsung Electronics 6 // Donggeun Kim <dg77.kim@samsung.com> 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 #include <linux/i2c.h> 11 #include <linux/slab.h> 12 #include <linux/interrupt.h> 13 #include <linux/err.h> 14 #include <linux/platform_device.h> 15 #include <linux/kobject.h> 16 #include <linux/mfd/max8997.h> 17 #include <linux/mfd/max8997-private.h> 18 #include <linux/extcon-provider.h> 19 #include <linux/irqdomain.h> 20 21 #define DEV_NAME "max8997-muic" 22 #define DELAY_MS_DEFAULT 20000 /* unit: millisecond */ 23 24 enum max8997_muic_adc_debounce_time { 25 ADC_DEBOUNCE_TIME_0_5MS = 0, /* 0.5ms */ 26 ADC_DEBOUNCE_TIME_10MS, /* 10ms */ 27 ADC_DEBOUNCE_TIME_25MS, /* 25ms */ 28 ADC_DEBOUNCE_TIME_38_62MS, /* 38.62ms */ 29 }; 30 31 struct max8997_muic_irq { 32 unsigned int irq; 33 const char *name; 34 unsigned int virq; 35 }; 36 37 static struct max8997_muic_irq muic_irqs[] = { 38 { MAX8997_MUICIRQ_ADCError, "muic-ADCERROR" }, 39 { MAX8997_MUICIRQ_ADCLow, "muic-ADCLOW" }, 40 { MAX8997_MUICIRQ_ADC, "muic-ADC" }, 41 { MAX8997_MUICIRQ_VBVolt, "muic-VBVOLT" }, 42 { MAX8997_MUICIRQ_DBChg, "muic-DBCHG" }, 43 { MAX8997_MUICIRQ_DCDTmr, "muic-DCDTMR" }, 44 { MAX8997_MUICIRQ_ChgDetRun, "muic-CHGDETRUN" }, 45 { MAX8997_MUICIRQ_ChgTyp, "muic-CHGTYP" }, 46 { MAX8997_MUICIRQ_OVP, "muic-OVP" }, 47 { MAX8997_PMICIRQ_CHGINS, "pmic-CHGINS" }, 48 { MAX8997_PMICIRQ_CHGRM, "pmic-CHGRM" }, 49 }; 50 51 /* Define supported cable type */ 52 enum max8997_muic_acc_type { 53 MAX8997_MUIC_ADC_GROUND = 0x0, 54 MAX8997_MUIC_ADC_MHL, /* MHL*/ 55 MAX8997_MUIC_ADC_REMOTE_S1_BUTTON, 56 MAX8997_MUIC_ADC_REMOTE_S2_BUTTON, 57 MAX8997_MUIC_ADC_REMOTE_S3_BUTTON, 58 MAX8997_MUIC_ADC_REMOTE_S4_BUTTON, 59 MAX8997_MUIC_ADC_REMOTE_S5_BUTTON, 60 MAX8997_MUIC_ADC_REMOTE_S6_BUTTON, 61 MAX8997_MUIC_ADC_REMOTE_S7_BUTTON, 62 MAX8997_MUIC_ADC_REMOTE_S8_BUTTON, 63 MAX8997_MUIC_ADC_REMOTE_S9_BUTTON, 64 MAX8997_MUIC_ADC_REMOTE_S10_BUTTON, 65 MAX8997_MUIC_ADC_REMOTE_S11_BUTTON, 66 MAX8997_MUIC_ADC_REMOTE_S12_BUTTON, 67 MAX8997_MUIC_ADC_RESERVED_ACC_1, 68 MAX8997_MUIC_ADC_RESERVED_ACC_2, 69 MAX8997_MUIC_ADC_RESERVED_ACC_3, 70 MAX8997_MUIC_ADC_RESERVED_ACC_4, 71 MAX8997_MUIC_ADC_RESERVED_ACC_5, 72 MAX8997_MUIC_ADC_CEA936_AUDIO, 73 MAX8997_MUIC_ADC_PHONE_POWERED_DEV, 74 MAX8997_MUIC_ADC_TTY_CONVERTER, 75 MAX8997_MUIC_ADC_UART_CABLE, 76 MAX8997_MUIC_ADC_CEA936A_TYPE1_CHG, 77 MAX8997_MUIC_ADC_FACTORY_MODE_USB_OFF, /* JIG-USB-OFF */ 78 MAX8997_MUIC_ADC_FACTORY_MODE_USB_ON, /* JIG-USB-ON */ 79 MAX8997_MUIC_ADC_AV_CABLE_NOLOAD, /* DESKDOCK */ 80 MAX8997_MUIC_ADC_CEA936A_TYPE2_CHG, 81 MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF, /* JIG-UART */ 82 MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON, /* CARDOCK */ 83 MAX8997_MUIC_ADC_AUDIO_MODE_REMOTE, 84 MAX8997_MUIC_ADC_OPEN, /* OPEN */ 85 }; 86 87 enum max8997_muic_cable_group { 88 MAX8997_CABLE_GROUP_ADC = 0, 89 MAX8997_CABLE_GROUP_ADC_GND, 90 MAX8997_CABLE_GROUP_CHG, 91 MAX8997_CABLE_GROUP_VBVOLT, 92 }; 93 94 enum max8997_muic_usb_type { 95 MAX8997_USB_HOST, 96 MAX8997_USB_DEVICE, 97 }; 98 99 enum max8997_muic_charger_type { 100 MAX8997_CHARGER_TYPE_NONE = 0, 101 MAX8997_CHARGER_TYPE_USB, 102 MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT, 103 MAX8997_CHARGER_TYPE_DEDICATED_CHG, 104 MAX8997_CHARGER_TYPE_500MA, 105 MAX8997_CHARGER_TYPE_1A, 106 MAX8997_CHARGER_TYPE_DEAD_BATTERY = 7, 107 }; 108 109 struct max8997_muic_info { 110 struct device *dev; 111 struct i2c_client *muic; 112 struct extcon_dev *edev; 113 int prev_cable_type; 114 int prev_chg_type; 115 u8 status[2]; 116 117 int irq; 118 struct work_struct irq_work; 119 struct mutex mutex; 120 121 struct max8997_muic_platform_data *muic_pdata; 122 enum max8997_muic_charger_type pre_charger_type; 123 124 /* 125 * Use delayed workqueue to detect cable state and then 126 * notify cable state to notifiee/platform through uevent. 127 * After completing the booting of platform, the extcon provider 128 * driver should notify cable state to upper layer. 129 */ 130 struct delayed_work wq_detcable; 131 132 /* 133 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB 134 * h/w path of COMP2/COMN1 on CONTROL1 register. 135 */ 136 int path_usb; 137 int path_uart; 138 }; 139 140 static const unsigned int max8997_extcon_cable[] = { 141 EXTCON_USB, 142 EXTCON_USB_HOST, 143 EXTCON_CHG_USB_SDP, 144 EXTCON_CHG_USB_DCP, 145 EXTCON_CHG_USB_FAST, 146 EXTCON_CHG_USB_SLOW, 147 EXTCON_CHG_USB_CDP, 148 EXTCON_DISP_MHL, 149 EXTCON_DOCK, 150 EXTCON_JIG, 151 EXTCON_NONE, 152 }; 153 154 /* 155 * max8997_muic_set_debounce_time - Set the debounce time of ADC 156 * @info: the instance including private data of max8997 MUIC 157 * @time: the debounce time of ADC 158 */ 159 static int max8997_muic_set_debounce_time(struct max8997_muic_info *info, 160 enum max8997_muic_adc_debounce_time time) 161 { 162 int ret; 163 164 switch (time) { 165 case ADC_DEBOUNCE_TIME_0_5MS: 166 case ADC_DEBOUNCE_TIME_10MS: 167 case ADC_DEBOUNCE_TIME_25MS: 168 case ADC_DEBOUNCE_TIME_38_62MS: 169 ret = max8997_update_reg(info->muic, 170 MAX8997_MUIC_REG_CONTROL3, 171 time << CONTROL3_ADCDBSET_SHIFT, 172 CONTROL3_ADCDBSET_MASK); 173 if (ret) { 174 dev_err(info->dev, "failed to set ADC debounce time\n"); 175 return ret; 176 } 177 break; 178 default: 179 dev_err(info->dev, "invalid ADC debounce time\n"); 180 return -EINVAL; 181 } 182 183 return 0; 184 }; 185 186 /* 187 * max8997_muic_set_path - Set hardware line according to attached cable 188 * @info: the instance including private data of max8997 MUIC 189 * @value: the path according to attached cable 190 * @attached: the state of cable (true:attached, false:detached) 191 * 192 * The max8997 MUIC device share outside H/W line among a varity of cables, 193 * so this function set internal path of H/W line according to the type of 194 * attached cable. 195 */ 196 static int max8997_muic_set_path(struct max8997_muic_info *info, 197 u8 val, bool attached) 198 { 199 int ret; 200 u8 ctrl1, ctrl2 = 0; 201 202 if (attached) 203 ctrl1 = val; 204 else 205 ctrl1 = CONTROL1_SW_OPEN; 206 207 ret = max8997_update_reg(info->muic, 208 MAX8997_MUIC_REG_CONTROL1, ctrl1, COMP_SW_MASK); 209 if (ret < 0) { 210 dev_err(info->dev, "failed to update MUIC register\n"); 211 return ret; 212 } 213 214 if (attached) 215 ctrl2 |= CONTROL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */ 216 else 217 ctrl2 |= CONTROL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */ 218 219 ret = max8997_update_reg(info->muic, 220 MAX8997_MUIC_REG_CONTROL2, ctrl2, 221 CONTROL2_LOWPWR_MASK | CONTROL2_CPEN_MASK); 222 if (ret < 0) { 223 dev_err(info->dev, "failed to update MUIC register\n"); 224 return ret; 225 } 226 227 dev_info(info->dev, 228 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n", 229 ctrl1, ctrl2, attached ? "attached" : "detached"); 230 231 return 0; 232 } 233 234 /* 235 * max8997_muic_get_cable_type - Return cable type and check cable state 236 * @info: the instance including private data of max8997 MUIC 237 * @group: the path according to attached cable 238 * @attached: store cable state and return 239 * 240 * This function check the cable state either attached or detached, 241 * and then divide precise type of cable according to cable group. 242 * - MAX8997_CABLE_GROUP_ADC 243 * - MAX8997_CABLE_GROUP_CHG 244 */ 245 static int max8997_muic_get_cable_type(struct max8997_muic_info *info, 246 enum max8997_muic_cable_group group, bool *attached) 247 { 248 int cable_type = 0; 249 int adc; 250 int chg_type; 251 252 switch (group) { 253 case MAX8997_CABLE_GROUP_ADC: 254 /* 255 * Read ADC value to check cable type and decide cable state 256 * according to cable type 257 */ 258 adc = info->status[0] & STATUS1_ADC_MASK; 259 adc >>= STATUS1_ADC_SHIFT; 260 261 /* 262 * Check current cable state/cable type and store cable type 263 * (info->prev_cable_type) for handling cable when cable is 264 * detached. 265 */ 266 if (adc == MAX8997_MUIC_ADC_OPEN) { 267 *attached = false; 268 269 cable_type = info->prev_cable_type; 270 info->prev_cable_type = MAX8997_MUIC_ADC_OPEN; 271 } else { 272 *attached = true; 273 274 cable_type = info->prev_cable_type = adc; 275 } 276 break; 277 case MAX8997_CABLE_GROUP_CHG: 278 /* 279 * Read charger type to check cable type and decide cable state 280 * according to type of charger cable. 281 */ 282 chg_type = info->status[1] & STATUS2_CHGTYP_MASK; 283 chg_type >>= STATUS2_CHGTYP_SHIFT; 284 285 if (chg_type == MAX8997_CHARGER_TYPE_NONE) { 286 *attached = false; 287 288 cable_type = info->prev_chg_type; 289 info->prev_chg_type = MAX8997_CHARGER_TYPE_NONE; 290 } else { 291 *attached = true; 292 293 /* 294 * Check current cable state/cable type and store cable 295 * type(info->prev_chg_type) for handling cable when 296 * charger cable is detached. 297 */ 298 cable_type = info->prev_chg_type = chg_type; 299 } 300 301 break; 302 default: 303 dev_err(info->dev, "Unknown cable group (%d)\n", group); 304 cable_type = -EINVAL; 305 break; 306 } 307 308 return cable_type; 309 } 310 311 static int max8997_muic_handle_usb(struct max8997_muic_info *info, 312 enum max8997_muic_usb_type usb_type, bool attached) 313 { 314 int ret = 0; 315 316 ret = max8997_muic_set_path(info, info->path_usb, attached); 317 if (ret < 0) { 318 dev_err(info->dev, "failed to update muic register\n"); 319 return ret; 320 } 321 322 switch (usb_type) { 323 case MAX8997_USB_HOST: 324 extcon_set_state_sync(info->edev, EXTCON_USB_HOST, attached); 325 break; 326 case MAX8997_USB_DEVICE: 327 extcon_set_state_sync(info->edev, EXTCON_USB, attached); 328 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, 329 attached); 330 break; 331 default: 332 dev_err(info->dev, "failed to detect %s usb cable\n", 333 attached ? "attached" : "detached"); 334 return -EINVAL; 335 } 336 337 return 0; 338 } 339 340 static int max8997_muic_handle_dock(struct max8997_muic_info *info, 341 int cable_type, bool attached) 342 { 343 int ret = 0; 344 345 ret = max8997_muic_set_path(info, CONTROL1_SW_AUDIO, attached); 346 if (ret) { 347 dev_err(info->dev, "failed to update muic register\n"); 348 return ret; 349 } 350 351 switch (cable_type) { 352 case MAX8997_MUIC_ADC_AV_CABLE_NOLOAD: 353 case MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON: 354 extcon_set_state_sync(info->edev, EXTCON_DOCK, attached); 355 break; 356 default: 357 dev_err(info->dev, "failed to detect %s dock device\n", 358 attached ? "attached" : "detached"); 359 return -EINVAL; 360 } 361 362 return 0; 363 } 364 365 static int max8997_muic_handle_jig_uart(struct max8997_muic_info *info, 366 bool attached) 367 { 368 int ret = 0; 369 370 /* switch to UART */ 371 ret = max8997_muic_set_path(info, info->path_uart, attached); 372 if (ret) { 373 dev_err(info->dev, "failed to update muic register\n"); 374 return ret; 375 } 376 377 extcon_set_state_sync(info->edev, EXTCON_JIG, attached); 378 379 return 0; 380 } 381 382 static int max8997_muic_adc_handler(struct max8997_muic_info *info) 383 { 384 int cable_type; 385 bool attached; 386 int ret = 0; 387 388 /* Check cable state which is either detached or attached */ 389 cable_type = max8997_muic_get_cable_type(info, 390 MAX8997_CABLE_GROUP_ADC, &attached); 391 392 switch (cable_type) { 393 case MAX8997_MUIC_ADC_GROUND: 394 ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, attached); 395 if (ret < 0) 396 return ret; 397 break; 398 case MAX8997_MUIC_ADC_MHL: 399 extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, attached); 400 break; 401 case MAX8997_MUIC_ADC_FACTORY_MODE_USB_OFF: 402 case MAX8997_MUIC_ADC_FACTORY_MODE_USB_ON: 403 ret = max8997_muic_handle_usb(info, 404 MAX8997_USB_DEVICE, attached); 405 if (ret < 0) 406 return ret; 407 break; 408 case MAX8997_MUIC_ADC_AV_CABLE_NOLOAD: 409 case MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON: 410 ret = max8997_muic_handle_dock(info, cable_type, attached); 411 if (ret < 0) 412 return ret; 413 break; 414 case MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF: 415 ret = max8997_muic_handle_jig_uart(info, attached); 416 break; 417 case MAX8997_MUIC_ADC_REMOTE_S1_BUTTON: 418 case MAX8997_MUIC_ADC_REMOTE_S2_BUTTON: 419 case MAX8997_MUIC_ADC_REMOTE_S3_BUTTON: 420 case MAX8997_MUIC_ADC_REMOTE_S4_BUTTON: 421 case MAX8997_MUIC_ADC_REMOTE_S5_BUTTON: 422 case MAX8997_MUIC_ADC_REMOTE_S6_BUTTON: 423 case MAX8997_MUIC_ADC_REMOTE_S7_BUTTON: 424 case MAX8997_MUIC_ADC_REMOTE_S8_BUTTON: 425 case MAX8997_MUIC_ADC_REMOTE_S9_BUTTON: 426 case MAX8997_MUIC_ADC_REMOTE_S10_BUTTON: 427 case MAX8997_MUIC_ADC_REMOTE_S11_BUTTON: 428 case MAX8997_MUIC_ADC_REMOTE_S12_BUTTON: 429 case MAX8997_MUIC_ADC_RESERVED_ACC_1: 430 case MAX8997_MUIC_ADC_RESERVED_ACC_2: 431 case MAX8997_MUIC_ADC_RESERVED_ACC_3: 432 case MAX8997_MUIC_ADC_RESERVED_ACC_4: 433 case MAX8997_MUIC_ADC_RESERVED_ACC_5: 434 case MAX8997_MUIC_ADC_CEA936_AUDIO: 435 case MAX8997_MUIC_ADC_PHONE_POWERED_DEV: 436 case MAX8997_MUIC_ADC_TTY_CONVERTER: 437 case MAX8997_MUIC_ADC_UART_CABLE: 438 case MAX8997_MUIC_ADC_CEA936A_TYPE1_CHG: 439 case MAX8997_MUIC_ADC_CEA936A_TYPE2_CHG: 440 case MAX8997_MUIC_ADC_AUDIO_MODE_REMOTE: 441 /* 442 * This cable isn't used in general case if it is specially 443 * needed to detect additional cable, should implement 444 * proper operation when this cable is attached/detached. 445 */ 446 dev_info(info->dev, 447 "cable is %s but it isn't used (type:0x%x)\n", 448 attached ? "attached" : "detached", cable_type); 449 return -EAGAIN; 450 default: 451 dev_err(info->dev, 452 "failed to detect %s unknown cable (type:0x%x)\n", 453 attached ? "attached" : "detached", cable_type); 454 return -EINVAL; 455 } 456 457 return 0; 458 } 459 460 static int max8997_muic_chg_handler(struct max8997_muic_info *info) 461 { 462 int chg_type; 463 bool attached; 464 int adc; 465 466 chg_type = max8997_muic_get_cable_type(info, 467 MAX8997_CABLE_GROUP_CHG, &attached); 468 469 switch (chg_type) { 470 case MAX8997_CHARGER_TYPE_NONE: 471 break; 472 case MAX8997_CHARGER_TYPE_USB: 473 adc = info->status[0] & STATUS1_ADC_MASK; 474 adc >>= STATUS1_ADC_SHIFT; 475 476 if ((adc & STATUS1_ADC_MASK) == MAX8997_MUIC_ADC_OPEN) { 477 max8997_muic_handle_usb(info, 478 MAX8997_USB_DEVICE, attached); 479 } 480 break; 481 case MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT: 482 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP, 483 attached); 484 break; 485 case MAX8997_CHARGER_TYPE_DEDICATED_CHG: 486 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP, 487 attached); 488 break; 489 case MAX8997_CHARGER_TYPE_500MA: 490 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW, 491 attached); 492 break; 493 case MAX8997_CHARGER_TYPE_1A: 494 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST, 495 attached); 496 break; 497 default: 498 dev_err(info->dev, 499 "failed to detect %s unknown chg cable (type:0x%x)\n", 500 attached ? "attached" : "detached", chg_type); 501 return -EINVAL; 502 } 503 504 return 0; 505 } 506 507 static void max8997_muic_irq_work(struct work_struct *work) 508 { 509 struct max8997_muic_info *info = container_of(work, 510 struct max8997_muic_info, irq_work); 511 int irq_type = 0; 512 int i, ret; 513 514 if (!info->edev) 515 return; 516 517 mutex_lock(&info->mutex); 518 519 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) 520 if (info->irq == muic_irqs[i].virq) 521 irq_type = muic_irqs[i].irq; 522 523 ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1, 524 2, info->status); 525 if (ret) { 526 dev_err(info->dev, "failed to read muic register\n"); 527 mutex_unlock(&info->mutex); 528 return; 529 } 530 531 switch (irq_type) { 532 case MAX8997_MUICIRQ_ADCError: 533 case MAX8997_MUICIRQ_ADCLow: 534 case MAX8997_MUICIRQ_ADC: 535 /* Handle all of cable except for charger cable */ 536 ret = max8997_muic_adc_handler(info); 537 break; 538 case MAX8997_MUICIRQ_VBVolt: 539 case MAX8997_MUICIRQ_DBChg: 540 case MAX8997_MUICIRQ_DCDTmr: 541 case MAX8997_MUICIRQ_ChgDetRun: 542 case MAX8997_MUICIRQ_ChgTyp: 543 case MAX8997_PMICIRQ_CHGINS: 544 case MAX8997_PMICIRQ_CHGRM: 545 /* Handle charger cable */ 546 ret = max8997_muic_chg_handler(info); 547 break; 548 case MAX8997_MUICIRQ_OVP: 549 break; 550 default: 551 dev_info(info->dev, "misc interrupt: irq %d occurred\n", 552 irq_type); 553 mutex_unlock(&info->mutex); 554 return; 555 } 556 557 if (ret < 0) 558 dev_err(info->dev, "failed to handle MUIC interrupt\n"); 559 560 mutex_unlock(&info->mutex); 561 } 562 563 static irqreturn_t max8997_muic_irq_handler(int irq, void *data) 564 { 565 struct max8997_muic_info *info = data; 566 567 dev_dbg(info->dev, "irq:%d\n", irq); 568 info->irq = irq; 569 570 schedule_work(&info->irq_work); 571 572 return IRQ_HANDLED; 573 } 574 575 static int max8997_muic_detect_dev(struct max8997_muic_info *info) 576 { 577 int ret = 0; 578 int adc; 579 int chg_type; 580 bool attached; 581 582 mutex_lock(&info->mutex); 583 584 /* Read STATUSx register to detect accessory */ 585 ret = max8997_bulk_read(info->muic, 586 MAX8997_MUIC_REG_STATUS1, 2, info->status); 587 if (ret) { 588 dev_err(info->dev, "failed to read MUIC register\n"); 589 mutex_unlock(&info->mutex); 590 return ret; 591 } 592 593 adc = max8997_muic_get_cable_type(info, MAX8997_CABLE_GROUP_ADC, 594 &attached); 595 if (attached && adc != MAX8997_MUIC_ADC_OPEN) { 596 ret = max8997_muic_adc_handler(info); 597 if (ret < 0) { 598 dev_err(info->dev, "Cannot detect ADC cable\n"); 599 mutex_unlock(&info->mutex); 600 return ret; 601 } 602 } 603 604 chg_type = max8997_muic_get_cable_type(info, MAX8997_CABLE_GROUP_CHG, 605 &attached); 606 if (attached && chg_type != MAX8997_CHARGER_TYPE_NONE) { 607 ret = max8997_muic_chg_handler(info); 608 if (ret < 0) { 609 dev_err(info->dev, "Cannot detect charger cable\n"); 610 mutex_unlock(&info->mutex); 611 return ret; 612 } 613 } 614 615 mutex_unlock(&info->mutex); 616 617 return 0; 618 } 619 620 static void max8997_muic_detect_cable_wq(struct work_struct *work) 621 { 622 struct max8997_muic_info *info = container_of(to_delayed_work(work), 623 struct max8997_muic_info, wq_detcable); 624 int ret; 625 626 ret = max8997_muic_detect_dev(info); 627 if (ret < 0) 628 dev_err(info->dev, "failed to detect cable type\n"); 629 } 630 631 static int max8997_muic_probe(struct platform_device *pdev) 632 { 633 struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent); 634 struct max8997_platform_data *pdata = dev_get_platdata(max8997->dev); 635 struct max8997_muic_info *info; 636 int delay_jiffies; 637 int cable_type; 638 bool attached; 639 int ret, i; 640 641 info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_muic_info), 642 GFP_KERNEL); 643 if (!info) 644 return -ENOMEM; 645 646 info->dev = &pdev->dev; 647 info->muic = max8997->muic; 648 649 platform_set_drvdata(pdev, info); 650 mutex_init(&info->mutex); 651 652 INIT_WORK(&info->irq_work, max8997_muic_irq_work); 653 654 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) { 655 struct max8997_muic_irq *muic_irq = &muic_irqs[i]; 656 unsigned int virq = 0; 657 658 virq = irq_create_mapping(max8997->irq_domain, muic_irq->irq); 659 if (!virq) { 660 ret = -EINVAL; 661 goto err_irq; 662 } 663 muic_irq->virq = virq; 664 665 ret = request_threaded_irq(virq, NULL, 666 max8997_muic_irq_handler, 667 IRQF_NO_SUSPEND, 668 muic_irq->name, info); 669 if (ret) { 670 dev_err(&pdev->dev, 671 "failed: irq request (IRQ: %d, error :%d)\n", 672 muic_irq->irq, ret); 673 goto err_irq; 674 } 675 } 676 677 /* External connector */ 678 info->edev = devm_extcon_dev_allocate(&pdev->dev, max8997_extcon_cable); 679 if (IS_ERR(info->edev)) { 680 dev_err(&pdev->dev, "failed to allocate memory for extcon\n"); 681 ret = PTR_ERR(info->edev); 682 goto err_irq; 683 } 684 685 ret = devm_extcon_dev_register(&pdev->dev, info->edev); 686 if (ret) { 687 dev_err(&pdev->dev, "failed to register extcon device\n"); 688 goto err_irq; 689 } 690 691 if (pdata && pdata->muic_pdata) { 692 struct max8997_muic_platform_data *muic_pdata 693 = pdata->muic_pdata; 694 695 /* Initialize registers according to platform data */ 696 for (i = 0; i < muic_pdata->num_init_data; i++) { 697 max8997_write_reg(info->muic, 698 muic_pdata->init_data[i].addr, 699 muic_pdata->init_data[i].data); 700 } 701 702 /* 703 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB 704 * h/w path of COMP2/COMN1 on CONTROL1 register. 705 */ 706 if (muic_pdata->path_uart) 707 info->path_uart = muic_pdata->path_uart; 708 else 709 info->path_uart = CONTROL1_SW_UART; 710 711 if (muic_pdata->path_usb) 712 info->path_usb = muic_pdata->path_usb; 713 else 714 info->path_usb = CONTROL1_SW_USB; 715 716 /* 717 * Default delay time for detecting cable state 718 * after certain time. 719 */ 720 if (muic_pdata->detcable_delay_ms) 721 delay_jiffies = 722 msecs_to_jiffies(muic_pdata->detcable_delay_ms); 723 else 724 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); 725 } else { 726 info->path_uart = CONTROL1_SW_UART; 727 info->path_usb = CONTROL1_SW_USB; 728 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); 729 } 730 731 /* Set initial path for UART when JIG is connected to get serial logs */ 732 ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1, 733 2, info->status); 734 if (ret) { 735 dev_err(info->dev, "failed to read MUIC register\n"); 736 return ret; 737 } 738 cable_type = max8997_muic_get_cable_type(info, 739 MAX8997_CABLE_GROUP_ADC, &attached); 740 if (attached && cable_type == MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF) 741 max8997_muic_set_path(info, info->path_uart, true); 742 743 /* Set ADC debounce time */ 744 max8997_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS); 745 746 /* 747 * Detect accessory after completing the initialization of platform 748 * 749 * - Use delayed workqueue to detect cable state and then 750 * notify cable state to notifiee/platform through uevent. 751 * After completing the booting of platform, the extcon provider 752 * driver should notify cable state to upper layer. 753 */ 754 INIT_DELAYED_WORK(&info->wq_detcable, max8997_muic_detect_cable_wq); 755 queue_delayed_work(system_power_efficient_wq, &info->wq_detcable, 756 delay_jiffies); 757 758 return 0; 759 760 err_irq: 761 while (--i >= 0) 762 free_irq(muic_irqs[i].virq, info); 763 return ret; 764 } 765 766 static int max8997_muic_remove(struct platform_device *pdev) 767 { 768 struct max8997_muic_info *info = platform_get_drvdata(pdev); 769 int i; 770 771 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) 772 free_irq(muic_irqs[i].virq, info); 773 cancel_work_sync(&info->irq_work); 774 775 return 0; 776 } 777 778 static struct platform_driver max8997_muic_driver = { 779 .driver = { 780 .name = DEV_NAME, 781 }, 782 .probe = max8997_muic_probe, 783 .remove = max8997_muic_remove, 784 }; 785 786 module_platform_driver(max8997_muic_driver); 787 788 MODULE_DESCRIPTION("Maxim MAX8997 Extcon driver"); 789 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>"); 790 MODULE_LICENSE("GPL"); 791