| @@ -0,0 +1,752 @@ |
| | 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"); |