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