1 /* 2 * extcon-max14577.c - MAX14577 extcon driver to support MAX14577 MUIC 3 * 4 * Copyright (C) 2013 Samsung Electrnoics 5 * Chanwoo Choi <cw00.choi@samsung.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/i2c.h> 21 #include <linux/interrupt.h> 22 #include <linux/platform_device.h> 23 #include <linux/mfd/max14577.h> 24 #include <linux/mfd/max14577-private.h> 25 #include <linux/extcon.h> 26 27 #define DEV_NAME "max14577-muic" 28 #define DELAY_MS_DEFAULT 17000 /* unit: millisecond */ 29 30 enum max14577_muic_adc_debounce_time { 31 ADC_DEBOUNCE_TIME_5MS = 0, 32 ADC_DEBOUNCE_TIME_10MS, 33 ADC_DEBOUNCE_TIME_25MS, 34 ADC_DEBOUNCE_TIME_38_62MS, 35 }; 36 37 enum max14577_muic_status { 38 MAX14577_MUIC_STATUS1 = 0, 39 MAX14577_MUIC_STATUS2 = 1, 40 MAX14577_MUIC_STATUS_END, 41 }; 42 43 struct max14577_muic_info { 44 struct device *dev; 45 struct max14577 *max14577; 46 struct extcon_dev *edev; 47 int prev_cable_type; 48 int prev_chg_type; 49 u8 status[MAX14577_MUIC_STATUS_END]; 50 51 bool irq_adc; 52 bool irq_chg; 53 struct work_struct irq_work; 54 struct mutex mutex; 55 56 /* 57 * Use delayed workqueue to detect cable state and then 58 * notify cable state to notifiee/platform through uevent. 59 * After completing the booting of platform, the extcon provider 60 * driver should notify cable state to upper layer. 61 */ 62 struct delayed_work wq_detcable; 63 64 /* 65 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB 66 * h/w path of COMP2/COMN1 on CONTROL1 register. 67 */ 68 int path_usb; 69 int path_uart; 70 }; 71 72 enum max14577_muic_cable_group { 73 MAX14577_CABLE_GROUP_ADC = 0, 74 MAX14577_CABLE_GROUP_CHG, 75 }; 76 77 /** 78 * struct max14577_muic_irq 79 * @irq: the index of irq list of MUIC device. 80 * @name: the name of irq. 81 * @virq: the virtual irq to use irq domain 82 */ 83 struct max14577_muic_irq { 84 unsigned int irq; 85 const char *name; 86 unsigned int virq; 87 }; 88 89 static struct max14577_muic_irq muic_irqs[] = { 90 { MAX14577_IRQ_INT1_ADC, "muic-ADC" }, 91 { MAX14577_IRQ_INT1_ADCLOW, "muic-ADCLOW" }, 92 { MAX14577_IRQ_INT1_ADCERR, "muic-ADCError" }, 93 { MAX14577_IRQ_INT2_CHGTYP, "muic-CHGTYP" }, 94 { MAX14577_IRQ_INT2_CHGDETRUN, "muic-CHGDETRUN" }, 95 { MAX14577_IRQ_INT2_DCDTMR, "muic-DCDTMR" }, 96 { MAX14577_IRQ_INT2_DBCHG, "muic-DBCHG" }, 97 { MAX14577_IRQ_INT2_VBVOLT, "muic-VBVOLT" }, 98 }; 99 100 /* Define supported accessory type */ 101 enum max14577_muic_acc_type { 102 MAX14577_MUIC_ADC_GROUND = 0x0, 103 MAX14577_MUIC_ADC_SEND_END_BUTTON, 104 MAX14577_MUIC_ADC_REMOTE_S1_BUTTON, 105 MAX14577_MUIC_ADC_REMOTE_S2_BUTTON, 106 MAX14577_MUIC_ADC_REMOTE_S3_BUTTON, 107 MAX14577_MUIC_ADC_REMOTE_S4_BUTTON, 108 MAX14577_MUIC_ADC_REMOTE_S5_BUTTON, 109 MAX14577_MUIC_ADC_REMOTE_S6_BUTTON, 110 MAX14577_MUIC_ADC_REMOTE_S7_BUTTON, 111 MAX14577_MUIC_ADC_REMOTE_S8_BUTTON, 112 MAX14577_MUIC_ADC_REMOTE_S9_BUTTON, 113 MAX14577_MUIC_ADC_REMOTE_S10_BUTTON, 114 MAX14577_MUIC_ADC_REMOTE_S11_BUTTON, 115 MAX14577_MUIC_ADC_REMOTE_S12_BUTTON, 116 MAX14577_MUIC_ADC_RESERVED_ACC_1, 117 MAX14577_MUIC_ADC_RESERVED_ACC_2, 118 MAX14577_MUIC_ADC_RESERVED_ACC_3, 119 MAX14577_MUIC_ADC_RESERVED_ACC_4, 120 MAX14577_MUIC_ADC_RESERVED_ACC_5, 121 MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2, 122 MAX14577_MUIC_ADC_PHONE_POWERED_DEV, 123 MAX14577_MUIC_ADC_TTY_CONVERTER, 124 MAX14577_MUIC_ADC_UART_CABLE, 125 MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG, 126 MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF, 127 MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON, 128 MAX14577_MUIC_ADC_AV_CABLE_NOLOAD, 129 MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG, 130 MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF, 131 MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON, 132 MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1, /* with Remote and Simple Ctrl */ 133 MAX14577_MUIC_ADC_OPEN, 134 }; 135 136 /* max14577 MUIC device support below list of accessories(external connector) */ 137 enum { 138 EXTCON_CABLE_USB = 0, 139 EXTCON_CABLE_TA, 140 EXTCON_CABLE_FAST_CHARGER, 141 EXTCON_CABLE_SLOW_CHARGER, 142 EXTCON_CABLE_CHARGE_DOWNSTREAM, 143 EXTCON_CABLE_JIG_USB_ON, 144 EXTCON_CABLE_JIG_USB_OFF, 145 EXTCON_CABLE_JIG_UART_OFF, 146 EXTCON_CABLE_JIG_UART_ON, 147 148 _EXTCON_CABLE_NUM, 149 }; 150 151 static const char *max14577_extcon_cable[] = { 152 [EXTCON_CABLE_USB] = "USB", 153 [EXTCON_CABLE_TA] = "TA", 154 [EXTCON_CABLE_FAST_CHARGER] = "Fast-charger", 155 [EXTCON_CABLE_SLOW_CHARGER] = "Slow-charger", 156 [EXTCON_CABLE_CHARGE_DOWNSTREAM] = "Charge-downstream", 157 [EXTCON_CABLE_JIG_USB_ON] = "JIG-USB-ON", 158 [EXTCON_CABLE_JIG_USB_OFF] = "JIG-USB-OFF", 159 [EXTCON_CABLE_JIG_UART_OFF] = "JIG-UART-OFF", 160 [EXTCON_CABLE_JIG_UART_ON] = "JIG-UART-ON", 161 162 NULL, 163 }; 164 165 /* 166 * max14577_muic_set_debounce_time - Set the debounce time of ADC 167 * @info: the instance including private data of max14577 MUIC 168 * @time: the debounce time of ADC 169 */ 170 static int max14577_muic_set_debounce_time(struct max14577_muic_info *info, 171 enum max14577_muic_adc_debounce_time time) 172 { 173 u8 ret; 174 175 switch (time) { 176 case ADC_DEBOUNCE_TIME_5MS: 177 case ADC_DEBOUNCE_TIME_10MS: 178 case ADC_DEBOUNCE_TIME_25MS: 179 case ADC_DEBOUNCE_TIME_38_62MS: 180 ret = max14577_update_reg(info->max14577->regmap, 181 MAX14577_MUIC_REG_CONTROL3, 182 CTRL3_ADCDBSET_MASK, 183 time << CTRL3_ADCDBSET_SHIFT); 184 if (ret) { 185 dev_err(info->dev, "failed to set ADC debounce time\n"); 186 return ret; 187 } 188 break; 189 default: 190 dev_err(info->dev, "invalid ADC debounce time\n"); 191 return -EINVAL; 192 } 193 194 return 0; 195 }; 196 197 /* 198 * max14577_muic_set_path - Set hardware line according to attached cable 199 * @info: the instance including private data of max14577 MUIC 200 * @value: the path according to attached cable 201 * @attached: the state of cable (true:attached, false:detached) 202 * 203 * The max14577 MUIC device share outside H/W line among a varity of cables 204 * so, this function set internal path of H/W line according to the type of 205 * attached cable. 206 */ 207 static int max14577_muic_set_path(struct max14577_muic_info *info, 208 u8 val, bool attached) 209 { 210 int ret = 0; 211 u8 ctrl1, ctrl2 = 0; 212 213 /* Set open state to path before changing hw path */ 214 ret = max14577_update_reg(info->max14577->regmap, 215 MAX14577_MUIC_REG_CONTROL1, 216 CLEAR_IDBEN_MICEN_MASK, CTRL1_SW_OPEN); 217 if (ret < 0) { 218 dev_err(info->dev, "failed to update MUIC register\n"); 219 return ret; 220 } 221 222 if (attached) 223 ctrl1 = val; 224 else 225 ctrl1 = CTRL1_SW_OPEN; 226 227 ret = max14577_update_reg(info->max14577->regmap, 228 MAX14577_MUIC_REG_CONTROL1, 229 CLEAR_IDBEN_MICEN_MASK, ctrl1); 230 if (ret < 0) { 231 dev_err(info->dev, "failed to update MUIC register\n"); 232 return ret; 233 } 234 235 if (attached) 236 ctrl2 |= CTRL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */ 237 else 238 ctrl2 |= CTRL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */ 239 240 ret = max14577_update_reg(info->max14577->regmap, 241 MAX14577_REG_CONTROL2, 242 CTRL2_LOWPWR_MASK | CTRL2_CPEN_MASK, ctrl2); 243 if (ret < 0) { 244 dev_err(info->dev, "failed to update MUIC register\n"); 245 return ret; 246 } 247 248 dev_dbg(info->dev, 249 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n", 250 ctrl1, ctrl2, attached ? "attached" : "detached"); 251 252 return 0; 253 } 254 255 /* 256 * max14577_muic_get_cable_type - Return cable type and check cable state 257 * @info: the instance including private data of max14577 MUIC 258 * @group: the path according to attached cable 259 * @attached: store cable state and return 260 * 261 * This function check the cable state either attached or detached, 262 * and then divide precise type of cable according to cable group. 263 * - max14577_CABLE_GROUP_ADC 264 * - max14577_CABLE_GROUP_CHG 265 */ 266 static int max14577_muic_get_cable_type(struct max14577_muic_info *info, 267 enum max14577_muic_cable_group group, bool *attached) 268 { 269 int cable_type = 0; 270 int adc; 271 int chg_type; 272 273 switch (group) { 274 case MAX14577_CABLE_GROUP_ADC: 275 /* 276 * Read ADC value to check cable type and decide cable state 277 * according to cable type 278 */ 279 adc = info->status[MAX14577_MUIC_STATUS1] & STATUS1_ADC_MASK; 280 adc >>= STATUS1_ADC_SHIFT; 281 282 /* 283 * Check current cable state/cable type and store cable type 284 * (info->prev_cable_type) for handling cable when cable is 285 * detached. 286 */ 287 if (adc == MAX14577_MUIC_ADC_OPEN) { 288 *attached = false; 289 290 cable_type = info->prev_cable_type; 291 info->prev_cable_type = MAX14577_MUIC_ADC_OPEN; 292 } else { 293 *attached = true; 294 295 cable_type = info->prev_cable_type = adc; 296 } 297 break; 298 case MAX14577_CABLE_GROUP_CHG: 299 /* 300 * Read charger type to check cable type and decide cable state 301 * according to type of charger cable. 302 */ 303 chg_type = info->status[MAX14577_MUIC_STATUS2] & 304 STATUS2_CHGTYP_MASK; 305 chg_type >>= STATUS2_CHGTYP_SHIFT; 306 307 if (chg_type == MAX14577_CHARGER_TYPE_NONE) { 308 *attached = false; 309 310 cable_type = info->prev_chg_type; 311 info->prev_chg_type = MAX14577_CHARGER_TYPE_NONE; 312 } else { 313 *attached = true; 314 315 /* 316 * Check current cable state/cable type and store cable 317 * type(info->prev_chg_type) for handling cable when 318 * charger cable is detached. 319 */ 320 cable_type = info->prev_chg_type = chg_type; 321 } 322 323 break; 324 default: 325 dev_err(info->dev, "Unknown cable group (%d)\n", group); 326 cable_type = -EINVAL; 327 break; 328 } 329 330 return cable_type; 331 } 332 333 static int max14577_muic_jig_handler(struct max14577_muic_info *info, 334 int cable_type, bool attached) 335 { 336 char cable_name[32]; 337 int ret = 0; 338 u8 path = CTRL1_SW_OPEN; 339 340 dev_dbg(info->dev, 341 "external connector is %s (adc:0x%02x)\n", 342 attached ? "attached" : "detached", cable_type); 343 344 switch (cable_type) { 345 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF: /* ADC_JIG_USB_OFF */ 346 /* PATH:AP_USB */ 347 strcpy(cable_name, "JIG-USB-OFF"); 348 path = CTRL1_SW_USB; 349 break; 350 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON: /* ADC_JIG_USB_ON */ 351 /* PATH:AP_USB */ 352 strcpy(cable_name, "JIG-USB-ON"); 353 path = CTRL1_SW_USB; 354 break; 355 case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF: /* ADC_JIG_UART_OFF */ 356 /* PATH:AP_UART */ 357 strcpy(cable_name, "JIG-UART-OFF"); 358 path = CTRL1_SW_UART; 359 break; 360 default: 361 dev_err(info->dev, "failed to detect %s jig cable\n", 362 attached ? "attached" : "detached"); 363 return -EINVAL; 364 } 365 366 ret = max14577_muic_set_path(info, path, attached); 367 if (ret < 0) 368 return ret; 369 370 extcon_set_cable_state(info->edev, cable_name, attached); 371 372 return 0; 373 } 374 375 static int max14577_muic_adc_handler(struct max14577_muic_info *info) 376 { 377 int cable_type; 378 bool attached; 379 int ret = 0; 380 381 /* Check accessory state which is either detached or attached */ 382 cable_type = max14577_muic_get_cable_type(info, 383 MAX14577_CABLE_GROUP_ADC, &attached); 384 385 dev_dbg(info->dev, 386 "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n", 387 attached ? "attached" : "detached", cable_type, 388 info->prev_cable_type); 389 390 switch (cable_type) { 391 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF: 392 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON: 393 case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF: 394 /* JIG */ 395 ret = max14577_muic_jig_handler(info, cable_type, attached); 396 if (ret < 0) 397 return ret; 398 break; 399 case MAX14577_MUIC_ADC_GROUND: 400 case MAX14577_MUIC_ADC_SEND_END_BUTTON: 401 case MAX14577_MUIC_ADC_REMOTE_S1_BUTTON: 402 case MAX14577_MUIC_ADC_REMOTE_S2_BUTTON: 403 case MAX14577_MUIC_ADC_REMOTE_S3_BUTTON: 404 case MAX14577_MUIC_ADC_REMOTE_S4_BUTTON: 405 case MAX14577_MUIC_ADC_REMOTE_S5_BUTTON: 406 case MAX14577_MUIC_ADC_REMOTE_S6_BUTTON: 407 case MAX14577_MUIC_ADC_REMOTE_S7_BUTTON: 408 case MAX14577_MUIC_ADC_REMOTE_S8_BUTTON: 409 case MAX14577_MUIC_ADC_REMOTE_S9_BUTTON: 410 case MAX14577_MUIC_ADC_REMOTE_S10_BUTTON: 411 case MAX14577_MUIC_ADC_REMOTE_S11_BUTTON: 412 case MAX14577_MUIC_ADC_REMOTE_S12_BUTTON: 413 case MAX14577_MUIC_ADC_RESERVED_ACC_1: 414 case MAX14577_MUIC_ADC_RESERVED_ACC_2: 415 case MAX14577_MUIC_ADC_RESERVED_ACC_3: 416 case MAX14577_MUIC_ADC_RESERVED_ACC_4: 417 case MAX14577_MUIC_ADC_RESERVED_ACC_5: 418 case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2: 419 case MAX14577_MUIC_ADC_PHONE_POWERED_DEV: 420 case MAX14577_MUIC_ADC_TTY_CONVERTER: 421 case MAX14577_MUIC_ADC_UART_CABLE: 422 case MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG: 423 case MAX14577_MUIC_ADC_AV_CABLE_NOLOAD: 424 case MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG: 425 case MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON: 426 case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1: 427 /* 428 * This accessory isn't used in general case if it is specially 429 * needed to detect additional accessory, should implement 430 * proper operation when this accessory is attached/detached. 431 */ 432 dev_info(info->dev, 433 "accessory is %s but it isn't used (adc:0x%x)\n", 434 attached ? "attached" : "detached", cable_type); 435 return -EAGAIN; 436 default: 437 dev_err(info->dev, 438 "failed to detect %s accessory (adc:0x%x)\n", 439 attached ? "attached" : "detached", cable_type); 440 return -EINVAL; 441 } 442 443 return 0; 444 } 445 446 static int max14577_muic_chg_handler(struct max14577_muic_info *info) 447 { 448 int chg_type; 449 bool attached; 450 int ret = 0; 451 452 chg_type = max14577_muic_get_cable_type(info, 453 MAX14577_CABLE_GROUP_CHG, &attached); 454 455 dev_dbg(info->dev, 456 "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n", 457 attached ? "attached" : "detached", 458 chg_type, info->prev_chg_type); 459 460 switch (chg_type) { 461 case MAX14577_CHARGER_TYPE_USB: 462 /* PATH:AP_USB */ 463 ret = max14577_muic_set_path(info, info->path_usb, attached); 464 if (ret < 0) 465 return ret; 466 467 extcon_set_cable_state(info->edev, "USB", attached); 468 break; 469 case MAX14577_CHARGER_TYPE_DEDICATED_CHG: 470 extcon_set_cable_state(info->edev, "TA", attached); 471 break; 472 case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT: 473 extcon_set_cable_state(info->edev, 474 "Charge-downstream", attached); 475 break; 476 case MAX14577_CHARGER_TYPE_SPECIAL_500MA: 477 extcon_set_cable_state(info->edev, "Slow-charger", attached); 478 break; 479 case MAX14577_CHARGER_TYPE_SPECIAL_1A: 480 extcon_set_cable_state(info->edev, "Fast-charger", attached); 481 break; 482 case MAX14577_CHARGER_TYPE_NONE: 483 case MAX14577_CHARGER_TYPE_DEAD_BATTERY: 484 break; 485 default: 486 dev_err(info->dev, 487 "failed to detect %s accessory (chg_type:0x%x)\n", 488 attached ? "attached" : "detached", chg_type); 489 return -EINVAL; 490 } 491 492 return 0; 493 } 494 495 static void max14577_muic_irq_work(struct work_struct *work) 496 { 497 struct max14577_muic_info *info = container_of(work, 498 struct max14577_muic_info, irq_work); 499 int ret = 0; 500 501 if (!info->edev) 502 return; 503 504 mutex_lock(&info->mutex); 505 506 ret = max14577_bulk_read(info->max14577->regmap, 507 MAX14577_MUIC_REG_STATUS1, info->status, 2); 508 if (ret) { 509 dev_err(info->dev, "failed to read MUIC register\n"); 510 mutex_unlock(&info->mutex); 511 return; 512 } 513 514 if (info->irq_adc) { 515 ret = max14577_muic_adc_handler(info); 516 info->irq_adc = false; 517 } 518 if (info->irq_chg) { 519 ret = max14577_muic_chg_handler(info); 520 info->irq_chg = false; 521 } 522 523 if (ret < 0) 524 dev_err(info->dev, "failed to handle MUIC interrupt\n"); 525 526 mutex_unlock(&info->mutex); 527 528 return; 529 } 530 531 static irqreturn_t max14577_muic_irq_handler(int irq, void *data) 532 { 533 struct max14577_muic_info *info = data; 534 int i, irq_type = -1; 535 536 /* 537 * We may be called multiple times for different nested IRQ-s. 538 * Including changes in INT1_ADC and INT2_CGHTYP at once. 539 * However we only need to know whether it was ADC, charger 540 * or both interrupts so decode IRQ and turn on proper flags. 541 */ 542 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) 543 if (irq == muic_irqs[i].virq) 544 irq_type = muic_irqs[i].irq; 545 546 switch (irq_type) { 547 case MAX14577_IRQ_INT1_ADC: 548 case MAX14577_IRQ_INT1_ADCLOW: 549 case MAX14577_IRQ_INT1_ADCERR: 550 /* Handle all of accessory except for 551 type of charger accessory */ 552 info->irq_adc = true; 553 break; 554 case MAX14577_IRQ_INT2_CHGTYP: 555 case MAX14577_IRQ_INT2_CHGDETRUN: 556 case MAX14577_IRQ_INT2_DCDTMR: 557 case MAX14577_IRQ_INT2_DBCHG: 558 case MAX14577_IRQ_INT2_VBVOLT: 559 /* Handle charger accessory */ 560 info->irq_chg = true; 561 break; 562 default: 563 dev_err(info->dev, "muic interrupt: irq %d occurred, skipped\n", 564 irq_type); 565 return IRQ_HANDLED; 566 } 567 schedule_work(&info->irq_work); 568 569 return IRQ_HANDLED; 570 } 571 572 static int max14577_muic_detect_accessory(struct max14577_muic_info *info) 573 { 574 int ret = 0; 575 int adc; 576 int chg_type; 577 bool attached; 578 579 mutex_lock(&info->mutex); 580 581 /* Read STATUSx register to detect accessory */ 582 ret = max14577_bulk_read(info->max14577->regmap, 583 MAX14577_MUIC_REG_STATUS1, info->status, 2); 584 if (ret) { 585 dev_err(info->dev, "failed to read MUIC register\n"); 586 mutex_unlock(&info->mutex); 587 return ret; 588 } 589 590 adc = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_ADC, 591 &attached); 592 if (attached && adc != MAX14577_MUIC_ADC_OPEN) { 593 ret = max14577_muic_adc_handler(info); 594 if (ret < 0) { 595 dev_err(info->dev, "Cannot detect accessory\n"); 596 mutex_unlock(&info->mutex); 597 return ret; 598 } 599 } 600 601 chg_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_CHG, 602 &attached); 603 if (attached && chg_type != MAX14577_CHARGER_TYPE_NONE) { 604 ret = max14577_muic_chg_handler(info); 605 if (ret < 0) { 606 dev_err(info->dev, "Cannot detect charger accessory\n"); 607 mutex_unlock(&info->mutex); 608 return ret; 609 } 610 } 611 612 mutex_unlock(&info->mutex); 613 614 return 0; 615 } 616 617 static void max14577_muic_detect_cable_wq(struct work_struct *work) 618 { 619 struct max14577_muic_info *info = container_of(to_delayed_work(work), 620 struct max14577_muic_info, wq_detcable); 621 622 max14577_muic_detect_accessory(info); 623 } 624 625 static int max14577_muic_probe(struct platform_device *pdev) 626 { 627 struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent); 628 struct max14577_muic_info *info; 629 int delay_jiffies; 630 int ret; 631 int i; 632 u8 id; 633 634 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); 635 if (!info) { 636 dev_err(&pdev->dev, "failed to allocate memory\n"); 637 return -ENOMEM; 638 } 639 info->dev = &pdev->dev; 640 info->max14577 = max14577; 641 642 platform_set_drvdata(pdev, info); 643 mutex_init(&info->mutex); 644 645 INIT_WORK(&info->irq_work, max14577_muic_irq_work); 646 647 /* Support irq domain for max14577 MUIC device */ 648 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) { 649 struct max14577_muic_irq *muic_irq = &muic_irqs[i]; 650 unsigned int virq = 0; 651 652 virq = regmap_irq_get_virq(max14577->irq_data, muic_irq->irq); 653 if (!virq) 654 return -EINVAL; 655 muic_irq->virq = virq; 656 657 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL, 658 max14577_muic_irq_handler, 659 IRQF_NO_SUSPEND, 660 muic_irq->name, info); 661 if (ret) { 662 dev_err(&pdev->dev, 663 "failed: irq request (IRQ: %d," 664 " error :%d)\n", 665 muic_irq->irq, ret); 666 return ret; 667 } 668 } 669 670 /* Initialize extcon device */ 671 info->edev = devm_kzalloc(&pdev->dev, sizeof(*info->edev), GFP_KERNEL); 672 if (!info->edev) { 673 dev_err(&pdev->dev, "failed to allocate memory for extcon\n"); 674 return -ENOMEM; 675 } 676 info->edev->name = DEV_NAME; 677 info->edev->supported_cable = max14577_extcon_cable; 678 ret = extcon_dev_register(info->edev); 679 if (ret) { 680 dev_err(&pdev->dev, "failed to register extcon device\n"); 681 return ret; 682 } 683 684 /* Default h/w line path */ 685 info->path_usb = CTRL1_SW_USB; 686 info->path_uart = CTRL1_SW_UART; 687 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); 688 689 /* Set initial path for UART */ 690 max14577_muic_set_path(info, info->path_uart, true); 691 692 /* Check revision number of MUIC device*/ 693 ret = max14577_read_reg(info->max14577->regmap, 694 MAX14577_REG_DEVICEID, &id); 695 if (ret < 0) { 696 dev_err(&pdev->dev, "failed to read revision number\n"); 697 goto err_extcon; 698 } 699 dev_info(info->dev, "device ID : 0x%x\n", id); 700 701 /* Set ADC debounce time */ 702 max14577_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS); 703 704 /* 705 * Detect accessory after completing the initialization of platform 706 * 707 * - Use delayed workqueue to detect cable state and then 708 * notify cable state to notifiee/platform through uevent. 709 * After completing the booting of platform, the extcon provider 710 * driver should notify cable state to upper layer. 711 */ 712 INIT_DELAYED_WORK(&info->wq_detcable, max14577_muic_detect_cable_wq); 713 ret = queue_delayed_work(system_power_efficient_wq, &info->wq_detcable, 714 delay_jiffies); 715 if (ret < 0) { 716 dev_err(&pdev->dev, 717 "failed to schedule delayed work for cable detect\n"); 718 goto err_extcon; 719 } 720 721 return ret; 722 723 err_extcon: 724 extcon_dev_unregister(info->edev); 725 return ret; 726 } 727 728 static int max14577_muic_remove(struct platform_device *pdev) 729 { 730 struct max14577_muic_info *info = platform_get_drvdata(pdev); 731 732 cancel_work_sync(&info->irq_work); 733 extcon_dev_unregister(info->edev); 734 735 return 0; 736 } 737 738 static struct platform_driver max14577_muic_driver = { 739 .driver = { 740 .name = DEV_NAME, 741 .owner = THIS_MODULE, 742 }, 743 .probe = max14577_muic_probe, 744 .remove = max14577_muic_remove, 745 }; 746 747 module_platform_driver(max14577_muic_driver); 748 749 MODULE_DESCRIPTION("MAXIM 14577 Extcon driver"); 750 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>"); 751 MODULE_LICENSE("GPL"); 752 MODULE_ALIAS("platform:extcon-max14577"); 753