1// SPDX-License-Identifier: GPL-2.0+ 2// 3// extcon-max77693.c - MAX77693 extcon driver to support MAX77693 MUIC 4// 5// Copyright (C) 2012 Samsung Electrnoics 6// Chanwoo Choi <cw00.choi@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/input.h> 13#include <linux/interrupt.h> 14#include <linux/err.h> 15#include <linux/platform_device.h> 16#include <linux/mfd/max77693.h> 17#include <linux/mfd/max77693-common.h> 18#include <linux/mfd/max77693-private.h> 19#include <linux/extcon-provider.h> 20#include <linux/regmap.h> 21#include <linux/irqdomain.h> 22 23#define DEV_NAME "max77693-muic" 24#define DELAY_MS_DEFAULT 20000 /* unit: millisecond */ 25 26/* 27 * Default value of MAX77693 register to bring up MUIC device. 28 * If user don't set some initial value for MUIC device through platform data, 29 * extcon-max77693 driver use 'default_init_data' to bring up base operation 30 * of MAX77693 MUIC device. 31 */ 32static struct max77693_reg_data default_init_data[] = { 33 { 34 /* STATUS2 - [3]ChgDetRun */ 35 .addr = MAX77693_MUIC_REG_STATUS2, 36 .data = MAX77693_STATUS2_CHGDETRUN_MASK, 37 }, { 38 /* INTMASK1 - Unmask [3]ADC1KM,[0]ADCM */ 39 .addr = MAX77693_MUIC_REG_INTMASK1, 40 .data = INTMASK1_ADC1K_MASK 41 | INTMASK1_ADC_MASK, 42 }, { 43 /* INTMASK2 - Unmask [0]ChgTypM */ 44 .addr = MAX77693_MUIC_REG_INTMASK2, 45 .data = INTMASK2_CHGTYP_MASK, 46 }, { 47 /* INTMASK3 - Mask all of interrupts */ 48 .addr = MAX77693_MUIC_REG_INTMASK3, 49 .data = 0x0, 50 }, { 51 /* CDETCTRL2 */ 52 .addr = MAX77693_MUIC_REG_CDETCTRL2, 53 .data = CDETCTRL2_VIDRMEN_MASK 54 | CDETCTRL2_DXOVPEN_MASK, 55 }, 56}; 57 58enum max77693_muic_adc_debounce_time { 59 ADC_DEBOUNCE_TIME_5MS = 0, 60 ADC_DEBOUNCE_TIME_10MS, 61 ADC_DEBOUNCE_TIME_25MS, 62 ADC_DEBOUNCE_TIME_38_62MS, 63}; 64 65struct max77693_muic_info { 66 struct device *dev; 67 struct max77693_dev *max77693; 68 struct extcon_dev *edev; 69 int prev_cable_type; 70 int prev_cable_type_gnd; 71 int prev_chg_type; 72 int prev_button_type; 73 u8 status[2]; 74 75 int irq; 76 struct work_struct irq_work; 77 struct mutex mutex; 78 79 /* 80 * Use delayed workqueue to detect cable state and then 81 * notify cable state to notifiee/platform through uevent. 82 * After completing the booting of platform, the extcon provider 83 * driver should notify cable state to upper layer. 84 */ 85 struct delayed_work wq_detcable; 86 87 /* Button of dock device */ 88 struct input_dev *dock; 89 90 /* 91 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB 92 * h/w path of COMP2/COMN1 on CONTROL1 register. 93 */ 94 int path_usb; 95 int path_uart; 96}; 97 98enum max77693_muic_cable_group { 99 MAX77693_CABLE_GROUP_ADC = 0, 100 MAX77693_CABLE_GROUP_ADC_GND, 101 MAX77693_CABLE_GROUP_CHG, 102 MAX77693_CABLE_GROUP_VBVOLT, 103}; 104 105enum max77693_muic_charger_type { 106 MAX77693_CHARGER_TYPE_NONE = 0, 107 MAX77693_CHARGER_TYPE_USB, 108 MAX77693_CHARGER_TYPE_DOWNSTREAM_PORT, 109 MAX77693_CHARGER_TYPE_DEDICATED_CHG, 110 MAX77693_CHARGER_TYPE_APPLE_500MA, 111 MAX77693_CHARGER_TYPE_APPLE_1A_2A, 112 MAX77693_CHARGER_TYPE_DEAD_BATTERY = 7, 113}; 114 115/** 116 * struct max77693_muic_irq 117 * @irq: the index of irq list of MUIC device. 118 * @name: the name of irq. 119 * @virq: the virtual irq to use irq domain 120 */ 121struct max77693_muic_irq { 122 unsigned int irq; 123 const char *name; 124 unsigned int virq; 125}; 126 127static struct max77693_muic_irq muic_irqs[] = { 128 { MAX77693_MUIC_IRQ_INT1_ADC, "muic-ADC" }, 129 { MAX77693_MUIC_IRQ_INT1_ADC_LOW, "muic-ADCLOW" }, 130 { MAX77693_MUIC_IRQ_INT1_ADC_ERR, "muic-ADCError" }, 131 { MAX77693_MUIC_IRQ_INT1_ADC1K, "muic-ADC1K" }, 132 { MAX77693_MUIC_IRQ_INT2_CHGTYP, "muic-CHGTYP" }, 133 { MAX77693_MUIC_IRQ_INT2_CHGDETREUN, "muic-CHGDETREUN" }, 134 { MAX77693_MUIC_IRQ_INT2_DCDTMR, "muic-DCDTMR" }, 135 { MAX77693_MUIC_IRQ_INT2_DXOVP, "muic-DXOVP" }, 136 { MAX77693_MUIC_IRQ_INT2_VBVOLT, "muic-VBVOLT" }, 137 { MAX77693_MUIC_IRQ_INT2_VIDRM, "muic-VIDRM" }, 138 { MAX77693_MUIC_IRQ_INT3_EOC, "muic-EOC" }, 139 { MAX77693_MUIC_IRQ_INT3_CGMBC, "muic-CGMBC" }, 140 { MAX77693_MUIC_IRQ_INT3_OVP, "muic-OVP" }, 141 { MAX77693_MUIC_IRQ_INT3_MBCCHG_ERR, "muic-MBCCHG_ERR" }, 142 { MAX77693_MUIC_IRQ_INT3_CHG_ENABLED, "muic-CHG_ENABLED" }, 143 { MAX77693_MUIC_IRQ_INT3_BAT_DET, "muic-BAT_DET" }, 144}; 145 146/* Define supported accessory type */ 147enum max77693_muic_acc_type { 148 MAX77693_MUIC_ADC_GROUND = 0x0, 149 MAX77693_MUIC_ADC_SEND_END_BUTTON, 150 MAX77693_MUIC_ADC_REMOTE_S1_BUTTON, 151 MAX77693_MUIC_ADC_REMOTE_S2_BUTTON, 152 MAX77693_MUIC_ADC_REMOTE_S3_BUTTON, 153 MAX77693_MUIC_ADC_REMOTE_S4_BUTTON, 154 MAX77693_MUIC_ADC_REMOTE_S5_BUTTON, 155 MAX77693_MUIC_ADC_REMOTE_S6_BUTTON, 156 MAX77693_MUIC_ADC_REMOTE_S7_BUTTON, 157 MAX77693_MUIC_ADC_REMOTE_S8_BUTTON, 158 MAX77693_MUIC_ADC_REMOTE_S9_BUTTON, 159 MAX77693_MUIC_ADC_REMOTE_S10_BUTTON, 160 MAX77693_MUIC_ADC_REMOTE_S11_BUTTON, 161 MAX77693_MUIC_ADC_REMOTE_S12_BUTTON, 162 MAX77693_MUIC_ADC_RESERVED_ACC_1, 163 MAX77693_MUIC_ADC_RESERVED_ACC_2, 164 MAX77693_MUIC_ADC_RESERVED_ACC_3, 165 MAX77693_MUIC_ADC_RESERVED_ACC_4, 166 MAX77693_MUIC_ADC_RESERVED_ACC_5, 167 MAX77693_MUIC_ADC_CEA936_AUDIO, 168 MAX77693_MUIC_ADC_PHONE_POWERED_DEV, 169 MAX77693_MUIC_ADC_TTY_CONVERTER, 170 MAX77693_MUIC_ADC_UART_CABLE, 171 MAX77693_MUIC_ADC_CEA936A_TYPE1_CHG, 172 MAX77693_MUIC_ADC_FACTORY_MODE_USB_OFF, 173 MAX77693_MUIC_ADC_FACTORY_MODE_USB_ON, 174 MAX77693_MUIC_ADC_AV_CABLE_NOLOAD, 175 MAX77693_MUIC_ADC_CEA936A_TYPE2_CHG, 176 MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF, 177 MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON, 178 MAX77693_MUIC_ADC_AUDIO_MODE_REMOTE, 179 MAX77693_MUIC_ADC_OPEN, 180 181 /* 182 * The below accessories have same ADC value so ADCLow and 183 * ADC1K bit is used to separate specific accessory. 184 */ 185 /* ADC|VBVolot|ADCLow|ADC1K| */ 186 MAX77693_MUIC_GND_USB_HOST = 0x100, /* 0x0| 0| 0| 0| */ 187 MAX77693_MUIC_GND_USB_HOST_VB = 0x104, /* 0x0| 1| 0| 0| */ 188 MAX77693_MUIC_GND_AV_CABLE_LOAD = 0x102,/* 0x0| 0| 1| 0| */ 189 MAX77693_MUIC_GND_MHL = 0x103, /* 0x0| 0| 1| 1| */ 190 MAX77693_MUIC_GND_MHL_VB = 0x107, /* 0x0| 1| 1| 1| */ 191}; 192 193/* 194 * MAX77693 MUIC device support below list of accessories(external connector) 195 */ 196static const unsigned int max77693_extcon_cable[] = { 197 EXTCON_USB, 198 EXTCON_USB_HOST, 199 EXTCON_CHG_USB_SDP, 200 EXTCON_CHG_USB_DCP, 201 EXTCON_CHG_USB_FAST, 202 EXTCON_CHG_USB_SLOW, 203 EXTCON_CHG_USB_CDP, 204 EXTCON_DISP_MHL, 205 EXTCON_JIG, 206 EXTCON_DOCK, 207 EXTCON_NONE, 208}; 209 210/* 211 * max77693_muic_set_debounce_time - Set the debounce time of ADC 212 * @info: the instance including private data of max77693 MUIC 213 * @time: the debounce time of ADC 214 */ 215static int max77693_muic_set_debounce_time(struct max77693_muic_info *info, 216 enum max77693_muic_adc_debounce_time time) 217{ 218 int ret; 219 220 switch (time) { 221 case ADC_DEBOUNCE_TIME_5MS: 222 case ADC_DEBOUNCE_TIME_10MS: 223 case ADC_DEBOUNCE_TIME_25MS: 224 case ADC_DEBOUNCE_TIME_38_62MS: 225 /* 226 * Don't touch BTLDset, JIGset when you want to change adc 227 * debounce time. If it writes other than 0 to BTLDset, JIGset 228 * muic device will be reset and loose current state. 229 */ 230 ret = regmap_write(info->max77693->regmap_muic, 231 MAX77693_MUIC_REG_CTRL3, 232 time << MAX77693_CONTROL3_ADCDBSET_SHIFT); 233 if (ret) { 234 dev_err(info->dev, "failed to set ADC debounce time\n"); 235 return ret; 236 } 237 break; 238 default: 239 dev_err(info->dev, "invalid ADC debounce time\n"); 240 return -EINVAL; 241 } 242 243 return 0; 244}; 245 246/* 247 * max77693_muic_set_path - Set hardware line according to attached cable 248 * @info: the instance including private data of max77693 MUIC 249 * @value: the path according to attached cable 250 * @attached: the state of cable (true:attached, false:detached) 251 * 252 * The max77693 MUIC device share outside H/W line among a varity of cables 253 * so, this function set internal path of H/W line according to the type of 254 * attached cable. 255 */ 256static int max77693_muic_set_path(struct max77693_muic_info *info, 257 u8 val, bool attached) 258{ 259 int ret; 260 unsigned int ctrl1, ctrl2 = 0; 261 262 if (attached) 263 ctrl1 = val; 264 else 265 ctrl1 = MAX77693_CONTROL1_SW_OPEN; 266 267 ret = regmap_update_bits(info->max77693->regmap_muic, 268 MAX77693_MUIC_REG_CTRL1, COMP_SW_MASK, ctrl1); 269 if (ret < 0) { 270 dev_err(info->dev, "failed to update MUIC register\n"); 271 return ret; 272 } 273 274 if (attached) 275 ctrl2 |= MAX77693_CONTROL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */ 276 else 277 ctrl2 |= MAX77693_CONTROL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */ 278 279 ret = regmap_update_bits(info->max77693->regmap_muic, 280 MAX77693_MUIC_REG_CTRL2, 281 MAX77693_CONTROL2_LOWPWR_MASK | MAX77693_CONTROL2_CPEN_MASK, 282 ctrl2); 283 if (ret < 0) { 284 dev_err(info->dev, "failed to update MUIC register\n"); 285 return ret; 286 } 287 288 dev_info(info->dev, 289 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n", 290 ctrl1, ctrl2, attached ? "attached" : "detached"); 291 292 return 0; 293} 294 295/* 296 * max77693_muic_get_cable_type - Return cable type and check cable state 297 * @info: the instance including private data of max77693 MUIC 298 * @group: the path according to attached cable 299 * @attached: store cable state and return 300 * 301 * This function check the cable state either attached or detached, 302 * and then divide precise type of cable according to cable group. 303 * - MAX77693_CABLE_GROUP_ADC 304 * - MAX77693_CABLE_GROUP_ADC_GND 305 * - MAX77693_CABLE_GROUP_CHG 306 * - MAX77693_CABLE_GROUP_VBVOLT 307 */ 308static int max77693_muic_get_cable_type(struct max77693_muic_info *info, 309 enum max77693_muic_cable_group group, bool *attached) 310{ 311 int cable_type = 0; 312 int adc; 313 int adc1k; 314 int adclow; 315 int vbvolt; 316 int chg_type; 317 318 switch (group) { 319 case MAX77693_CABLE_GROUP_ADC: 320 /* 321 * Read ADC value to check cable type and decide cable state 322 * according to cable type 323 */ 324 adc = info->status[0] & MAX77693_STATUS1_ADC_MASK; 325 adc >>= MAX77693_STATUS1_ADC_SHIFT; 326 327 /* 328 * Check current cable state/cable type and store cable type 329 * (info->prev_cable_type) for handling cable when cable is 330 * detached. 331 */ 332 if (adc == MAX77693_MUIC_ADC_OPEN) { 333 *attached = false; 334 335 cable_type = info->prev_cable_type; 336 info->prev_cable_type = MAX77693_MUIC_ADC_OPEN; 337 } else { 338 *attached = true; 339 340 cable_type = info->prev_cable_type = adc; 341 } 342 break; 343 case MAX77693_CABLE_GROUP_ADC_GND: 344 /* 345 * Read ADC value to check cable type and decide cable state 346 * according to cable type 347 */ 348 adc = info->status[0] & MAX77693_STATUS1_ADC_MASK; 349 adc >>= MAX77693_STATUS1_ADC_SHIFT; 350 351 /* 352 * Check current cable state/cable type and store cable type 353 * (info->prev_cable_type/_gnd) for handling cable when cable 354 * is detached. 355 */ 356 if (adc == MAX77693_MUIC_ADC_OPEN) { 357 *attached = false; 358 359 cable_type = info->prev_cable_type_gnd; 360 info->prev_cable_type_gnd = MAX77693_MUIC_ADC_OPEN; 361 } else { 362 *attached = true; 363 364 adclow = info->status[0] & MAX77693_STATUS1_ADCLOW_MASK; 365 adclow >>= MAX77693_STATUS1_ADCLOW_SHIFT; 366 adc1k = info->status[0] & MAX77693_STATUS1_ADC1K_MASK; 367 adc1k >>= MAX77693_STATUS1_ADC1K_SHIFT; 368 369 vbvolt = info->status[1] & MAX77693_STATUS2_VBVOLT_MASK; 370 vbvolt >>= MAX77693_STATUS2_VBVOLT_SHIFT; 371 372 /** 373 * [0x1|VBVolt|ADCLow|ADC1K] 374 * [0x1| 0| 0| 0] USB_HOST 375 * [0x1| 1| 0| 0] USB_HSOT_VB 376 * [0x1| 0| 1| 0] Audio Video cable with load 377 * [0x1| 0| 1| 1] MHL without charging cable 378 * [0x1| 1| 1| 1] MHL with charging cable 379 */ 380 cable_type = ((0x1 << 8) 381 | (vbvolt << 2) 382 | (adclow << 1) 383 | adc1k); 384 385 info->prev_cable_type = adc; 386 info->prev_cable_type_gnd = cable_type; 387 } 388 389 break; 390 case MAX77693_CABLE_GROUP_CHG: 391 /* 392 * Read charger type to check cable type and decide cable state 393 * according to type of charger cable. 394 */ 395 chg_type = info->status[1] & MAX77693_STATUS2_CHGTYP_MASK; 396 chg_type >>= MAX77693_STATUS2_CHGTYP_SHIFT; 397 398 if (chg_type == MAX77693_CHARGER_TYPE_NONE) { 399 *attached = false; 400 401 cable_type = info->prev_chg_type; 402 info->prev_chg_type = MAX77693_CHARGER_TYPE_NONE; 403 } else { 404 *attached = true; 405 406 /* 407 * Check current cable state/cable type and store cable 408 * type(info->prev_chg_type) for handling cable when 409 * charger cable is detached. 410 */ 411 cable_type = info->prev_chg_type = chg_type; 412 } 413 414 break; 415 case MAX77693_CABLE_GROUP_VBVOLT: 416 /* 417 * Read ADC value to check cable type and decide cable state 418 * according to cable type 419 */ 420 adc = info->status[0] & MAX77693_STATUS1_ADC_MASK; 421 adc >>= MAX77693_STATUS1_ADC_SHIFT; 422 chg_type = info->status[1] & MAX77693_STATUS2_CHGTYP_MASK; 423 chg_type >>= MAX77693_STATUS2_CHGTYP_SHIFT; 424 425 if (adc == MAX77693_MUIC_ADC_OPEN 426 && chg_type == MAX77693_CHARGER_TYPE_NONE) 427 *attached = false; 428 else 429 *attached = true; 430 431 /* 432 * Read vbvolt field, if vbvolt is 1, 433 * this cable is used for charging. 434 */ 435 vbvolt = info->status[1] & MAX77693_STATUS2_VBVOLT_MASK; 436 vbvolt >>= MAX77693_STATUS2_VBVOLT_SHIFT; 437 438 cable_type = vbvolt; 439 break; 440 default: 441 dev_err(info->dev, "Unknown cable group (%d)\n", group); 442 cable_type = -EINVAL; 443 break; 444 } 445 446 return cable_type; 447} 448 449static int max77693_muic_dock_handler(struct max77693_muic_info *info, 450 int cable_type, bool attached) 451{ 452 int ret = 0; 453 int vbvolt; 454 bool cable_attached; 455 unsigned int dock_id; 456 457 dev_info(info->dev, 458 "external connector is %s (adc:0x%02x)\n", 459 attached ? "attached" : "detached", cable_type); 460 461 switch (cable_type) { 462 case MAX77693_MUIC_ADC_RESERVED_ACC_3: /* Dock-Smart */ 463 /* 464 * Check power cable whether attached or detached state. 465 * The Dock-Smart device need surely external power supply. 466 * If power cable(USB/TA) isn't connected to Dock device, 467 * user can't use Dock-Smart for desktop mode. 468 */ 469 vbvolt = max77693_muic_get_cable_type(info, 470 MAX77693_CABLE_GROUP_VBVOLT, &cable_attached); 471 if (attached && !vbvolt) { 472 dev_warn(info->dev, 473 "Cannot detect external power supply\n"); 474 return 0; 475 } 476 477 /* 478 * Notify Dock/MHL state. 479 * - Dock device include three type of cable which 480 * are HDMI, USB for mouse/keyboard and micro-usb port 481 * for USB/TA cable. Dock device need always exteranl 482 * power supply(USB/TA cable through micro-usb cable). Dock 483 * device support screen output of target to separate 484 * monitor and mouse/keyboard for desktop mode. 485 * 486 * Features of 'USB/TA cable with Dock device' 487 * - Support MHL 488 * - Support external output feature of audio 489 * - Support charging through micro-usb port without data 490 * connection if TA cable is connected to target. 491 * - Support charging and data connection through micro-usb port 492 * if USB cable is connected between target and host 493 * device. 494 * - Support OTG(On-The-Go) device (Ex: Mouse/Keyboard) 495 */ 496 ret = max77693_muic_set_path(info, info->path_usb, attached); 497 if (ret < 0) 498 return ret; 499 500 extcon_set_state_sync(info->edev, EXTCON_DOCK, attached); 501 extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, attached); 502 goto out; 503 case MAX77693_MUIC_ADC_AUDIO_MODE_REMOTE: /* Dock-Desk */ 504 dock_id = EXTCON_DOCK; 505 break; 506 case MAX77693_MUIC_ADC_AV_CABLE_NOLOAD: /* Dock-Audio */ 507 dock_id = EXTCON_DOCK; 508 if (!attached) { 509 extcon_set_state_sync(info->edev, EXTCON_USB, false); 510 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, 511 false); 512 } 513 break; 514 default: 515 dev_err(info->dev, "failed to detect %s dock device\n", 516 attached ? "attached" : "detached"); 517 return -EINVAL; 518 } 519 520 /* Dock-Car/Desk/Audio, PATH:AUDIO */ 521 ret = max77693_muic_set_path(info, MAX77693_CONTROL1_SW_AUDIO, 522 attached); 523 if (ret < 0) 524 return ret; 525 extcon_set_state_sync(info->edev, dock_id, attached); 526 527out: 528 return 0; 529} 530 531static int max77693_muic_dock_button_handler(struct max77693_muic_info *info, 532 int button_type, bool attached) 533{ 534 struct input_dev *dock = info->dock; 535 unsigned int code; 536 537 switch (button_type) { 538 case MAX77693_MUIC_ADC_REMOTE_S3_BUTTON-1 539 ... MAX77693_MUIC_ADC_REMOTE_S3_BUTTON+1: 540 /* DOCK_KEY_PREV */ 541 code = KEY_PREVIOUSSONG; 542 break; 543 case MAX77693_MUIC_ADC_REMOTE_S7_BUTTON-1 544 ... MAX77693_MUIC_ADC_REMOTE_S7_BUTTON+1: 545 /* DOCK_KEY_NEXT */ 546 code = KEY_NEXTSONG; 547 break; 548 case MAX77693_MUIC_ADC_REMOTE_S9_BUTTON: 549 /* DOCK_VOL_DOWN */ 550 code = KEY_VOLUMEDOWN; 551 break; 552 case MAX77693_MUIC_ADC_REMOTE_S10_BUTTON: 553 /* DOCK_VOL_UP */ 554 code = KEY_VOLUMEUP; 555 break; 556 case MAX77693_MUIC_ADC_REMOTE_S12_BUTTON-1 557 ... MAX77693_MUIC_ADC_REMOTE_S12_BUTTON+1: 558 /* DOCK_KEY_PLAY_PAUSE */ 559 code = KEY_PLAYPAUSE; 560 break; 561 default: 562 dev_err(info->dev, 563 "failed to detect %s key (adc:0x%x)\n", 564 attached ? "pressed" : "released", button_type); 565 return -EINVAL; 566 } 567 568 input_event(dock, EV_KEY, code, attached); 569 input_sync(dock); 570 571 return 0; 572} 573 574static int max77693_muic_adc_ground_handler(struct max77693_muic_info *info) 575{ 576 int cable_type_gnd; 577 int ret = 0; 578 bool attached; 579 580 cable_type_gnd = max77693_muic_get_cable_type(info, 581 MAX77693_CABLE_GROUP_ADC_GND, &attached); 582 583 switch (cable_type_gnd) { 584 case MAX77693_MUIC_GND_USB_HOST: 585 case MAX77693_MUIC_GND_USB_HOST_VB: 586 /* USB_HOST, PATH: AP_USB */ 587 ret = max77693_muic_set_path(info, MAX77693_CONTROL1_SW_USB, 588 attached); 589 if (ret < 0) 590 return ret; 591 extcon_set_state_sync(info->edev, EXTCON_USB_HOST, attached); 592 break; 593 case MAX77693_MUIC_GND_AV_CABLE_LOAD: 594 /* Audio Video Cable with load, PATH:AUDIO */ 595 ret = max77693_muic_set_path(info, MAX77693_CONTROL1_SW_AUDIO, 596 attached); 597 if (ret < 0) 598 return ret; 599 extcon_set_state_sync(info->edev, EXTCON_USB, attached); 600 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, 601 attached); 602 break; 603 case MAX77693_MUIC_GND_MHL: 604 case MAX77693_MUIC_GND_MHL_VB: 605 /* MHL or MHL with USB/TA cable */ 606 extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, attached); 607 break; 608 default: 609 dev_err(info->dev, "failed to detect %s cable of gnd type\n", 610 attached ? "attached" : "detached"); 611 return -EINVAL; 612 } 613 614 return 0; 615} 616 617static int max77693_muic_jig_handler(struct max77693_muic_info *info, 618 int cable_type, bool attached) 619{ 620 int ret = 0; 621 u8 path = MAX77693_CONTROL1_SW_OPEN; 622 623 dev_info(info->dev, 624 "external connector is %s (adc:0x%02x)\n", 625 attached ? "attached" : "detached", cable_type); 626 627 switch (cable_type) { 628 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_OFF: /* ADC_JIG_USB_OFF */ 629 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_ON: /* ADC_JIG_USB_ON */ 630 /* PATH:AP_USB */ 631 path = MAX77693_CONTROL1_SW_USB; 632 break; 633 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF: /* ADC_JIG_UART_OFF */ 634 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON: /* ADC_JIG_UART_ON */ 635 /* PATH:AP_UART */ 636 path = MAX77693_CONTROL1_SW_UART; 637 break; 638 default: 639 dev_err(info->dev, "failed to detect %s jig cable\n", 640 attached ? "attached" : "detached"); 641 return -EINVAL; 642 } 643 644 ret = max77693_muic_set_path(info, path, attached); 645 if (ret < 0) 646 return ret; 647 648 extcon_set_state_sync(info->edev, EXTCON_JIG, attached); 649 650 return 0; 651} 652 653static int max77693_muic_adc_handler(struct max77693_muic_info *info) 654{ 655 int cable_type; 656 int button_type; 657 bool attached; 658 int ret = 0; 659 660 /* Check accessory state which is either detached or attached */ 661 cable_type = max77693_muic_get_cable_type(info, 662 MAX77693_CABLE_GROUP_ADC, &attached); 663 664 dev_info(info->dev, 665 "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n", 666 attached ? "attached" : "detached", cable_type, 667 info->prev_cable_type); 668 669 switch (cable_type) { 670 case MAX77693_MUIC_ADC_GROUND: 671 /* USB_HOST/MHL/Audio */ 672 max77693_muic_adc_ground_handler(info); 673 break; 674 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_OFF: 675 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_ON: 676 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF: 677 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON: 678 /* JIG */ 679 ret = max77693_muic_jig_handler(info, cable_type, attached); 680 if (ret < 0) 681 return ret; 682 break; 683 case MAX77693_MUIC_ADC_RESERVED_ACC_3: /* Dock-Smart */ 684 case MAX77693_MUIC_ADC_AUDIO_MODE_REMOTE: /* Dock-Desk */ 685 case MAX77693_MUIC_ADC_AV_CABLE_NOLOAD: /* Dock-Audio */ 686 /* 687 * DOCK device 688 * 689 * The MAX77693 MUIC device can detect total 34 cable type 690 * except of charger cable and MUIC device didn't define 691 * specfic role of cable in the range of from 0x01 to 0x12 692 * of ADC value. So, can use/define cable with no role according 693 * to schema of hardware board. 694 */ 695 ret = max77693_muic_dock_handler(info, cable_type, attached); 696 if (ret < 0) 697 return ret; 698 break; 699 case MAX77693_MUIC_ADC_REMOTE_S3_BUTTON: /* DOCK_KEY_PREV */ 700 case MAX77693_MUIC_ADC_REMOTE_S7_BUTTON: /* DOCK_KEY_NEXT */ 701 case MAX77693_MUIC_ADC_REMOTE_S9_BUTTON: /* DOCK_VOL_DOWN */ 702 case MAX77693_MUIC_ADC_REMOTE_S10_BUTTON: /* DOCK_VOL_UP */ 703 case MAX77693_MUIC_ADC_REMOTE_S12_BUTTON: /* DOCK_KEY_PLAY_PAUSE */ 704 /* 705 * Button of DOCK device 706 * - the Prev/Next/Volume Up/Volume Down/Play-Pause button 707 * 708 * The MAX77693 MUIC device can detect total 34 cable type 709 * except of charger cable and MUIC device didn't define 710 * specfic role of cable in the range of from 0x01 to 0x12 711 * of ADC value. So, can use/define cable with no role according 712 * to schema of hardware board. 713 */ 714 if (attached) 715 button_type = info->prev_button_type = cable_type; 716 else 717 button_type = info->prev_button_type; 718 719 ret = max77693_muic_dock_button_handler(info, button_type, 720 attached); 721 if (ret < 0) 722 return ret; 723 break; 724 case MAX77693_MUIC_ADC_SEND_END_BUTTON: 725 case MAX77693_MUIC_ADC_REMOTE_S1_BUTTON: 726 case MAX77693_MUIC_ADC_REMOTE_S2_BUTTON: 727 case MAX77693_MUIC_ADC_REMOTE_S4_BUTTON: 728 case MAX77693_MUIC_ADC_REMOTE_S5_BUTTON: 729 case MAX77693_MUIC_ADC_REMOTE_S6_BUTTON: 730 case MAX77693_MUIC_ADC_REMOTE_S8_BUTTON: 731 case MAX77693_MUIC_ADC_REMOTE_S11_BUTTON: 732 case MAX77693_MUIC_ADC_RESERVED_ACC_1: 733 case MAX77693_MUIC_ADC_RESERVED_ACC_2: 734 case MAX77693_MUIC_ADC_RESERVED_ACC_4: 735 case MAX77693_MUIC_ADC_RESERVED_ACC_5: 736 case MAX77693_MUIC_ADC_CEA936_AUDIO: 737 case MAX77693_MUIC_ADC_PHONE_POWERED_DEV: 738 case MAX77693_MUIC_ADC_TTY_CONVERTER: 739 case MAX77693_MUIC_ADC_UART_CABLE: 740 case MAX77693_MUIC_ADC_CEA936A_TYPE1_CHG: 741 case MAX77693_MUIC_ADC_CEA936A_TYPE2_CHG: 742 /* 743 * This accessory isn't used in general case if it is specially 744 * needed to detect additional accessory, should implement 745 * proper operation when this accessory is attached/detached. 746 */ 747 dev_info(info->dev, 748 "accessory is %s but it isn't used (adc:0x%x)\n", 749 attached ? "attached" : "detached", cable_type); 750 return -EAGAIN; 751 default: 752 dev_err(info->dev, 753 "failed to detect %s accessory (adc:0x%x)\n", 754 attached ? "attached" : "detached", cable_type); 755 return -EINVAL; 756 } 757 758 return 0; 759} 760 761static int max77693_muic_chg_handler(struct max77693_muic_info *info) 762{ 763 int chg_type; 764 int cable_type_gnd; 765 int cable_type; 766 bool attached; 767 bool cable_attached; 768 int ret = 0; 769 770 chg_type = max77693_muic_get_cable_type(info, 771 MAX77693_CABLE_GROUP_CHG, &attached); 772 773 dev_info(info->dev, 774 "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n", 775 attached ? "attached" : "detached", 776 chg_type, info->prev_chg_type); 777 778 switch (chg_type) { 779 case MAX77693_CHARGER_TYPE_USB: 780 case MAX77693_CHARGER_TYPE_DEDICATED_CHG: 781 case MAX77693_CHARGER_TYPE_NONE: 782 /* Check MAX77693_CABLE_GROUP_ADC_GND type */ 783 cable_type_gnd = max77693_muic_get_cable_type(info, 784 MAX77693_CABLE_GROUP_ADC_GND, 785 &cable_attached); 786 switch (cable_type_gnd) { 787 case MAX77693_MUIC_GND_MHL: 788 case MAX77693_MUIC_GND_MHL_VB: 789 /* 790 * MHL cable with USB/TA cable 791 * - MHL cable include two port(HDMI line and separate 792 * micro-usb port. When the target connect MHL cable, 793 * extcon driver check whether USB/TA cable is 794 * connected. If USB/TA cable is connected, extcon 795 * driver notify state to notifiee for charging battery. 796 * 797 * Features of 'USB/TA with MHL cable' 798 * - Support MHL 799 * - Support charging through micro-usb port without 800 * data connection 801 */ 802 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP, 803 attached); 804 extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, 805 cable_attached); 806 break; 807 } 808 809 /* Check MAX77693_CABLE_GROUP_ADC type */ 810 cable_type = max77693_muic_get_cable_type(info, 811 MAX77693_CABLE_GROUP_ADC, 812 &cable_attached); 813 switch (cable_type) { 814 case MAX77693_MUIC_ADC_AV_CABLE_NOLOAD: /* Dock-Audio */ 815 /* 816 * Dock-Audio device with USB/TA cable 817 * - Dock device include two port(Dock-Audio and micro- 818 * usb port). When the target connect Dock-Audio device, 819 * extcon driver check whether USB/TA cable is connected 820 * or not. If USB/TA cable is connected, extcon driver 821 * notify state to notifiee for charging battery. 822 * 823 * Features of 'USB/TA cable with Dock-Audio device' 824 * - Support external output feature of audio. 825 * - Support charging through micro-usb port without 826 * data connection. 827 */ 828 extcon_set_state_sync(info->edev, EXTCON_USB, 829 attached); 830 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, 831 attached); 832 833 if (!cable_attached) 834 extcon_set_state_sync(info->edev, EXTCON_DOCK, 835 cable_attached); 836 break; 837 case MAX77693_MUIC_ADC_RESERVED_ACC_3: /* Dock-Smart */ 838 /* 839 * Dock-Smart device with USB/TA cable 840 * - Dock-Desk device include three type of cable which 841 * are HDMI, USB for mouse/keyboard and micro-usb port 842 * for USB/TA cable. Dock-Smart device need always 843 * exteranl power supply(USB/TA cable through micro-usb 844 * cable). Dock-Smart device support screen output of 845 * target to separate monitor and mouse/keyboard for 846 * desktop mode. 847 * 848 * Features of 'USB/TA cable with Dock-Smart device' 849 * - Support MHL 850 * - Support external output feature of audio 851 * - Support charging through micro-usb port without 852 * data connection if TA cable is connected to target. 853 * - Support charging and data connection through micro- 854 * usb port if USB cable is connected between target 855 * and host device 856 * - Support OTG(On-The-Go) device (Ex: Mouse/Keyboard) 857 */ 858 ret = max77693_muic_set_path(info, info->path_usb, 859 attached); 860 if (ret < 0) 861 return ret; 862 863 extcon_set_state_sync(info->edev, EXTCON_DOCK, 864 attached); 865 extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, 866 attached); 867 break; 868 } 869 870 /* Check MAX77693_CABLE_GROUP_CHG type */ 871 switch (chg_type) { 872 case MAX77693_CHARGER_TYPE_NONE: 873 /* 874 * When MHL(with USB/TA cable) or Dock-Audio with USB/TA 875 * cable is attached, muic device happen below two irq. 876 * - 'MAX77693_MUIC_IRQ_INT1_ADC' for detecting 877 * MHL/Dock-Audio. 878 * - 'MAX77693_MUIC_IRQ_INT2_CHGTYP' for detecting 879 * USB/TA cable connected to MHL or Dock-Audio. 880 * Always, happen eariler MAX77693_MUIC_IRQ_INT1_ADC 881 * irq than MAX77693_MUIC_IRQ_INT2_CHGTYP irq. 882 * 883 * If user attach MHL (with USB/TA cable and immediately 884 * detach MHL with USB/TA cable before MAX77693_MUIC_IRQ 885 * _INT2_CHGTYP irq is happened, USB/TA cable remain 886 * connected state to target. But USB/TA cable isn't 887 * connected to target. The user be face with unusual 888 * action. So, driver should check this situation in 889 * spite of, that previous charger type is N/A. 890 */ 891 break; 892 case MAX77693_CHARGER_TYPE_USB: 893 /* Only USB cable, PATH:AP_USB */ 894 ret = max77693_muic_set_path(info, info->path_usb, 895 attached); 896 if (ret < 0) 897 return ret; 898 899 extcon_set_state_sync(info->edev, EXTCON_USB, 900 attached); 901 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP, 902 attached); 903 break; 904 case MAX77693_CHARGER_TYPE_DEDICATED_CHG: 905 /* Only TA cable */ 906 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP, 907 attached); 908 break; 909 } 910 break; 911 case MAX77693_CHARGER_TYPE_DOWNSTREAM_PORT: 912 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP, 913 attached); 914 break; 915 case MAX77693_CHARGER_TYPE_APPLE_500MA: 916 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW, 917 attached); 918 break; 919 case MAX77693_CHARGER_TYPE_APPLE_1A_2A: 920 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST, 921 attached); 922 break; 923 case MAX77693_CHARGER_TYPE_DEAD_BATTERY: 924 break; 925 default: 926 dev_err(info->dev, 927 "failed to detect %s accessory (chg_type:0x%x)\n", 928 attached ? "attached" : "detached", chg_type); 929 return -EINVAL; 930 } 931 932 return 0; 933} 934 935static void max77693_muic_irq_work(struct work_struct *work) 936{ 937 struct max77693_muic_info *info = container_of(work, 938 struct max77693_muic_info, irq_work); 939 int irq_type = -1; 940 int i, ret = 0; 941 942 if (!info->edev) 943 return; 944 945 mutex_lock(&info->mutex); 946 947 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) 948 if (info->irq == muic_irqs[i].virq) 949 irq_type = muic_irqs[i].irq; 950 951 ret = regmap_bulk_read(info->max77693->regmap_muic, 952 MAX77693_MUIC_REG_STATUS1, info->status, 2); 953 if (ret) { 954 dev_err(info->dev, "failed to read MUIC register\n"); 955 mutex_unlock(&info->mutex); 956 return; 957 } 958 959 switch (irq_type) { 960 case MAX77693_MUIC_IRQ_INT1_ADC: 961 case MAX77693_MUIC_IRQ_INT1_ADC_LOW: 962 case MAX77693_MUIC_IRQ_INT1_ADC_ERR: 963 case MAX77693_MUIC_IRQ_INT1_ADC1K: 964 /* 965 * Handle all of accessory except for 966 * type of charger accessory. 967 */ 968 ret = max77693_muic_adc_handler(info); 969 break; 970 case MAX77693_MUIC_IRQ_INT2_CHGTYP: 971 case MAX77693_MUIC_IRQ_INT2_CHGDETREUN: 972 case MAX77693_MUIC_IRQ_INT2_DCDTMR: 973 case MAX77693_MUIC_IRQ_INT2_DXOVP: 974 case MAX77693_MUIC_IRQ_INT2_VBVOLT: 975 case MAX77693_MUIC_IRQ_INT2_VIDRM: 976 /* Handle charger accessory */ 977 ret = max77693_muic_chg_handler(info); 978 break; 979 case MAX77693_MUIC_IRQ_INT3_EOC: 980 case MAX77693_MUIC_IRQ_INT3_CGMBC: 981 case MAX77693_MUIC_IRQ_INT3_OVP: 982 case MAX77693_MUIC_IRQ_INT3_MBCCHG_ERR: 983 case MAX77693_MUIC_IRQ_INT3_CHG_ENABLED: 984 case MAX77693_MUIC_IRQ_INT3_BAT_DET: 985 break; 986 default: 987 dev_err(info->dev, "muic interrupt: irq %d occurred\n", 988 irq_type); 989 mutex_unlock(&info->mutex); 990 return; 991 } 992 993 if (ret < 0) 994 dev_err(info->dev, "failed to handle MUIC interrupt\n"); 995 996 mutex_unlock(&info->mutex); 997} 998 999static irqreturn_t max77693_muic_irq_handler(int irq, void *data) 1000{ 1001 struct max77693_muic_info *info = data; 1002 1003 info->irq = irq; 1004 schedule_work(&info->irq_work); 1005 1006 return IRQ_HANDLED; 1007} 1008 1009static const struct regmap_config max77693_muic_regmap_config = { 1010 .reg_bits = 8, 1011 .val_bits = 8, 1012}; 1013 1014static int max77693_muic_detect_accessory(struct max77693_muic_info *info) 1015{ 1016 int ret = 0; 1017 int adc; 1018 int chg_type; 1019 bool attached; 1020 1021 mutex_lock(&info->mutex); 1022 1023 /* Read STATUSx register to detect accessory */ 1024 ret = regmap_bulk_read(info->max77693->regmap_muic, 1025 MAX77693_MUIC_REG_STATUS1, info->status, 2); 1026 if (ret) { 1027 dev_err(info->dev, "failed to read MUIC register\n"); 1028 mutex_unlock(&info->mutex); 1029 return ret; 1030 } 1031 1032 adc = max77693_muic_get_cable_type(info, MAX77693_CABLE_GROUP_ADC, 1033 &attached); 1034 if (attached && adc != MAX77693_MUIC_ADC_OPEN) { 1035 ret = max77693_muic_adc_handler(info); 1036 if (ret < 0) { 1037 dev_err(info->dev, "Cannot detect accessory\n"); 1038 mutex_unlock(&info->mutex); 1039 return ret; 1040 } 1041 } 1042 1043 chg_type = max77693_muic_get_cable_type(info, MAX77693_CABLE_GROUP_CHG, 1044 &attached); 1045 if (attached && chg_type != MAX77693_CHARGER_TYPE_NONE) { 1046 ret = max77693_muic_chg_handler(info); 1047 if (ret < 0) { 1048 dev_err(info->dev, "Cannot detect charger accessory\n"); 1049 mutex_unlock(&info->mutex); 1050 return ret; 1051 } 1052 } 1053 1054 mutex_unlock(&info->mutex); 1055 1056 return 0; 1057} 1058 1059static void max77693_muic_detect_cable_wq(struct work_struct *work) 1060{ 1061 struct max77693_muic_info *info = container_of(to_delayed_work(work), 1062 struct max77693_muic_info, wq_detcable); 1063 1064 max77693_muic_detect_accessory(info); 1065} 1066 1067static int max77693_muic_probe(struct platform_device *pdev) 1068{ 1069 struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent); 1070 struct max77693_platform_data *pdata = dev_get_platdata(max77693->dev); 1071 struct max77693_muic_info *info; 1072 struct max77693_reg_data *init_data; 1073 int num_init_data; 1074 int delay_jiffies; 1075 int cable_type; 1076 bool attached; 1077 int ret; 1078 int i; 1079 unsigned int id; 1080 1081 info = devm_kzalloc(&pdev->dev, sizeof(struct max77693_muic_info), 1082 GFP_KERNEL); 1083 if (!info) 1084 return -ENOMEM; 1085 1086 info->dev = &pdev->dev; 1087 info->max77693 = max77693; 1088 if (info->max77693->regmap_muic) { 1089 dev_dbg(&pdev->dev, "allocate register map\n"); 1090 } else { 1091 info->max77693->regmap_muic = devm_regmap_init_i2c( 1092 info->max77693->i2c_muic, 1093 &max77693_muic_regmap_config); 1094 if (IS_ERR(info->max77693->regmap_muic)) { 1095 ret = PTR_ERR(info->max77693->regmap_muic); 1096 dev_err(max77693->dev, 1097 "failed to allocate register map: %d\n", ret); 1098 return ret; 1099 } 1100 } 1101 1102 /* Register input device for button of dock device */ 1103 info->dock = devm_input_allocate_device(&pdev->dev); 1104 if (!info->dock) { 1105 dev_err(&pdev->dev, "%s: failed to allocate input\n", __func__); 1106 return -ENOMEM; 1107 } 1108 info->dock->name = "max77693-muic/dock"; 1109 info->dock->phys = "max77693-muic/extcon"; 1110 info->dock->dev.parent = &pdev->dev; 1111 1112 __set_bit(EV_REP, info->dock->evbit); 1113 1114 input_set_capability(info->dock, EV_KEY, KEY_VOLUMEUP); 1115 input_set_capability(info->dock, EV_KEY, KEY_VOLUMEDOWN); 1116 input_set_capability(info->dock, EV_KEY, KEY_PLAYPAUSE); 1117 input_set_capability(info->dock, EV_KEY, KEY_PREVIOUSSONG); 1118 input_set_capability(info->dock, EV_KEY, KEY_NEXTSONG); 1119 1120 ret = input_register_device(info->dock); 1121 if (ret < 0) { 1122 dev_err(&pdev->dev, "Cannot register input device error(%d)\n", 1123 ret); 1124 return ret; 1125 } 1126 1127 platform_set_drvdata(pdev, info); 1128 mutex_init(&info->mutex); 1129 1130 INIT_WORK(&info->irq_work, max77693_muic_irq_work); 1131 1132 /* Support irq domain for MAX77693 MUIC device */ 1133 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) { 1134 struct max77693_muic_irq *muic_irq = &muic_irqs[i]; 1135 int virq; 1136 1137 virq = regmap_irq_get_virq(max77693->irq_data_muic, 1138 muic_irq->irq); 1139 if (virq <= 0) 1140 return -EINVAL; 1141 muic_irq->virq = virq; 1142 1143 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL, 1144 max77693_muic_irq_handler, 1145 IRQF_NO_SUSPEND, 1146 muic_irq->name, info); 1147 if (ret) { 1148 dev_err(&pdev->dev, 1149 "failed: irq request (IRQ: %d, error :%d)\n", 1150 muic_irq->irq, ret); 1151 return ret; 1152 } 1153 } 1154 1155 /* Initialize extcon device */ 1156 info->edev = devm_extcon_dev_allocate(&pdev->dev, 1157 max77693_extcon_cable); 1158 if (IS_ERR(info->edev)) { 1159 dev_err(&pdev->dev, "failed to allocate memory for extcon\n"); 1160 return PTR_ERR(info->edev); 1161 } 1162 1163 ret = devm_extcon_dev_register(&pdev->dev, info->edev); 1164 if (ret) { 1165 dev_err(&pdev->dev, "failed to register extcon device\n"); 1166 return ret; 1167 } 1168 1169 /* Initialize MUIC register by using platform data or default data */ 1170 if (pdata && pdata->muic_data) { 1171 init_data = pdata->muic_data->init_data; 1172 num_init_data = pdata->muic_data->num_init_data; 1173 } else { 1174 init_data = default_init_data; 1175 num_init_data = ARRAY_SIZE(default_init_data); 1176 } 1177 1178 for (i = 0; i < num_init_data; i++) { 1179 regmap_write(info->max77693->regmap_muic, 1180 init_data[i].addr, 1181 init_data[i].data); 1182 } 1183 1184 if (pdata && pdata->muic_data) { 1185 struct max77693_muic_platform_data *muic_pdata 1186 = pdata->muic_data; 1187 1188 /* 1189 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB 1190 * h/w path of COMP2/COMN1 on CONTROL1 register. 1191 */ 1192 if (muic_pdata->path_uart) 1193 info->path_uart = muic_pdata->path_uart; 1194 else 1195 info->path_uart = MAX77693_CONTROL1_SW_UART; 1196 1197 if (muic_pdata->path_usb) 1198 info->path_usb = muic_pdata->path_usb; 1199 else 1200 info->path_usb = MAX77693_CONTROL1_SW_USB; 1201 1202 /* 1203 * Default delay time for detecting cable state 1204 * after certain time. 1205 */ 1206 if (muic_pdata->detcable_delay_ms) 1207 delay_jiffies = 1208 msecs_to_jiffies(muic_pdata->detcable_delay_ms); 1209 else 1210 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); 1211 } else { 1212 info->path_usb = MAX77693_CONTROL1_SW_USB; 1213 info->path_uart = MAX77693_CONTROL1_SW_UART; 1214 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT); 1215 } 1216 1217 /* Set initial path for UART when JIG is connected to get serial logs */ 1218 ret = regmap_bulk_read(info->max77693->regmap_muic, 1219 MAX77693_MUIC_REG_STATUS1, info->status, 2); 1220 if (ret) { 1221 dev_err(info->dev, "failed to read MUIC register\n"); 1222 return ret; 1223 } 1224 cable_type = max77693_muic_get_cable_type(info, 1225 MAX77693_CABLE_GROUP_ADC, &attached); 1226 if (attached && (cable_type == MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON || 1227 cable_type == MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF)) 1228 max77693_muic_set_path(info, info->path_uart, true); 1229 1230 /* Check revision number of MUIC device*/ 1231 ret = regmap_read(info->max77693->regmap_muic, 1232 MAX77693_MUIC_REG_ID, &id); 1233 if (ret < 0) { 1234 dev_err(&pdev->dev, "failed to read revision number\n"); 1235 return ret; 1236 } 1237 dev_info(info->dev, "device ID : 0x%x\n", id); 1238 1239 /* Set ADC debounce time */ 1240 max77693_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS); 1241 1242 /* 1243 * Detect accessory after completing the initialization of platform 1244 * 1245 * - Use delayed workqueue to detect cable state and then 1246 * notify cable state to notifiee/platform through uevent. 1247 * After completing the booting of platform, the extcon provider 1248 * driver should notify cable state to upper layer. 1249 */ 1250 INIT_DELAYED_WORK(&info->wq_detcable, max77693_muic_detect_cable_wq); 1251 queue_delayed_work(system_power_efficient_wq, &info->wq_detcable, 1252 delay_jiffies); 1253 1254 return ret; 1255} 1256 1257static int max77693_muic_remove(struct platform_device *pdev) 1258{ 1259 struct max77693_muic_info *info = platform_get_drvdata(pdev); 1260 1261 cancel_work_sync(&info->irq_work); 1262 input_unregister_device(info->dock); 1263 1264 return 0; 1265} 1266 1267static struct platform_driver max77693_muic_driver = { 1268 .driver = { 1269 .name = DEV_NAME, 1270 }, 1271 .probe = max77693_muic_probe, 1272 .remove = max77693_muic_remove, 1273}; 1274 1275module_platform_driver(max77693_muic_driver); 1276 1277MODULE_DESCRIPTION("Maxim MAX77693 Extcon driver"); 1278MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>"); 1279MODULE_LICENSE("GPL"); 1280MODULE_ALIAS("platform:max77693-muic"); 1281