extcon-max77843.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967
  1. // SPDX-License-Identifier: GPL-2.0+
  2. //
  3. // extcon-max77843.c - Maxim MAX77843 extcon driver to support
  4. // MUIC(Micro USB Interface Controller)
  5. //
  6. // Copyright (C) 2015 Samsung Electronics
  7. // Author: Jaewon Kim <jaewon02.kim@samsung.com>
  8. #include <linux/extcon-provider.h>
  9. #include <linux/i2c.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/kernel.h>
  12. #include <linux/mfd/max77693-common.h>
  13. #include <linux/mfd/max77843-private.h>
  14. #include <linux/module.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/workqueue.h>
  17. #define DELAY_MS_DEFAULT 15000 /* unit: millisecond */
  18. enum max77843_muic_status {
  19. MAX77843_MUIC_STATUS1 = 0,
  20. MAX77843_MUIC_STATUS2,
  21. MAX77843_MUIC_STATUS3,
  22. MAX77843_MUIC_STATUS_NUM,
  23. };
  24. struct max77843_muic_info {
  25. struct device *dev;
  26. struct max77693_dev *max77843;
  27. struct extcon_dev *edev;
  28. struct mutex mutex;
  29. struct work_struct irq_work;
  30. struct delayed_work wq_detcable;
  31. u8 status[MAX77843_MUIC_STATUS_NUM];
  32. int prev_cable_type;
  33. int prev_chg_type;
  34. int prev_gnd_type;
  35. bool irq_adc;
  36. bool irq_chg;
  37. };
  38. enum max77843_muic_cable_group {
  39. MAX77843_CABLE_GROUP_ADC = 0,
  40. MAX77843_CABLE_GROUP_ADC_GND,
  41. MAX77843_CABLE_GROUP_CHG,
  42. };
  43. enum max77843_muic_adc_debounce_time {
  44. MAX77843_DEBOUNCE_TIME_5MS = 0,
  45. MAX77843_DEBOUNCE_TIME_10MS,
  46. MAX77843_DEBOUNCE_TIME_25MS,
  47. MAX77843_DEBOUNCE_TIME_38_62MS,
  48. };
  49. /* Define accessory cable type */
  50. enum max77843_muic_accessory_type {
  51. MAX77843_MUIC_ADC_GROUND = 0,
  52. MAX77843_MUIC_ADC_SEND_END_BUTTON,
  53. MAX77843_MUIC_ADC_REMOTE_S1_BUTTON,
  54. MAX77843_MUIC_ADC_REMOTE_S2_BUTTON,
  55. MAX77843_MUIC_ADC_REMOTE_S3_BUTTON,
  56. MAX77843_MUIC_ADC_REMOTE_S4_BUTTON,
  57. MAX77843_MUIC_ADC_REMOTE_S5_BUTTON,
  58. MAX77843_MUIC_ADC_REMOTE_S6_BUTTON,
  59. MAX77843_MUIC_ADC_REMOTE_S7_BUTTON,
  60. MAX77843_MUIC_ADC_REMOTE_S8_BUTTON,
  61. MAX77843_MUIC_ADC_REMOTE_S9_BUTTON,
  62. MAX77843_MUIC_ADC_REMOTE_S10_BUTTON,
  63. MAX77843_MUIC_ADC_REMOTE_S11_BUTTON,
  64. MAX77843_MUIC_ADC_REMOTE_S12_BUTTON,
  65. MAX77843_MUIC_ADC_RESERVED_ACC_1,
  66. MAX77843_MUIC_ADC_RESERVED_ACC_2,
  67. MAX77843_MUIC_ADC_RESERVED_ACC_3, /* SmartDock */
  68. MAX77843_MUIC_ADC_RESERVED_ACC_4,
  69. MAX77843_MUIC_ADC_RESERVED_ACC_5,
  70. MAX77843_MUIC_ADC_AUDIO_DEVICE_TYPE2,
  71. MAX77843_MUIC_ADC_PHONE_POWERED_DEV,
  72. MAX77843_MUIC_ADC_TTY_CONVERTER,
  73. MAX77843_MUIC_ADC_UART_CABLE,
  74. MAX77843_MUIC_ADC_CEA936A_TYPE1_CHG,
  75. MAX77843_MUIC_ADC_FACTORY_MODE_USB_OFF,
  76. MAX77843_MUIC_ADC_FACTORY_MODE_USB_ON,
  77. MAX77843_MUIC_ADC_AV_CABLE_NOLOAD,
  78. MAX77843_MUIC_ADC_CEA936A_TYPE2_CHG,
  79. MAX77843_MUIC_ADC_FACTORY_MODE_UART_OFF,
  80. MAX77843_MUIC_ADC_FACTORY_MODE_UART_ON,
  81. MAX77843_MUIC_ADC_AUDIO_DEVICE_TYPE1,
  82. MAX77843_MUIC_ADC_OPEN,
  83. /*
  84. * The below accessories should check
  85. * not only ADC value but also ADC1K and VBVolt value.
  86. */
  87. /* Offset|ADC1K|VBVolt| */
  88. MAX77843_MUIC_GND_USB_HOST = 0x100, /* 0x1| 0| 0| */
  89. MAX77843_MUIC_GND_USB_HOST_VB = 0x101, /* 0x1| 0| 1| */
  90. MAX77843_MUIC_GND_MHL = 0x102, /* 0x1| 1| 0| */
  91. MAX77843_MUIC_GND_MHL_VB = 0x103, /* 0x1| 1| 1| */
  92. };
  93. /* Define charger cable type */
  94. enum max77843_muic_charger_type {
  95. MAX77843_MUIC_CHG_NONE = 0,
  96. MAX77843_MUIC_CHG_USB,
  97. MAX77843_MUIC_CHG_DOWNSTREAM,
  98. MAX77843_MUIC_CHG_DEDICATED,
  99. MAX77843_MUIC_CHG_SPECIAL_500MA,
  100. MAX77843_MUIC_CHG_SPECIAL_1A,
  101. MAX77843_MUIC_CHG_SPECIAL_BIAS,
  102. MAX77843_MUIC_CHG_RESERVED,
  103. MAX77843_MUIC_CHG_GND,
  104. MAX77843_MUIC_CHG_DOCK,
  105. };
  106. static const unsigned int max77843_extcon_cable[] = {
  107. EXTCON_USB,
  108. EXTCON_USB_HOST,
  109. EXTCON_CHG_USB_SDP,
  110. EXTCON_CHG_USB_DCP,
  111. EXTCON_CHG_USB_CDP,
  112. EXTCON_CHG_USB_FAST,
  113. EXTCON_CHG_USB_SLOW,
  114. EXTCON_DISP_MHL,
  115. EXTCON_DOCK,
  116. EXTCON_JIG,
  117. EXTCON_NONE,
  118. };
  119. struct max77843_muic_irq {
  120. unsigned int irq;
  121. const char *name;
  122. unsigned int virq;
  123. };
  124. static struct max77843_muic_irq max77843_muic_irqs[] = {
  125. { MAX77843_MUIC_IRQ_INT1_ADC, "MUIC-ADC" },
  126. { MAX77843_MUIC_IRQ_INT1_ADCERROR, "MUIC-ADC_ERROR" },
  127. { MAX77843_MUIC_IRQ_INT1_ADC1K, "MUIC-ADC1K" },
  128. { MAX77843_MUIC_IRQ_INT2_CHGTYP, "MUIC-CHGTYP" },
  129. { MAX77843_MUIC_IRQ_INT2_CHGDETRUN, "MUIC-CHGDETRUN" },
  130. { MAX77843_MUIC_IRQ_INT2_DCDTMR, "MUIC-DCDTMR" },
  131. { MAX77843_MUIC_IRQ_INT2_DXOVP, "MUIC-DXOVP" },
  132. { MAX77843_MUIC_IRQ_INT2_VBVOLT, "MUIC-VBVOLT" },
  133. { MAX77843_MUIC_IRQ_INT3_VBADC, "MUIC-VBADC" },
  134. { MAX77843_MUIC_IRQ_INT3_VDNMON, "MUIC-VDNMON" },
  135. { MAX77843_MUIC_IRQ_INT3_DNRES, "MUIC-DNRES" },
  136. { MAX77843_MUIC_IRQ_INT3_MPNACK, "MUIC-MPNACK"},
  137. { MAX77843_MUIC_IRQ_INT3_MRXBUFOW, "MUIC-MRXBUFOW"},
  138. { MAX77843_MUIC_IRQ_INT3_MRXTRF, "MUIC-MRXTRF"},
  139. { MAX77843_MUIC_IRQ_INT3_MRXPERR, "MUIC-MRXPERR"},
  140. { MAX77843_MUIC_IRQ_INT3_MRXRDY, "MUIC-MRXRDY"},
  141. };
  142. static const struct regmap_config max77843_muic_regmap_config = {
  143. .reg_bits = 8,
  144. .val_bits = 8,
  145. .max_register = MAX77843_MUIC_REG_END,
  146. };
  147. static const struct regmap_irq max77843_muic_irq[] = {
  148. /* INT1 interrupt */
  149. { .reg_offset = 0, .mask = MAX77843_MUIC_ADC, },
  150. { .reg_offset = 0, .mask = MAX77843_MUIC_ADCERROR, },
  151. { .reg_offset = 0, .mask = MAX77843_MUIC_ADC1K, },
  152. /* INT2 interrupt */
  153. { .reg_offset = 1, .mask = MAX77843_MUIC_CHGTYP, },
  154. { .reg_offset = 1, .mask = MAX77843_MUIC_CHGDETRUN, },
  155. { .reg_offset = 1, .mask = MAX77843_MUIC_DCDTMR, },
  156. { .reg_offset = 1, .mask = MAX77843_MUIC_DXOVP, },
  157. { .reg_offset = 1, .mask = MAX77843_MUIC_VBVOLT, },
  158. /* INT3 interrupt */
  159. { .reg_offset = 2, .mask = MAX77843_MUIC_VBADC, },
  160. { .reg_offset = 2, .mask = MAX77843_MUIC_VDNMON, },
  161. { .reg_offset = 2, .mask = MAX77843_MUIC_DNRES, },
  162. { .reg_offset = 2, .mask = MAX77843_MUIC_MPNACK, },
  163. { .reg_offset = 2, .mask = MAX77843_MUIC_MRXBUFOW, },
  164. { .reg_offset = 2, .mask = MAX77843_MUIC_MRXTRF, },
  165. { .reg_offset = 2, .mask = MAX77843_MUIC_MRXPERR, },
  166. { .reg_offset = 2, .mask = MAX77843_MUIC_MRXRDY, },
  167. };
  168. static const struct regmap_irq_chip max77843_muic_irq_chip = {
  169. .name = "max77843-muic",
  170. .status_base = MAX77843_MUIC_REG_INT1,
  171. .mask_base = MAX77843_MUIC_REG_INTMASK1,
  172. .mask_invert = true,
  173. .num_regs = 3,
  174. .irqs = max77843_muic_irq,
  175. .num_irqs = ARRAY_SIZE(max77843_muic_irq),
  176. };
  177. static int max77843_muic_set_path(struct max77843_muic_info *info,
  178. u8 val, bool attached, bool nobccomp)
  179. {
  180. struct max77693_dev *max77843 = info->max77843;
  181. int ret = 0;
  182. unsigned int ctrl1, ctrl2;
  183. if (attached)
  184. ctrl1 = val;
  185. else
  186. ctrl1 = MAX77843_MUIC_CONTROL1_SW_OPEN;
  187. if (nobccomp) {
  188. /* Disable BC1.2 protocol and force manual switch control */
  189. ctrl1 |= MAX77843_MUIC_CONTROL1_NOBCCOMP_MASK;
  190. }
  191. ret = regmap_update_bits(max77843->regmap_muic,
  192. MAX77843_MUIC_REG_CONTROL1,
  193. MAX77843_MUIC_CONTROL1_COM_SW |
  194. MAX77843_MUIC_CONTROL1_NOBCCOMP_MASK,
  195. ctrl1);
  196. if (ret < 0) {
  197. dev_err(info->dev, "Cannot switch MUIC port\n");
  198. return ret;
  199. }
  200. if (attached)
  201. ctrl2 = MAX77843_MUIC_CONTROL2_CPEN_MASK;
  202. else
  203. ctrl2 = MAX77843_MUIC_CONTROL2_LOWPWR_MASK;
  204. ret = regmap_update_bits(max77843->regmap_muic,
  205. MAX77843_MUIC_REG_CONTROL2,
  206. MAX77843_MUIC_CONTROL2_LOWPWR_MASK |
  207. MAX77843_MUIC_CONTROL2_CPEN_MASK, ctrl2);
  208. if (ret < 0) {
  209. dev_err(info->dev, "Cannot update lowpower mode\n");
  210. return ret;
  211. }
  212. dev_dbg(info->dev,
  213. "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
  214. ctrl1, ctrl2, attached ? "attached" : "detached");
  215. return 0;
  216. }
  217. static void max77843_charger_set_otg_vbus(struct max77843_muic_info *info,
  218. bool on)
  219. {
  220. struct max77693_dev *max77843 = info->max77843;
  221. unsigned int cnfg00;
  222. if (on)
  223. cnfg00 = MAX77843_CHG_OTG_MASK | MAX77843_CHG_BOOST_MASK;
  224. else
  225. cnfg00 = MAX77843_CHG_ENABLE | MAX77843_CHG_BUCK_MASK;
  226. regmap_update_bits(max77843->regmap_chg, MAX77843_CHG_REG_CHG_CNFG_00,
  227. MAX77843_CHG_MODE_MASK, cnfg00);
  228. }
  229. static int max77843_muic_get_cable_type(struct max77843_muic_info *info,
  230. enum max77843_muic_cable_group group, bool *attached)
  231. {
  232. int adc, chg_type, cable_type, gnd_type;
  233. adc = info->status[MAX77843_MUIC_STATUS1] &
  234. MAX77843_MUIC_STATUS1_ADC_MASK;
  235. adc >>= MAX77843_MUIC_STATUS1_ADC_SHIFT;
  236. switch (group) {
  237. case MAX77843_CABLE_GROUP_ADC:
  238. if (adc == MAX77843_MUIC_ADC_OPEN) {
  239. *attached = false;
  240. cable_type = info->prev_cable_type;
  241. info->prev_cable_type = MAX77843_MUIC_ADC_OPEN;
  242. } else {
  243. *attached = true;
  244. cable_type = info->prev_cable_type = adc;
  245. }
  246. break;
  247. case MAX77843_CABLE_GROUP_CHG:
  248. chg_type = info->status[MAX77843_MUIC_STATUS2] &
  249. MAX77843_MUIC_STATUS2_CHGTYP_MASK;
  250. /* Check GROUND accessory with charger cable */
  251. if (adc == MAX77843_MUIC_ADC_GROUND) {
  252. if (chg_type == MAX77843_MUIC_CHG_NONE) {
  253. /*
  254. * The following state when charger cable is
  255. * disconnected but the GROUND accessory still
  256. * connected.
  257. */
  258. *attached = false;
  259. cable_type = info->prev_chg_type;
  260. info->prev_chg_type = MAX77843_MUIC_CHG_NONE;
  261. } else {
  262. /*
  263. * The following state when charger cable is
  264. * connected on the GROUND accessory.
  265. */
  266. *attached = true;
  267. cable_type = MAX77843_MUIC_CHG_GND;
  268. info->prev_chg_type = MAX77843_MUIC_CHG_GND;
  269. }
  270. break;
  271. }
  272. if (adc == MAX77843_MUIC_ADC_RESERVED_ACC_3) { /* SmartDock */
  273. if (chg_type == MAX77843_MUIC_CHG_NONE) {
  274. *attached = false;
  275. cable_type = info->prev_chg_type;
  276. info->prev_chg_type = MAX77843_MUIC_CHG_NONE;
  277. } else {
  278. *attached = true;
  279. cable_type = MAX77843_MUIC_CHG_DOCK;
  280. info->prev_chg_type = MAX77843_MUIC_CHG_DOCK;
  281. }
  282. break;
  283. }
  284. if (chg_type == MAX77843_MUIC_CHG_NONE) {
  285. *attached = false;
  286. cable_type = info->prev_chg_type;
  287. info->prev_chg_type = MAX77843_MUIC_CHG_NONE;
  288. } else {
  289. *attached = true;
  290. cable_type = info->prev_chg_type = chg_type;
  291. }
  292. break;
  293. case MAX77843_CABLE_GROUP_ADC_GND:
  294. if (adc == MAX77843_MUIC_ADC_OPEN) {
  295. *attached = false;
  296. cable_type = info->prev_gnd_type;
  297. info->prev_gnd_type = MAX77843_MUIC_ADC_OPEN;
  298. } else {
  299. *attached = true;
  300. /*
  301. * Offset|ADC1K|VBVolt|
  302. * 0x1| 0| 0| USB-HOST
  303. * 0x1| 0| 1| USB-HOST with VB
  304. * 0x1| 1| 0| MHL
  305. * 0x1| 1| 1| MHL with VB
  306. */
  307. /* Get ADC1K register bit */
  308. gnd_type = (info->status[MAX77843_MUIC_STATUS1] &
  309. MAX77843_MUIC_STATUS1_ADC1K_MASK);
  310. /* Get VBVolt register bit */
  311. gnd_type |= (info->status[MAX77843_MUIC_STATUS2] &
  312. MAX77843_MUIC_STATUS2_VBVOLT_MASK);
  313. gnd_type >>= MAX77843_MUIC_STATUS2_VBVOLT_SHIFT;
  314. /* Offset of GND cable */
  315. gnd_type |= MAX77843_MUIC_GND_USB_HOST;
  316. cable_type = info->prev_gnd_type = gnd_type;
  317. }
  318. break;
  319. default:
  320. dev_err(info->dev, "Unknown cable group (%d)\n", group);
  321. cable_type = -EINVAL;
  322. break;
  323. }
  324. return cable_type;
  325. }
  326. static int max77843_muic_adc_gnd_handler(struct max77843_muic_info *info)
  327. {
  328. int ret, gnd_cable_type;
  329. bool attached;
  330. gnd_cable_type = max77843_muic_get_cable_type(info,
  331. MAX77843_CABLE_GROUP_ADC_GND, &attached);
  332. dev_dbg(info->dev, "external connector is %s (gnd:0x%02x)\n",
  333. attached ? "attached" : "detached", gnd_cable_type);
  334. switch (gnd_cable_type) {
  335. case MAX77843_MUIC_GND_USB_HOST:
  336. case MAX77843_MUIC_GND_USB_HOST_VB:
  337. ret = max77843_muic_set_path(info,
  338. MAX77843_MUIC_CONTROL1_SW_USB,
  339. attached, false);
  340. if (ret < 0)
  341. return ret;
  342. extcon_set_state_sync(info->edev, EXTCON_USB_HOST, attached);
  343. max77843_charger_set_otg_vbus(info, attached);
  344. break;
  345. case MAX77843_MUIC_GND_MHL_VB:
  346. case MAX77843_MUIC_GND_MHL:
  347. ret = max77843_muic_set_path(info,
  348. MAX77843_MUIC_CONTROL1_SW_OPEN,
  349. attached, false);
  350. if (ret < 0)
  351. return ret;
  352. extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, attached);
  353. break;
  354. default:
  355. dev_err(info->dev, "failed to detect %s accessory(gnd:0x%x)\n",
  356. attached ? "attached" : "detached", gnd_cable_type);
  357. return -EINVAL;
  358. }
  359. return 0;
  360. }
  361. static int max77843_muic_jig_handler(struct max77843_muic_info *info,
  362. int cable_type, bool attached)
  363. {
  364. int ret;
  365. u8 path = MAX77843_MUIC_CONTROL1_SW_OPEN;
  366. dev_dbg(info->dev, "external connector is %s (adc:0x%02x)\n",
  367. attached ? "attached" : "detached", cable_type);
  368. switch (cable_type) {
  369. case MAX77843_MUIC_ADC_FACTORY_MODE_USB_OFF:
  370. case MAX77843_MUIC_ADC_FACTORY_MODE_USB_ON:
  371. path = MAX77843_MUIC_CONTROL1_SW_USB;
  372. break;
  373. case MAX77843_MUIC_ADC_FACTORY_MODE_UART_OFF:
  374. path = MAX77843_MUIC_CONTROL1_SW_UART;
  375. break;
  376. default:
  377. return -EINVAL;
  378. }
  379. ret = max77843_muic_set_path(info, path, attached, false);
  380. if (ret < 0)
  381. return ret;
  382. extcon_set_state_sync(info->edev, EXTCON_JIG, attached);
  383. return 0;
  384. }
  385. static int max77843_muic_dock_handler(struct max77843_muic_info *info,
  386. bool attached)
  387. {
  388. int ret;
  389. dev_dbg(info->dev, "external connector is %s (adc: 0x10)\n",
  390. attached ? "attached" : "detached");
  391. ret = max77843_muic_set_path(info, MAX77843_MUIC_CONTROL1_SW_USB,
  392. attached, attached);
  393. if (ret < 0)
  394. return ret;
  395. extcon_set_state_sync(info->edev, EXTCON_DISP_MHL, attached);
  396. extcon_set_state_sync(info->edev, EXTCON_USB_HOST, attached);
  397. extcon_set_state_sync(info->edev, EXTCON_DOCK, attached);
  398. return 0;
  399. }
  400. static int max77843_muic_adc_handler(struct max77843_muic_info *info)
  401. {
  402. int ret, cable_type;
  403. bool attached;
  404. cable_type = max77843_muic_get_cable_type(info,
  405. MAX77843_CABLE_GROUP_ADC, &attached);
  406. dev_dbg(info->dev,
  407. "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n",
  408. attached ? "attached" : "detached", cable_type,
  409. info->prev_cable_type);
  410. switch (cable_type) {
  411. case MAX77843_MUIC_ADC_RESERVED_ACC_3: /* SmartDock */
  412. ret = max77843_muic_dock_handler(info, attached);
  413. if (ret < 0)
  414. return ret;
  415. break;
  416. case MAX77843_MUIC_ADC_GROUND:
  417. ret = max77843_muic_adc_gnd_handler(info);
  418. if (ret < 0)
  419. return ret;
  420. break;
  421. case MAX77843_MUIC_ADC_FACTORY_MODE_USB_OFF:
  422. case MAX77843_MUIC_ADC_FACTORY_MODE_USB_ON:
  423. case MAX77843_MUIC_ADC_FACTORY_MODE_UART_OFF:
  424. ret = max77843_muic_jig_handler(info, cable_type, attached);
  425. if (ret < 0)
  426. return ret;
  427. break;
  428. case MAX77843_MUIC_ADC_SEND_END_BUTTON:
  429. case MAX77843_MUIC_ADC_REMOTE_S1_BUTTON:
  430. case MAX77843_MUIC_ADC_REMOTE_S2_BUTTON:
  431. case MAX77843_MUIC_ADC_REMOTE_S3_BUTTON:
  432. case MAX77843_MUIC_ADC_REMOTE_S4_BUTTON:
  433. case MAX77843_MUIC_ADC_REMOTE_S5_BUTTON:
  434. case MAX77843_MUIC_ADC_REMOTE_S6_BUTTON:
  435. case MAX77843_MUIC_ADC_REMOTE_S7_BUTTON:
  436. case MAX77843_MUIC_ADC_REMOTE_S8_BUTTON:
  437. case MAX77843_MUIC_ADC_REMOTE_S9_BUTTON:
  438. case MAX77843_MUIC_ADC_REMOTE_S10_BUTTON:
  439. case MAX77843_MUIC_ADC_REMOTE_S11_BUTTON:
  440. case MAX77843_MUIC_ADC_REMOTE_S12_BUTTON:
  441. case MAX77843_MUIC_ADC_RESERVED_ACC_1:
  442. case MAX77843_MUIC_ADC_RESERVED_ACC_2:
  443. case MAX77843_MUIC_ADC_RESERVED_ACC_4:
  444. case MAX77843_MUIC_ADC_RESERVED_ACC_5:
  445. case MAX77843_MUIC_ADC_AUDIO_DEVICE_TYPE2:
  446. case MAX77843_MUIC_ADC_PHONE_POWERED_DEV:
  447. case MAX77843_MUIC_ADC_TTY_CONVERTER:
  448. case MAX77843_MUIC_ADC_UART_CABLE:
  449. case MAX77843_MUIC_ADC_CEA936A_TYPE1_CHG:
  450. case MAX77843_MUIC_ADC_AV_CABLE_NOLOAD:
  451. case MAX77843_MUIC_ADC_CEA936A_TYPE2_CHG:
  452. case MAX77843_MUIC_ADC_FACTORY_MODE_UART_ON:
  453. case MAX77843_MUIC_ADC_AUDIO_DEVICE_TYPE1:
  454. case MAX77843_MUIC_ADC_OPEN:
  455. dev_err(info->dev,
  456. "accessory is %s but it isn't used (adc:0x%x)\n",
  457. attached ? "attached" : "detached", cable_type);
  458. return -EAGAIN;
  459. default:
  460. dev_err(info->dev,
  461. "failed to detect %s accessory (adc:0x%x)\n",
  462. attached ? "attached" : "detached", cable_type);
  463. return -EINVAL;
  464. }
  465. return 0;
  466. }
  467. static int max77843_muic_chg_handler(struct max77843_muic_info *info)
  468. {
  469. int ret, chg_type, gnd_type;
  470. bool attached;
  471. chg_type = max77843_muic_get_cable_type(info,
  472. MAX77843_CABLE_GROUP_CHG, &attached);
  473. dev_dbg(info->dev,
  474. "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n",
  475. attached ? "attached" : "detached",
  476. chg_type, info->prev_chg_type);
  477. switch (chg_type) {
  478. case MAX77843_MUIC_CHG_USB:
  479. ret = max77843_muic_set_path(info,
  480. MAX77843_MUIC_CONTROL1_SW_USB,
  481. attached, false);
  482. if (ret < 0)
  483. return ret;
  484. extcon_set_state_sync(info->edev, EXTCON_USB, attached);
  485. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP,
  486. attached);
  487. break;
  488. case MAX77843_MUIC_CHG_DOWNSTREAM:
  489. ret = max77843_muic_set_path(info,
  490. MAX77843_MUIC_CONTROL1_SW_OPEN,
  491. attached, false);
  492. if (ret < 0)
  493. return ret;
  494. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP,
  495. attached);
  496. break;
  497. case MAX77843_MUIC_CHG_DEDICATED:
  498. ret = max77843_muic_set_path(info,
  499. MAX77843_MUIC_CONTROL1_SW_OPEN,
  500. attached, false);
  501. if (ret < 0)
  502. return ret;
  503. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP,
  504. attached);
  505. break;
  506. case MAX77843_MUIC_CHG_SPECIAL_500MA:
  507. ret = max77843_muic_set_path(info,
  508. MAX77843_MUIC_CONTROL1_SW_OPEN,
  509. attached, false);
  510. if (ret < 0)
  511. return ret;
  512. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW,
  513. attached);
  514. break;
  515. case MAX77843_MUIC_CHG_SPECIAL_1A:
  516. ret = max77843_muic_set_path(info,
  517. MAX77843_MUIC_CONTROL1_SW_OPEN,
  518. attached, false);
  519. if (ret < 0)
  520. return ret;
  521. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST,
  522. attached);
  523. break;
  524. case MAX77843_MUIC_CHG_GND:
  525. gnd_type = max77843_muic_get_cable_type(info,
  526. MAX77843_CABLE_GROUP_ADC_GND, &attached);
  527. /* Charger cable on MHL accessory is attach or detach */
  528. if (gnd_type == MAX77843_MUIC_GND_MHL_VB)
  529. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP,
  530. true);
  531. else if (gnd_type == MAX77843_MUIC_GND_MHL)
  532. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP,
  533. false);
  534. break;
  535. case MAX77843_MUIC_CHG_DOCK:
  536. extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP, attached);
  537. break;
  538. case MAX77843_MUIC_CHG_NONE:
  539. break;
  540. default:
  541. dev_err(info->dev,
  542. "failed to detect %s accessory (chg_type:0x%x)\n",
  543. attached ? "attached" : "detached", chg_type);
  544. max77843_muic_set_path(info, MAX77843_MUIC_CONTROL1_SW_OPEN,
  545. attached, false);
  546. return -EINVAL;
  547. }
  548. return 0;
  549. }
  550. static void max77843_muic_irq_work(struct work_struct *work)
  551. {
  552. struct max77843_muic_info *info = container_of(work,
  553. struct max77843_muic_info, irq_work);
  554. struct max77693_dev *max77843 = info->max77843;
  555. int ret = 0;
  556. mutex_lock(&info->mutex);
  557. ret = regmap_bulk_read(max77843->regmap_muic,
  558. MAX77843_MUIC_REG_STATUS1, info->status,
  559. MAX77843_MUIC_STATUS_NUM);
  560. if (ret) {
  561. dev_err(info->dev, "Cannot read STATUS registers\n");
  562. mutex_unlock(&info->mutex);
  563. return;
  564. }
  565. if (info->irq_adc) {
  566. ret = max77843_muic_adc_handler(info);
  567. if (ret)
  568. dev_err(info->dev, "Unknown cable type\n");
  569. info->irq_adc = false;
  570. }
  571. if (info->irq_chg) {
  572. ret = max77843_muic_chg_handler(info);
  573. if (ret)
  574. dev_err(info->dev, "Unknown charger type\n");
  575. info->irq_chg = false;
  576. }
  577. mutex_unlock(&info->mutex);
  578. }
  579. static irqreturn_t max77843_muic_irq_handler(int irq, void *data)
  580. {
  581. struct max77843_muic_info *info = data;
  582. int i, irq_type = -1;
  583. for (i = 0; i < ARRAY_SIZE(max77843_muic_irqs); i++)
  584. if (irq == max77843_muic_irqs[i].virq)
  585. irq_type = max77843_muic_irqs[i].irq;
  586. switch (irq_type) {
  587. case MAX77843_MUIC_IRQ_INT1_ADC:
  588. case MAX77843_MUIC_IRQ_INT1_ADCERROR:
  589. case MAX77843_MUIC_IRQ_INT1_ADC1K:
  590. info->irq_adc = true;
  591. break;
  592. case MAX77843_MUIC_IRQ_INT2_CHGTYP:
  593. case MAX77843_MUIC_IRQ_INT2_CHGDETRUN:
  594. case MAX77843_MUIC_IRQ_INT2_DCDTMR:
  595. case MAX77843_MUIC_IRQ_INT2_DXOVP:
  596. case MAX77843_MUIC_IRQ_INT2_VBVOLT:
  597. info->irq_chg = true;
  598. break;
  599. case MAX77843_MUIC_IRQ_INT3_VBADC:
  600. case MAX77843_MUIC_IRQ_INT3_VDNMON:
  601. case MAX77843_MUIC_IRQ_INT3_DNRES:
  602. case MAX77843_MUIC_IRQ_INT3_MPNACK:
  603. case MAX77843_MUIC_IRQ_INT3_MRXBUFOW:
  604. case MAX77843_MUIC_IRQ_INT3_MRXTRF:
  605. case MAX77843_MUIC_IRQ_INT3_MRXPERR:
  606. case MAX77843_MUIC_IRQ_INT3_MRXRDY:
  607. break;
  608. default:
  609. dev_err(info->dev, "Cannot recognize IRQ(%d)\n", irq_type);
  610. break;
  611. }
  612. schedule_work(&info->irq_work);
  613. return IRQ_HANDLED;
  614. }
  615. static void max77843_muic_detect_cable_wq(struct work_struct *work)
  616. {
  617. struct max77843_muic_info *info = container_of(to_delayed_work(work),
  618. struct max77843_muic_info, wq_detcable);
  619. struct max77693_dev *max77843 = info->max77843;
  620. int chg_type, adc, ret;
  621. bool attached;
  622. mutex_lock(&info->mutex);
  623. ret = regmap_bulk_read(max77843->regmap_muic,
  624. MAX77843_MUIC_REG_STATUS1, info->status,
  625. MAX77843_MUIC_STATUS_NUM);
  626. if (ret) {
  627. dev_err(info->dev, "Cannot read STATUS registers\n");
  628. goto err_cable_wq;
  629. }
  630. adc = max77843_muic_get_cable_type(info,
  631. MAX77843_CABLE_GROUP_ADC, &attached);
  632. if (attached && adc != MAX77843_MUIC_ADC_OPEN) {
  633. ret = max77843_muic_adc_handler(info);
  634. if (ret < 0) {
  635. dev_err(info->dev, "Cannot detect accessory\n");
  636. goto err_cable_wq;
  637. }
  638. }
  639. chg_type = max77843_muic_get_cable_type(info,
  640. MAX77843_CABLE_GROUP_CHG, &attached);
  641. if (attached && chg_type != MAX77843_MUIC_CHG_NONE) {
  642. ret = max77843_muic_chg_handler(info);
  643. if (ret < 0) {
  644. dev_err(info->dev, "Cannot detect charger accessory\n");
  645. goto err_cable_wq;
  646. }
  647. }
  648. err_cable_wq:
  649. mutex_unlock(&info->mutex);
  650. }
  651. static int max77843_muic_set_debounce_time(struct max77843_muic_info *info,
  652. enum max77843_muic_adc_debounce_time time)
  653. {
  654. struct max77693_dev *max77843 = info->max77843;
  655. int ret;
  656. switch (time) {
  657. case MAX77843_DEBOUNCE_TIME_5MS:
  658. case MAX77843_DEBOUNCE_TIME_10MS:
  659. case MAX77843_DEBOUNCE_TIME_25MS:
  660. case MAX77843_DEBOUNCE_TIME_38_62MS:
  661. ret = regmap_update_bits(max77843->regmap_muic,
  662. MAX77843_MUIC_REG_CONTROL4,
  663. MAX77843_MUIC_CONTROL4_ADCDBSET_MASK,
  664. time << MAX77843_MUIC_CONTROL4_ADCDBSET_SHIFT);
  665. if (ret < 0) {
  666. dev_err(info->dev, "Cannot write MUIC regmap\n");
  667. return ret;
  668. }
  669. break;
  670. default:
  671. dev_err(info->dev, "Invalid ADC debounce time\n");
  672. return -EINVAL;
  673. }
  674. return 0;
  675. }
  676. static int max77843_init_muic_regmap(struct max77693_dev *max77843)
  677. {
  678. int ret;
  679. max77843->i2c_muic = i2c_new_dummy_device(max77843->i2c->adapter,
  680. I2C_ADDR_MUIC);
  681. if (IS_ERR(max77843->i2c_muic)) {
  682. dev_err(&max77843->i2c->dev,
  683. "Cannot allocate I2C device for MUIC\n");
  684. return PTR_ERR(max77843->i2c_muic);
  685. }
  686. i2c_set_clientdata(max77843->i2c_muic, max77843);
  687. max77843->regmap_muic = devm_regmap_init_i2c(max77843->i2c_muic,
  688. &max77843_muic_regmap_config);
  689. if (IS_ERR(max77843->regmap_muic)) {
  690. ret = PTR_ERR(max77843->regmap_muic);
  691. goto err_muic_i2c;
  692. }
  693. ret = regmap_add_irq_chip(max77843->regmap_muic, max77843->irq,
  694. IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_SHARED,
  695. 0, &max77843_muic_irq_chip, &max77843->irq_data_muic);
  696. if (ret < 0) {
  697. dev_err(&max77843->i2c->dev, "Cannot add MUIC IRQ chip\n");
  698. goto err_muic_i2c;
  699. }
  700. return 0;
  701. err_muic_i2c:
  702. i2c_unregister_device(max77843->i2c_muic);
  703. return ret;
  704. }
  705. static int max77843_muic_probe(struct platform_device *pdev)
  706. {
  707. struct max77693_dev *max77843 = dev_get_drvdata(pdev->dev.parent);
  708. struct max77843_muic_info *info;
  709. unsigned int id;
  710. int cable_type;
  711. bool attached;
  712. int i, ret;
  713. info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
  714. if (!info)
  715. return -ENOMEM;
  716. info->dev = &pdev->dev;
  717. info->max77843 = max77843;
  718. platform_set_drvdata(pdev, info);
  719. mutex_init(&info->mutex);
  720. /* Initialize i2c and regmap */
  721. ret = max77843_init_muic_regmap(max77843);
  722. if (ret) {
  723. dev_err(&pdev->dev, "Failed to init MUIC regmap\n");
  724. return ret;
  725. }
  726. /* Turn off auto detection configuration */
  727. ret = regmap_update_bits(max77843->regmap_muic,
  728. MAX77843_MUIC_REG_CONTROL4,
  729. MAX77843_MUIC_CONTROL4_USBAUTO_MASK |
  730. MAX77843_MUIC_CONTROL4_FCTAUTO_MASK,
  731. CONTROL4_AUTO_DISABLE);
  732. /* Initialize extcon device */
  733. info->edev = devm_extcon_dev_allocate(&pdev->dev,
  734. max77843_extcon_cable);
  735. if (IS_ERR(info->edev)) {
  736. dev_err(&pdev->dev, "Failed to allocate memory for extcon\n");
  737. ret = PTR_ERR(info->edev);
  738. goto err_muic_irq;
  739. }
  740. ret = devm_extcon_dev_register(&pdev->dev, info->edev);
  741. if (ret) {
  742. dev_err(&pdev->dev, "Failed to register extcon device\n");
  743. goto err_muic_irq;
  744. }
  745. /* Set ADC debounce time */
  746. max77843_muic_set_debounce_time(info, MAX77843_DEBOUNCE_TIME_25MS);
  747. /* Set initial path for UART when JIG is connected to get serial logs */
  748. ret = regmap_bulk_read(max77843->regmap_muic,
  749. MAX77843_MUIC_REG_STATUS1, info->status,
  750. MAX77843_MUIC_STATUS_NUM);
  751. if (ret) {
  752. dev_err(info->dev, "Cannot read STATUS registers\n");
  753. goto err_muic_irq;
  754. }
  755. cable_type = max77843_muic_get_cable_type(info, MAX77843_CABLE_GROUP_ADC,
  756. &attached);
  757. if (attached && cable_type == MAX77843_MUIC_ADC_FACTORY_MODE_UART_OFF)
  758. max77843_muic_set_path(info, MAX77843_MUIC_CONTROL1_SW_UART,
  759. true, false);
  760. /* Check revision number of MUIC device */
  761. ret = regmap_read(max77843->regmap_muic, MAX77843_MUIC_REG_ID, &id);
  762. if (ret < 0) {
  763. dev_err(&pdev->dev, "Failed to read revision number\n");
  764. goto err_muic_irq;
  765. }
  766. dev_info(info->dev, "MUIC device ID : 0x%x\n", id);
  767. /* Support virtual irq domain for max77843 MUIC device */
  768. INIT_WORK(&info->irq_work, max77843_muic_irq_work);
  769. /* Clear IRQ bits before request IRQs */
  770. ret = regmap_bulk_read(max77843->regmap_muic,
  771. MAX77843_MUIC_REG_INT1, info->status,
  772. MAX77843_MUIC_STATUS_NUM);
  773. if (ret) {
  774. dev_err(&pdev->dev, "Failed to Clear IRQ bits\n");
  775. goto err_muic_irq;
  776. }
  777. for (i = 0; i < ARRAY_SIZE(max77843_muic_irqs); i++) {
  778. struct max77843_muic_irq *muic_irq = &max77843_muic_irqs[i];
  779. int virq = 0;
  780. virq = regmap_irq_get_virq(max77843->irq_data_muic,
  781. muic_irq->irq);
  782. if (virq <= 0) {
  783. ret = -EINVAL;
  784. goto err_muic_irq;
  785. }
  786. muic_irq->virq = virq;
  787. ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
  788. max77843_muic_irq_handler, IRQF_NO_SUSPEND,
  789. muic_irq->name, info);
  790. if (ret) {
  791. dev_err(&pdev->dev,
  792. "Failed to request irq (IRQ: %d, error: %d)\n",
  793. muic_irq->irq, ret);
  794. goto err_muic_irq;
  795. }
  796. }
  797. /* Detect accessory after completing the initialization of platform */
  798. INIT_DELAYED_WORK(&info->wq_detcable, max77843_muic_detect_cable_wq);
  799. queue_delayed_work(system_power_efficient_wq,
  800. &info->wq_detcable, msecs_to_jiffies(DELAY_MS_DEFAULT));
  801. return 0;
  802. err_muic_irq:
  803. regmap_del_irq_chip(max77843->irq, max77843->irq_data_muic);
  804. i2c_unregister_device(max77843->i2c_muic);
  805. return ret;
  806. }
  807. static int max77843_muic_remove(struct platform_device *pdev)
  808. {
  809. struct max77843_muic_info *info = platform_get_drvdata(pdev);
  810. struct max77693_dev *max77843 = info->max77843;
  811. cancel_work_sync(&info->irq_work);
  812. regmap_del_irq_chip(max77843->irq, max77843->irq_data_muic);
  813. i2c_unregister_device(max77843->i2c_muic);
  814. return 0;
  815. }
  816. static const struct platform_device_id max77843_muic_id[] = {
  817. { "max77843-muic", },
  818. { /* sentinel */ },
  819. };
  820. MODULE_DEVICE_TABLE(platform, max77843_muic_id);
  821. static struct platform_driver max77843_muic_driver = {
  822. .driver = {
  823. .name = "max77843-muic",
  824. },
  825. .probe = max77843_muic_probe,
  826. .remove = max77843_muic_remove,
  827. .id_table = max77843_muic_id,
  828. };
  829. static int __init max77843_muic_init(void)
  830. {
  831. return platform_driver_register(&max77843_muic_driver);
  832. }
  833. subsys_initcall(max77843_muic_init);
  834. MODULE_DESCRIPTION("Maxim MAX77843 Extcon driver");
  835. MODULE_AUTHOR("Jaewon Kim <jaewon02.kim@samsung.com>");
  836. MODULE_LICENSE("GPL");