qcom-wled.c 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /* Copyright (c) 2015, Sony Mobile Communications, AB.
  3. */
  4. #include <linux/delay.h>
  5. #include <linux/interrupt.h>
  6. #include <linux/ktime.h>
  7. #include <linux/kernel.h>
  8. #include <linux/backlight.h>
  9. #include <linux/module.h>
  10. #include <linux/of.h>
  11. #include <linux/of_device.h>
  12. #include <linux/of_address.h>
  13. #include <linux/regmap.h>
  14. /* From DT binding */
  15. #define WLED_MAX_STRINGS 4
  16. #define MOD_A 0
  17. #define MOD_B 1
  18. #define WLED_DEFAULT_BRIGHTNESS 2048
  19. #define WLED_SOFT_START_DLY_US 10000
  20. #define WLED3_SINK_REG_BRIGHT_MAX 0xFFF
  21. #define WLED5_SINK_REG_BRIGHT_MAX_12B 0xFFF
  22. #define WLED5_SINK_REG_BRIGHT_MAX_15B 0x7FFF
  23. /* WLED3/WLED4 control registers */
  24. #define WLED3_CTRL_REG_FAULT_STATUS 0x08
  25. #define WLED3_CTRL_REG_ILIM_FAULT_BIT BIT(0)
  26. #define WLED3_CTRL_REG_OVP_FAULT_BIT BIT(1)
  27. #define WLED4_CTRL_REG_SC_FAULT_BIT BIT(2)
  28. #define WLED5_CTRL_REG_OVP_PRE_ALARM_BIT BIT(4)
  29. #define WLED3_CTRL_REG_INT_RT_STS 0x10
  30. #define WLED3_CTRL_REG_OVP_FAULT_STATUS BIT(1)
  31. #define WLED3_CTRL_REG_MOD_EN 0x46
  32. #define WLED3_CTRL_REG_MOD_EN_MASK BIT(7)
  33. #define WLED3_CTRL_REG_MOD_EN_SHIFT 7
  34. #define WLED3_CTRL_REG_FEEDBACK_CONTROL 0x48
  35. #define WLED3_CTRL_REG_FREQ 0x4c
  36. #define WLED3_CTRL_REG_FREQ_MASK GENMASK(3, 0)
  37. #define WLED3_CTRL_REG_OVP 0x4d
  38. #define WLED3_CTRL_REG_OVP_MASK GENMASK(1, 0)
  39. #define WLED5_CTRL_REG_OVP_MASK GENMASK(3, 0)
  40. #define WLED3_CTRL_REG_ILIMIT 0x4e
  41. #define WLED3_CTRL_REG_ILIMIT_MASK GENMASK(2, 0)
  42. /* WLED3/WLED4 sink registers */
  43. #define WLED3_SINK_REG_SYNC 0x47
  44. #define WLED3_SINK_REG_SYNC_CLEAR 0x00
  45. #define WLED3_SINK_REG_CURR_SINK 0x4f
  46. #define WLED3_SINK_REG_CURR_SINK_MASK GENMASK(7, 5)
  47. #define WLED3_SINK_REG_CURR_SINK_SHFT 5
  48. /* WLED3 specific per-'string' registers below */
  49. #define WLED3_SINK_REG_BRIGHT(n) (0x40 + n)
  50. #define WLED3_SINK_REG_STR_MOD_EN(n) (0x60 + (n * 0x10))
  51. #define WLED3_SINK_REG_STR_MOD_MASK BIT(7)
  52. #define WLED3_SINK_REG_STR_FULL_SCALE_CURR(n) (0x62 + (n * 0x10))
  53. #define WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(4, 0)
  54. #define WLED3_SINK_REG_STR_MOD_SRC(n) (0x63 + (n * 0x10))
  55. #define WLED3_SINK_REG_STR_MOD_SRC_MASK BIT(0)
  56. #define WLED3_SINK_REG_STR_MOD_SRC_INT 0x00
  57. #define WLED3_SINK_REG_STR_MOD_SRC_EXT 0x01
  58. #define WLED3_SINK_REG_STR_CABC(n) (0x66 + (n * 0x10))
  59. #define WLED3_SINK_REG_STR_CABC_MASK BIT(7)
  60. /* WLED4 specific control registers */
  61. #define WLED4_CTRL_REG_SHORT_PROTECT 0x5e
  62. #define WLED4_CTRL_REG_SHORT_EN_MASK BIT(7)
  63. #define WLED4_CTRL_REG_SEC_ACCESS 0xd0
  64. #define WLED4_CTRL_REG_SEC_UNLOCK 0xa5
  65. #define WLED4_CTRL_REG_TEST1 0xe2
  66. #define WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2 0x09
  67. /* WLED4 specific sink registers */
  68. #define WLED4_SINK_REG_CURR_SINK 0x46
  69. #define WLED4_SINK_REG_CURR_SINK_MASK GENMASK(7, 4)
  70. #define WLED4_SINK_REG_CURR_SINK_SHFT 4
  71. /* WLED4 specific per-'string' registers below */
  72. #define WLED4_SINK_REG_STR_MOD_EN(n) (0x50 + (n * 0x10))
  73. #define WLED4_SINK_REG_STR_MOD_MASK BIT(7)
  74. #define WLED4_SINK_REG_STR_FULL_SCALE_CURR(n) (0x52 + (n * 0x10))
  75. #define WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(3, 0)
  76. #define WLED4_SINK_REG_STR_MOD_SRC(n) (0x53 + (n * 0x10))
  77. #define WLED4_SINK_REG_STR_MOD_SRC_MASK BIT(0)
  78. #define WLED4_SINK_REG_STR_MOD_SRC_INT 0x00
  79. #define WLED4_SINK_REG_STR_MOD_SRC_EXT 0x01
  80. #define WLED4_SINK_REG_STR_CABC(n) (0x56 + (n * 0x10))
  81. #define WLED4_SINK_REG_STR_CABC_MASK BIT(7)
  82. #define WLED4_SINK_REG_BRIGHT(n) (0x57 + (n * 0x10))
  83. /* WLED5 specific control registers */
  84. #define WLED5_CTRL_REG_OVP_INT_CTL 0x5f
  85. #define WLED5_CTRL_REG_OVP_INT_TIMER_MASK GENMASK(2, 0)
  86. /* WLED5 specific sink registers */
  87. #define WLED5_SINK_REG_MOD_A_EN 0x50
  88. #define WLED5_SINK_REG_MOD_B_EN 0x60
  89. #define WLED5_SINK_REG_MOD_EN_MASK BIT(7)
  90. #define WLED5_SINK_REG_MOD_A_SRC_SEL 0x51
  91. #define WLED5_SINK_REG_MOD_B_SRC_SEL 0x61
  92. #define WLED5_SINK_REG_MOD_SRC_SEL_HIGH 0
  93. #define WLED5_SINK_REG_MOD_SRC_SEL_EXT 0x03
  94. #define WLED5_SINK_REG_MOD_SRC_SEL_MASK GENMASK(1, 0)
  95. #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL 0x52
  96. #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL 0x62
  97. #define WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B 0
  98. #define WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B 1
  99. #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB 0x53
  100. #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_MSB 0x54
  101. #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB 0x63
  102. #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_MSB 0x64
  103. #define WLED5_SINK_REG_MOD_SYNC_BIT 0x65
  104. #define WLED5_SINK_REG_SYNC_MOD_A_BIT BIT(0)
  105. #define WLED5_SINK_REG_SYNC_MOD_B_BIT BIT(1)
  106. #define WLED5_SINK_REG_SYNC_MASK GENMASK(1, 0)
  107. /* WLED5 specific per-'string' registers below */
  108. #define WLED5_SINK_REG_STR_FULL_SCALE_CURR(n) (0x72 + (n * 0x10))
  109. #define WLED5_SINK_REG_STR_SRC_SEL(n) (0x73 + (n * 0x10))
  110. #define WLED5_SINK_REG_SRC_SEL_MOD_A 0
  111. #define WLED5_SINK_REG_SRC_SEL_MOD_B 1
  112. #define WLED5_SINK_REG_SRC_SEL_MASK GENMASK(1, 0)
  113. struct wled_var_cfg {
  114. const u32 *values;
  115. u32 (*fn)(u32);
  116. int size;
  117. };
  118. struct wled_u32_opts {
  119. const char *name;
  120. u32 *val_ptr;
  121. const struct wled_var_cfg *cfg;
  122. };
  123. struct wled_bool_opts {
  124. const char *name;
  125. bool *val_ptr;
  126. };
  127. struct wled_config {
  128. u32 boost_i_limit;
  129. u32 ovp;
  130. u32 switch_freq;
  131. u32 num_strings;
  132. u32 string_i_limit;
  133. u32 enabled_strings[WLED_MAX_STRINGS];
  134. u32 mod_sel;
  135. u32 cabc_sel;
  136. bool cs_out_en;
  137. bool ext_gen;
  138. bool cabc;
  139. bool external_pfet;
  140. bool auto_detection_enabled;
  141. };
  142. struct wled {
  143. const char *name;
  144. struct device *dev;
  145. struct regmap *regmap;
  146. struct mutex lock; /* Lock to avoid race from thread irq handler */
  147. ktime_t last_short_event;
  148. ktime_t start_ovp_fault_time;
  149. u16 ctrl_addr;
  150. u16 sink_addr;
  151. u16 max_string_count;
  152. u16 auto_detection_ovp_count;
  153. u32 brightness;
  154. u32 max_brightness;
  155. u32 short_count;
  156. u32 auto_detect_count;
  157. u32 version;
  158. bool disabled_by_short;
  159. bool has_short_detect;
  160. bool cabc_disabled;
  161. int short_irq;
  162. int ovp_irq;
  163. struct wled_config cfg;
  164. struct delayed_work ovp_work;
  165. /* Configures the brightness. Applicable for wled3, wled4 and wled5 */
  166. int (*wled_set_brightness)(struct wled *wled, u16 brightness);
  167. /* Configures the cabc register. Applicable for wled4 and wled5 */
  168. int (*wled_cabc_config)(struct wled *wled, bool enable);
  169. /*
  170. * Toggles the sync bit for the brightness update to take place.
  171. * Applicable for WLED3, WLED4 and WLED5.
  172. */
  173. int (*wled_sync_toggle)(struct wled *wled);
  174. /*
  175. * Time to wait before checking the OVP status after wled module enable.
  176. * Applicable for WLED4 and WLED5.
  177. */
  178. int (*wled_ovp_delay)(struct wled *wled);
  179. /*
  180. * Determines if the auto string detection is required.
  181. * Applicable for WLED4 and WLED5
  182. */
  183. bool (*wled_auto_detection_required)(struct wled *wled);
  184. };
  185. static int wled3_set_brightness(struct wled *wled, u16 brightness)
  186. {
  187. int rc, i;
  188. __le16 v;
  189. v = cpu_to_le16(brightness & WLED3_SINK_REG_BRIGHT_MAX);
  190. for (i = 0; i < wled->cfg.num_strings; ++i) {
  191. rc = regmap_bulk_write(wled->regmap, wled->ctrl_addr +
  192. WLED3_SINK_REG_BRIGHT(wled->cfg.enabled_strings[i]),
  193. &v, sizeof(v));
  194. if (rc < 0)
  195. return rc;
  196. }
  197. return 0;
  198. }
  199. static int wled4_set_brightness(struct wled *wled, u16 brightness)
  200. {
  201. int rc, i;
  202. u16 low_limit = wled->max_brightness * 4 / 1000;
  203. __le16 v;
  204. /* WLED4's lower limit of operation is 0.4% */
  205. if (brightness > 0 && brightness < low_limit)
  206. brightness = low_limit;
  207. v = cpu_to_le16(brightness & WLED3_SINK_REG_BRIGHT_MAX);
  208. for (i = 0; i < wled->cfg.num_strings; ++i) {
  209. rc = regmap_bulk_write(wled->regmap, wled->sink_addr +
  210. WLED4_SINK_REG_BRIGHT(wled->cfg.enabled_strings[i]),
  211. &v, sizeof(v));
  212. if (rc < 0)
  213. return rc;
  214. }
  215. return 0;
  216. }
  217. static int wled5_set_brightness(struct wled *wled, u16 brightness)
  218. {
  219. int rc, offset;
  220. u16 low_limit = wled->max_brightness * 1 / 1000;
  221. __le16 v;
  222. /* WLED5's lower limit is 0.1% */
  223. if (brightness < low_limit)
  224. brightness = low_limit;
  225. v = cpu_to_le16(brightness & WLED5_SINK_REG_BRIGHT_MAX_15B);
  226. offset = (wled->cfg.mod_sel == MOD_A) ?
  227. WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB :
  228. WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB;
  229. rc = regmap_bulk_write(wled->regmap, wled->sink_addr + offset,
  230. &v, sizeof(v));
  231. return rc;
  232. }
  233. static void wled_ovp_work(struct work_struct *work)
  234. {
  235. struct wled *wled = container_of(work,
  236. struct wled, ovp_work.work);
  237. enable_irq(wled->ovp_irq);
  238. }
  239. static int wled_module_enable(struct wled *wled, int val)
  240. {
  241. int rc;
  242. if (wled->disabled_by_short)
  243. return -ENXIO;
  244. rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
  245. WLED3_CTRL_REG_MOD_EN,
  246. WLED3_CTRL_REG_MOD_EN_MASK,
  247. val << WLED3_CTRL_REG_MOD_EN_SHIFT);
  248. if (rc < 0)
  249. return rc;
  250. if (wled->ovp_irq > 0) {
  251. if (val) {
  252. /*
  253. * The hardware generates a storm of spurious OVP
  254. * interrupts during soft start operations. So defer
  255. * enabling the IRQ for 10ms to ensure that the
  256. * soft start is complete.
  257. */
  258. schedule_delayed_work(&wled->ovp_work, HZ / 100);
  259. } else {
  260. if (!cancel_delayed_work_sync(&wled->ovp_work))
  261. disable_irq(wled->ovp_irq);
  262. }
  263. }
  264. return 0;
  265. }
  266. static int wled3_sync_toggle(struct wled *wled)
  267. {
  268. int rc;
  269. unsigned int mask = GENMASK(wled->max_string_count - 1, 0);
  270. rc = regmap_update_bits(wled->regmap,
  271. wled->sink_addr + WLED3_SINK_REG_SYNC,
  272. mask, mask);
  273. if (rc < 0)
  274. return rc;
  275. rc = regmap_update_bits(wled->regmap,
  276. wled->sink_addr + WLED3_SINK_REG_SYNC,
  277. mask, WLED3_SINK_REG_SYNC_CLEAR);
  278. return rc;
  279. }
  280. static int wled5_mod_sync_toggle(struct wled *wled)
  281. {
  282. int rc;
  283. u8 val;
  284. val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_SYNC_MOD_A_BIT :
  285. WLED5_SINK_REG_SYNC_MOD_B_BIT;
  286. rc = regmap_update_bits(wled->regmap,
  287. wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
  288. WLED5_SINK_REG_SYNC_MASK, val);
  289. if (rc < 0)
  290. return rc;
  291. return regmap_update_bits(wled->regmap,
  292. wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
  293. WLED5_SINK_REG_SYNC_MASK, 0);
  294. }
  295. static int wled_ovp_fault_status(struct wled *wled, bool *fault_set)
  296. {
  297. int rc;
  298. u32 int_rt_sts, fault_sts;
  299. *fault_set = false;
  300. rc = regmap_read(wled->regmap,
  301. wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS,
  302. &int_rt_sts);
  303. if (rc < 0) {
  304. dev_err(wled->dev, "Failed to read INT_RT_STS rc=%d\n", rc);
  305. return rc;
  306. }
  307. rc = regmap_read(wled->regmap,
  308. wled->ctrl_addr + WLED3_CTRL_REG_FAULT_STATUS,
  309. &fault_sts);
  310. if (rc < 0) {
  311. dev_err(wled->dev, "Failed to read FAULT_STATUS rc=%d\n", rc);
  312. return rc;
  313. }
  314. if (int_rt_sts & WLED3_CTRL_REG_OVP_FAULT_STATUS)
  315. *fault_set = true;
  316. if (wled->version == 4 && (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT))
  317. *fault_set = true;
  318. if (wled->version == 5 && (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
  319. WLED5_CTRL_REG_OVP_PRE_ALARM_BIT)))
  320. *fault_set = true;
  321. if (*fault_set)
  322. dev_dbg(wled->dev, "WLED OVP fault detected, int_rt_sts=0x%x fault_sts=0x%x\n",
  323. int_rt_sts, fault_sts);
  324. return rc;
  325. }
  326. static int wled4_ovp_delay(struct wled *wled)
  327. {
  328. return WLED_SOFT_START_DLY_US;
  329. }
  330. static int wled5_ovp_delay(struct wled *wled)
  331. {
  332. int rc, delay_us;
  333. u32 val;
  334. u8 ovp_timer_ms[8] = {1, 2, 4, 8, 12, 16, 20, 24};
  335. /* For WLED5, get the delay based on OVP timer */
  336. rc = regmap_read(wled->regmap, wled->ctrl_addr +
  337. WLED5_CTRL_REG_OVP_INT_CTL, &val);
  338. if (rc < 0)
  339. delay_us =
  340. ovp_timer_ms[val & WLED5_CTRL_REG_OVP_INT_TIMER_MASK] * 1000;
  341. else
  342. delay_us = 2 * WLED_SOFT_START_DLY_US;
  343. dev_dbg(wled->dev, "delay_time_us: %d\n", delay_us);
  344. return delay_us;
  345. }
  346. static int wled_update_status(struct backlight_device *bl)
  347. {
  348. struct wled *wled = bl_get_data(bl);
  349. u16 brightness = backlight_get_brightness(bl);
  350. int rc = 0;
  351. mutex_lock(&wled->lock);
  352. if (brightness) {
  353. rc = wled->wled_set_brightness(wled, brightness);
  354. if (rc < 0) {
  355. dev_err(wled->dev, "wled failed to set brightness rc:%d\n",
  356. rc);
  357. goto unlock_mutex;
  358. }
  359. if (wled->version < 5) {
  360. rc = wled->wled_sync_toggle(wled);
  361. if (rc < 0) {
  362. dev_err(wled->dev, "wled sync failed rc:%d\n", rc);
  363. goto unlock_mutex;
  364. }
  365. } else {
  366. /*
  367. * For WLED5 toggling the MOD_SYNC_BIT updates the
  368. * brightness
  369. */
  370. rc = wled5_mod_sync_toggle(wled);
  371. if (rc < 0) {
  372. dev_err(wled->dev, "wled mod sync failed rc:%d\n",
  373. rc);
  374. goto unlock_mutex;
  375. }
  376. }
  377. }
  378. if (!!brightness != !!wled->brightness) {
  379. rc = wled_module_enable(wled, !!brightness);
  380. if (rc < 0) {
  381. dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
  382. goto unlock_mutex;
  383. }
  384. }
  385. wled->brightness = brightness;
  386. unlock_mutex:
  387. mutex_unlock(&wled->lock);
  388. return rc;
  389. }
  390. static int wled4_cabc_config(struct wled *wled, bool enable)
  391. {
  392. int i, j, rc;
  393. u8 val;
  394. for (i = 0; i < wled->cfg.num_strings; i++) {
  395. j = wled->cfg.enabled_strings[i];
  396. val = enable ? WLED4_SINK_REG_STR_CABC_MASK : 0;
  397. rc = regmap_update_bits(wled->regmap, wled->sink_addr +
  398. WLED4_SINK_REG_STR_CABC(j),
  399. WLED4_SINK_REG_STR_CABC_MASK, val);
  400. if (rc < 0)
  401. return rc;
  402. }
  403. return 0;
  404. }
  405. static int wled5_cabc_config(struct wled *wled, bool enable)
  406. {
  407. int rc, offset;
  408. u8 reg;
  409. if (wled->cabc_disabled)
  410. return 0;
  411. reg = enable ? wled->cfg.cabc_sel : 0;
  412. offset = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_A_SRC_SEL :
  413. WLED5_SINK_REG_MOD_B_SRC_SEL;
  414. rc = regmap_update_bits(wled->regmap, wled->sink_addr + offset,
  415. WLED5_SINK_REG_MOD_SRC_SEL_MASK, reg);
  416. if (rc < 0) {
  417. pr_err("Error in configuring CABC rc=%d\n", rc);
  418. return rc;
  419. }
  420. if (!wled->cfg.cabc_sel)
  421. wled->cabc_disabled = true;
  422. return 0;
  423. }
  424. #define WLED_SHORT_DLY_MS 20
  425. #define WLED_SHORT_CNT_MAX 5
  426. #define WLED_SHORT_RESET_CNT_DLY_US USEC_PER_SEC
  427. static irqreturn_t wled_short_irq_handler(int irq, void *_wled)
  428. {
  429. struct wled *wled = _wled;
  430. int rc;
  431. s64 elapsed_time;
  432. wled->short_count++;
  433. mutex_lock(&wled->lock);
  434. rc = wled_module_enable(wled, false);
  435. if (rc < 0) {
  436. dev_err(wled->dev, "wled disable failed rc:%d\n", rc);
  437. goto unlock_mutex;
  438. }
  439. elapsed_time = ktime_us_delta(ktime_get(),
  440. wled->last_short_event);
  441. if (elapsed_time > WLED_SHORT_RESET_CNT_DLY_US)
  442. wled->short_count = 1;
  443. if (wled->short_count > WLED_SHORT_CNT_MAX) {
  444. dev_err(wled->dev, "Short triggered %d times, disabling WLED forever!\n",
  445. wled->short_count);
  446. wled->disabled_by_short = true;
  447. goto unlock_mutex;
  448. }
  449. wled->last_short_event = ktime_get();
  450. msleep(WLED_SHORT_DLY_MS);
  451. rc = wled_module_enable(wled, true);
  452. if (rc < 0)
  453. dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
  454. unlock_mutex:
  455. mutex_unlock(&wled->lock);
  456. return IRQ_HANDLED;
  457. }
  458. #define AUTO_DETECT_BRIGHTNESS 200
  459. static void wled_auto_string_detection(struct wled *wled)
  460. {
  461. int rc = 0, i, j, delay_time_us;
  462. u32 sink_config = 0;
  463. u8 sink_test = 0, sink_valid = 0, val;
  464. bool fault_set;
  465. /* Read configured sink configuration */
  466. rc = regmap_read(wled->regmap, wled->sink_addr +
  467. WLED4_SINK_REG_CURR_SINK, &sink_config);
  468. if (rc < 0) {
  469. dev_err(wled->dev, "Failed to read SINK configuration rc=%d\n",
  470. rc);
  471. goto failed_detect;
  472. }
  473. /* Disable the module before starting detection */
  474. rc = regmap_update_bits(wled->regmap,
  475. wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
  476. WLED3_CTRL_REG_MOD_EN_MASK, 0);
  477. if (rc < 0) {
  478. dev_err(wled->dev, "Failed to disable WLED module rc=%d\n", rc);
  479. goto failed_detect;
  480. }
  481. /* Set low brightness across all sinks */
  482. rc = wled4_set_brightness(wled, AUTO_DETECT_BRIGHTNESS);
  483. if (rc < 0) {
  484. dev_err(wled->dev, "Failed to set brightness for auto detection rc=%d\n",
  485. rc);
  486. goto failed_detect;
  487. }
  488. if (wled->cfg.cabc) {
  489. rc = wled->wled_cabc_config(wled, false);
  490. if (rc < 0)
  491. goto failed_detect;
  492. }
  493. /* Disable all sinks */
  494. rc = regmap_write(wled->regmap,
  495. wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 0);
  496. if (rc < 0) {
  497. dev_err(wled->dev, "Failed to disable all sinks rc=%d\n", rc);
  498. goto failed_detect;
  499. }
  500. /* Iterate through the strings one by one */
  501. for (i = 0; i < wled->cfg.num_strings; i++) {
  502. j = wled->cfg.enabled_strings[i];
  503. sink_test = BIT((WLED4_SINK_REG_CURR_SINK_SHFT + j));
  504. /* Enable feedback control */
  505. rc = regmap_write(wled->regmap, wled->ctrl_addr +
  506. WLED3_CTRL_REG_FEEDBACK_CONTROL, j + 1);
  507. if (rc < 0) {
  508. dev_err(wled->dev, "Failed to enable feedback for SINK %d rc = %d\n",
  509. j + 1, rc);
  510. goto failed_detect;
  511. }
  512. /* Enable the sink */
  513. rc = regmap_write(wled->regmap, wled->sink_addr +
  514. WLED4_SINK_REG_CURR_SINK, sink_test);
  515. if (rc < 0) {
  516. dev_err(wled->dev, "Failed to configure SINK %d rc=%d\n",
  517. j + 1, rc);
  518. goto failed_detect;
  519. }
  520. /* Enable the module */
  521. rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
  522. WLED3_CTRL_REG_MOD_EN,
  523. WLED3_CTRL_REG_MOD_EN_MASK,
  524. WLED3_CTRL_REG_MOD_EN_MASK);
  525. if (rc < 0) {
  526. dev_err(wled->dev, "Failed to enable WLED module rc=%d\n",
  527. rc);
  528. goto failed_detect;
  529. }
  530. delay_time_us = wled->wled_ovp_delay(wled);
  531. usleep_range(delay_time_us, delay_time_us + 1000);
  532. rc = wled_ovp_fault_status(wled, &fault_set);
  533. if (rc < 0) {
  534. dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n",
  535. rc);
  536. goto failed_detect;
  537. }
  538. if (fault_set)
  539. dev_dbg(wled->dev, "WLED OVP fault detected with SINK %d\n",
  540. j + 1);
  541. else
  542. sink_valid |= sink_test;
  543. /* Disable the module */
  544. rc = regmap_update_bits(wled->regmap,
  545. wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
  546. WLED3_CTRL_REG_MOD_EN_MASK, 0);
  547. if (rc < 0) {
  548. dev_err(wled->dev, "Failed to disable WLED module rc=%d\n",
  549. rc);
  550. goto failed_detect;
  551. }
  552. }
  553. if (!sink_valid) {
  554. dev_err(wled->dev, "No valid WLED sinks found\n");
  555. wled->disabled_by_short = true;
  556. goto failed_detect;
  557. }
  558. if (sink_valid != sink_config) {
  559. dev_warn(wled->dev, "%x is not a valid sink configuration - using %x instead\n",
  560. sink_config, sink_valid);
  561. sink_config = sink_valid;
  562. }
  563. /* Write the new sink configuration */
  564. rc = regmap_write(wled->regmap,
  565. wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
  566. sink_config);
  567. if (rc < 0) {
  568. dev_err(wled->dev, "Failed to reconfigure the default sink rc=%d\n",
  569. rc);
  570. goto failed_detect;
  571. }
  572. /* Enable valid sinks */
  573. if (wled->version == 4) {
  574. for (i = 0; i < wled->cfg.num_strings; i++) {
  575. j = wled->cfg.enabled_strings[i];
  576. if (sink_config &
  577. BIT(WLED4_SINK_REG_CURR_SINK_SHFT + j))
  578. val = WLED4_SINK_REG_STR_MOD_MASK;
  579. else
  580. /* Disable modulator_en for unused sink */
  581. val = 0;
  582. rc = regmap_write(wled->regmap, wled->sink_addr +
  583. WLED4_SINK_REG_STR_MOD_EN(j), val);
  584. if (rc < 0) {
  585. dev_err(wled->dev, "Failed to configure MODULATOR_EN rc=%d\n",
  586. rc);
  587. goto failed_detect;
  588. }
  589. }
  590. }
  591. /* Enable CABC */
  592. rc = wled->wled_cabc_config(wled, true);
  593. if (rc < 0)
  594. goto failed_detect;
  595. /* Restore the feedback setting */
  596. rc = regmap_write(wled->regmap,
  597. wled->ctrl_addr + WLED3_CTRL_REG_FEEDBACK_CONTROL, 0);
  598. if (rc < 0) {
  599. dev_err(wled->dev, "Failed to restore feedback setting rc=%d\n",
  600. rc);
  601. goto failed_detect;
  602. }
  603. /* Restore brightness */
  604. rc = wled4_set_brightness(wled, wled->brightness);
  605. if (rc < 0) {
  606. dev_err(wled->dev, "Failed to set brightness after auto detection rc=%d\n",
  607. rc);
  608. goto failed_detect;
  609. }
  610. rc = regmap_update_bits(wled->regmap,
  611. wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
  612. WLED3_CTRL_REG_MOD_EN_MASK,
  613. WLED3_CTRL_REG_MOD_EN_MASK);
  614. if (rc < 0) {
  615. dev_err(wled->dev, "Failed to enable WLED module rc=%d\n", rc);
  616. goto failed_detect;
  617. }
  618. failed_detect:
  619. return;
  620. }
  621. #define WLED_AUTO_DETECT_OVP_COUNT 5
  622. #define WLED_AUTO_DETECT_CNT_DLY_US USEC_PER_SEC
  623. static bool wled4_auto_detection_required(struct wled *wled)
  624. {
  625. s64 elapsed_time_us;
  626. if (!wled->cfg.auto_detection_enabled)
  627. return false;
  628. /*
  629. * Check if the OVP fault was an occasional one
  630. * or if it's firing continuously, the latter qualifies
  631. * for an auto-detection check.
  632. */
  633. if (!wled->auto_detection_ovp_count) {
  634. wled->start_ovp_fault_time = ktime_get();
  635. wled->auto_detection_ovp_count++;
  636. } else {
  637. elapsed_time_us = ktime_us_delta(ktime_get(),
  638. wled->start_ovp_fault_time);
  639. if (elapsed_time_us > WLED_AUTO_DETECT_CNT_DLY_US)
  640. wled->auto_detection_ovp_count = 0;
  641. else
  642. wled->auto_detection_ovp_count++;
  643. if (wled->auto_detection_ovp_count >=
  644. WLED_AUTO_DETECT_OVP_COUNT) {
  645. wled->auto_detection_ovp_count = 0;
  646. return true;
  647. }
  648. }
  649. return false;
  650. }
  651. static bool wled5_auto_detection_required(struct wled *wled)
  652. {
  653. if (!wled->cfg.auto_detection_enabled)
  654. return false;
  655. /*
  656. * Unlike WLED4, WLED5 has OVP fault density interrupt configuration
  657. * i.e. to count the number of OVP alarms for a certain duration before
  658. * triggering OVP fault interrupt. By default, number of OVP fault
  659. * events counted before an interrupt is fired is 32 and the time
  660. * interval is 12 ms. If we see one OVP fault interrupt, then that
  661. * should qualify for a real OVP fault condition to run auto detection
  662. * algorithm.
  663. */
  664. return true;
  665. }
  666. static int wled_auto_detection_at_init(struct wled *wled)
  667. {
  668. int rc;
  669. bool fault_set;
  670. if (!wled->cfg.auto_detection_enabled)
  671. return 0;
  672. rc = wled_ovp_fault_status(wled, &fault_set);
  673. if (rc < 0) {
  674. dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n",
  675. rc);
  676. return rc;
  677. }
  678. if (fault_set) {
  679. mutex_lock(&wled->lock);
  680. wled_auto_string_detection(wled);
  681. mutex_unlock(&wled->lock);
  682. }
  683. return rc;
  684. }
  685. static irqreturn_t wled_ovp_irq_handler(int irq, void *_wled)
  686. {
  687. struct wled *wled = _wled;
  688. int rc;
  689. u32 int_sts, fault_sts;
  690. rc = regmap_read(wled->regmap,
  691. wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS, &int_sts);
  692. if (rc < 0) {
  693. dev_err(wled->dev, "Error in reading WLED3_INT_RT_STS rc=%d\n",
  694. rc);
  695. return IRQ_HANDLED;
  696. }
  697. rc = regmap_read(wled->regmap, wled->ctrl_addr +
  698. WLED3_CTRL_REG_FAULT_STATUS, &fault_sts);
  699. if (rc < 0) {
  700. dev_err(wled->dev, "Error in reading WLED_FAULT_STATUS rc=%d\n",
  701. rc);
  702. return IRQ_HANDLED;
  703. }
  704. if (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
  705. WLED3_CTRL_REG_ILIM_FAULT_BIT))
  706. dev_dbg(wled->dev, "WLED OVP fault detected, int_sts=%x fault_sts= %x\n",
  707. int_sts, fault_sts);
  708. if (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT) {
  709. if (wled->wled_auto_detection_required(wled)) {
  710. mutex_lock(&wled->lock);
  711. wled_auto_string_detection(wled);
  712. mutex_unlock(&wled->lock);
  713. }
  714. }
  715. return IRQ_HANDLED;
  716. }
  717. static int wled3_setup(struct wled *wled)
  718. {
  719. u16 addr;
  720. u8 sink_en = 0;
  721. int rc, i, j;
  722. rc = regmap_update_bits(wled->regmap,
  723. wled->ctrl_addr + WLED3_CTRL_REG_OVP,
  724. WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
  725. if (rc)
  726. return rc;
  727. rc = regmap_update_bits(wled->regmap,
  728. wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
  729. WLED3_CTRL_REG_ILIMIT_MASK,
  730. wled->cfg.boost_i_limit);
  731. if (rc)
  732. return rc;
  733. rc = regmap_update_bits(wled->regmap,
  734. wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
  735. WLED3_CTRL_REG_FREQ_MASK,
  736. wled->cfg.switch_freq);
  737. if (rc)
  738. return rc;
  739. for (i = 0; i < wled->cfg.num_strings; ++i) {
  740. j = wled->cfg.enabled_strings[i];
  741. addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_EN(j);
  742. rc = regmap_update_bits(wled->regmap, addr,
  743. WLED3_SINK_REG_STR_MOD_MASK,
  744. WLED3_SINK_REG_STR_MOD_MASK);
  745. if (rc)
  746. return rc;
  747. if (wled->cfg.ext_gen) {
  748. addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_SRC(j);
  749. rc = regmap_update_bits(wled->regmap, addr,
  750. WLED3_SINK_REG_STR_MOD_SRC_MASK,
  751. WLED3_SINK_REG_STR_MOD_SRC_EXT);
  752. if (rc)
  753. return rc;
  754. }
  755. addr = wled->ctrl_addr + WLED3_SINK_REG_STR_FULL_SCALE_CURR(j);
  756. rc = regmap_update_bits(wled->regmap, addr,
  757. WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK,
  758. wled->cfg.string_i_limit);
  759. if (rc)
  760. return rc;
  761. addr = wled->ctrl_addr + WLED3_SINK_REG_STR_CABC(j);
  762. rc = regmap_update_bits(wled->regmap, addr,
  763. WLED3_SINK_REG_STR_CABC_MASK,
  764. wled->cfg.cabc ?
  765. WLED3_SINK_REG_STR_CABC_MASK : 0);
  766. if (rc)
  767. return rc;
  768. sink_en |= BIT(j + WLED3_SINK_REG_CURR_SINK_SHFT);
  769. }
  770. rc = regmap_update_bits(wled->regmap,
  771. wled->ctrl_addr + WLED3_SINK_REG_CURR_SINK,
  772. WLED3_SINK_REG_CURR_SINK_MASK, sink_en);
  773. if (rc)
  774. return rc;
  775. return 0;
  776. }
  777. static const struct wled_config wled3_config_defaults = {
  778. .boost_i_limit = 3,
  779. .string_i_limit = 20,
  780. .ovp = 2,
  781. .num_strings = 3,
  782. .switch_freq = 5,
  783. .cs_out_en = false,
  784. .ext_gen = false,
  785. .cabc = false,
  786. .enabled_strings = {0, 1, 2, 3},
  787. };
  788. static int wled4_setup(struct wled *wled)
  789. {
  790. int rc, temp, i, j;
  791. u16 addr;
  792. u8 sink_en = 0;
  793. u32 sink_cfg;
  794. rc = regmap_update_bits(wled->regmap,
  795. wled->ctrl_addr + WLED3_CTRL_REG_OVP,
  796. WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
  797. if (rc < 0)
  798. return rc;
  799. rc = regmap_update_bits(wled->regmap,
  800. wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
  801. WLED3_CTRL_REG_ILIMIT_MASK,
  802. wled->cfg.boost_i_limit);
  803. if (rc < 0)
  804. return rc;
  805. rc = regmap_update_bits(wled->regmap,
  806. wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
  807. WLED3_CTRL_REG_FREQ_MASK,
  808. wled->cfg.switch_freq);
  809. if (rc < 0)
  810. return rc;
  811. if (wled->cfg.external_pfet) {
  812. /* Unlock the secure register access */
  813. rc = regmap_write(wled->regmap, wled->ctrl_addr +
  814. WLED4_CTRL_REG_SEC_ACCESS,
  815. WLED4_CTRL_REG_SEC_UNLOCK);
  816. if (rc < 0)
  817. return rc;
  818. rc = regmap_write(wled->regmap,
  819. wled->ctrl_addr + WLED4_CTRL_REG_TEST1,
  820. WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2);
  821. if (rc < 0)
  822. return rc;
  823. }
  824. rc = regmap_read(wled->regmap, wled->sink_addr +
  825. WLED4_SINK_REG_CURR_SINK, &sink_cfg);
  826. if (rc < 0)
  827. return rc;
  828. for (i = 0; i < wled->cfg.num_strings; i++) {
  829. j = wled->cfg.enabled_strings[i];
  830. temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
  831. sink_en |= 1 << temp;
  832. }
  833. if (sink_cfg == sink_en) {
  834. rc = wled_auto_detection_at_init(wled);
  835. return rc;
  836. }
  837. rc = regmap_update_bits(wled->regmap,
  838. wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
  839. WLED4_SINK_REG_CURR_SINK_MASK, 0);
  840. if (rc < 0)
  841. return rc;
  842. rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
  843. WLED3_CTRL_REG_MOD_EN,
  844. WLED3_CTRL_REG_MOD_EN_MASK, 0);
  845. if (rc < 0)
  846. return rc;
  847. /* Per sink/string configuration */
  848. for (i = 0; i < wled->cfg.num_strings; i++) {
  849. j = wled->cfg.enabled_strings[i];
  850. addr = wled->sink_addr +
  851. WLED4_SINK_REG_STR_MOD_EN(j);
  852. rc = regmap_update_bits(wled->regmap, addr,
  853. WLED4_SINK_REG_STR_MOD_MASK,
  854. WLED4_SINK_REG_STR_MOD_MASK);
  855. if (rc < 0)
  856. return rc;
  857. addr = wled->sink_addr +
  858. WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
  859. rc = regmap_update_bits(wled->regmap, addr,
  860. WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
  861. wled->cfg.string_i_limit);
  862. if (rc < 0)
  863. return rc;
  864. }
  865. rc = wled4_cabc_config(wled, wled->cfg.cabc);
  866. if (rc < 0)
  867. return rc;
  868. rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
  869. WLED3_CTRL_REG_MOD_EN,
  870. WLED3_CTRL_REG_MOD_EN_MASK,
  871. WLED3_CTRL_REG_MOD_EN_MASK);
  872. if (rc < 0)
  873. return rc;
  874. rc = regmap_update_bits(wled->regmap,
  875. wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
  876. WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
  877. if (rc < 0)
  878. return rc;
  879. rc = wled->wled_sync_toggle(wled);
  880. if (rc < 0) {
  881. dev_err(wled->dev, "Failed to toggle sync reg rc:%d\n", rc);
  882. return rc;
  883. }
  884. rc = wled_auto_detection_at_init(wled);
  885. return rc;
  886. }
  887. static const struct wled_config wled4_config_defaults = {
  888. .boost_i_limit = 4,
  889. .string_i_limit = 10,
  890. .ovp = 1,
  891. .num_strings = 4,
  892. .switch_freq = 11,
  893. .cabc = false,
  894. .external_pfet = false,
  895. .auto_detection_enabled = false,
  896. };
  897. static int wled5_setup(struct wled *wled)
  898. {
  899. int rc, temp, i, j, offset;
  900. u8 sink_en = 0;
  901. u16 addr;
  902. u32 val;
  903. rc = regmap_update_bits(wled->regmap,
  904. wled->ctrl_addr + WLED3_CTRL_REG_OVP,
  905. WLED5_CTRL_REG_OVP_MASK, wled->cfg.ovp);
  906. if (rc < 0)
  907. return rc;
  908. rc = regmap_update_bits(wled->regmap,
  909. wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
  910. WLED3_CTRL_REG_ILIMIT_MASK,
  911. wled->cfg.boost_i_limit);
  912. if (rc < 0)
  913. return rc;
  914. rc = regmap_update_bits(wled->regmap,
  915. wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
  916. WLED3_CTRL_REG_FREQ_MASK,
  917. wled->cfg.switch_freq);
  918. if (rc < 0)
  919. return rc;
  920. /* Per sink/string configuration */
  921. for (i = 0; i < wled->cfg.num_strings; ++i) {
  922. j = wled->cfg.enabled_strings[i];
  923. addr = wled->sink_addr +
  924. WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
  925. rc = regmap_update_bits(wled->regmap, addr,
  926. WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
  927. wled->cfg.string_i_limit);
  928. if (rc < 0)
  929. return rc;
  930. addr = wled->sink_addr + WLED5_SINK_REG_STR_SRC_SEL(j);
  931. rc = regmap_update_bits(wled->regmap, addr,
  932. WLED5_SINK_REG_SRC_SEL_MASK,
  933. wled->cfg.mod_sel == MOD_A ?
  934. WLED5_SINK_REG_SRC_SEL_MOD_A :
  935. WLED5_SINK_REG_SRC_SEL_MOD_B);
  936. temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
  937. sink_en |= 1 << temp;
  938. }
  939. rc = wled5_cabc_config(wled, wled->cfg.cabc_sel ? true : false);
  940. if (rc < 0)
  941. return rc;
  942. /* Enable one of the modulators A or B based on mod_sel */
  943. addr = wled->sink_addr + WLED5_SINK_REG_MOD_A_EN;
  944. val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
  945. rc = regmap_update_bits(wled->regmap, addr,
  946. WLED5_SINK_REG_MOD_EN_MASK, val);
  947. if (rc < 0)
  948. return rc;
  949. addr = wled->sink_addr + WLED5_SINK_REG_MOD_B_EN;
  950. val = (wled->cfg.mod_sel == MOD_B) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
  951. rc = regmap_update_bits(wled->regmap, addr,
  952. WLED5_SINK_REG_MOD_EN_MASK, val);
  953. if (rc < 0)
  954. return rc;
  955. offset = (wled->cfg.mod_sel == MOD_A) ?
  956. WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL :
  957. WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL;
  958. addr = wled->sink_addr + offset;
  959. val = (wled->max_brightness == WLED5_SINK_REG_BRIGHT_MAX_15B) ?
  960. WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B :
  961. WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B;
  962. rc = regmap_write(wled->regmap, addr, val);
  963. if (rc < 0)
  964. return rc;
  965. rc = regmap_update_bits(wled->regmap,
  966. wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
  967. WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
  968. if (rc < 0)
  969. return rc;
  970. /* This updates only FSC configuration in WLED5 */
  971. rc = wled->wled_sync_toggle(wled);
  972. if (rc < 0) {
  973. pr_err("Failed to toggle sync reg rc:%d\n", rc);
  974. return rc;
  975. }
  976. rc = wled_auto_detection_at_init(wled);
  977. if (rc < 0)
  978. return rc;
  979. return 0;
  980. }
  981. static const struct wled_config wled5_config_defaults = {
  982. .boost_i_limit = 5,
  983. .string_i_limit = 10,
  984. .ovp = 4,
  985. .num_strings = 4,
  986. .switch_freq = 11,
  987. .mod_sel = 0,
  988. .cabc_sel = 0,
  989. .cabc = false,
  990. .external_pfet = false,
  991. .auto_detection_enabled = false,
  992. };
  993. static const u32 wled3_boost_i_limit_values[] = {
  994. 105, 385, 525, 805, 980, 1260, 1400, 1680,
  995. };
  996. static const struct wled_var_cfg wled3_boost_i_limit_cfg = {
  997. .values = wled3_boost_i_limit_values,
  998. .size = ARRAY_SIZE(wled3_boost_i_limit_values),
  999. };
  1000. static const u32 wled4_boost_i_limit_values[] = {
  1001. 105, 280, 450, 620, 970, 1150, 1300, 1500,
  1002. };
  1003. static const struct wled_var_cfg wled4_boost_i_limit_cfg = {
  1004. .values = wled4_boost_i_limit_values,
  1005. .size = ARRAY_SIZE(wled4_boost_i_limit_values),
  1006. };
  1007. static inline u32 wled5_boost_i_limit_values_fn(u32 idx)
  1008. {
  1009. return 525 + (idx * 175);
  1010. }
  1011. static const struct wled_var_cfg wled5_boost_i_limit_cfg = {
  1012. .fn = wled5_boost_i_limit_values_fn,
  1013. .size = 8,
  1014. };
  1015. static const u32 wled3_ovp_values[] = {
  1016. 35, 32, 29, 27,
  1017. };
  1018. static const struct wled_var_cfg wled3_ovp_cfg = {
  1019. .values = wled3_ovp_values,
  1020. .size = ARRAY_SIZE(wled3_ovp_values),
  1021. };
  1022. static const u32 wled4_ovp_values[] = {
  1023. 31100, 29600, 19600, 18100,
  1024. };
  1025. static const struct wled_var_cfg wled4_ovp_cfg = {
  1026. .values = wled4_ovp_values,
  1027. .size = ARRAY_SIZE(wled4_ovp_values),
  1028. };
  1029. static inline u32 wled5_ovp_values_fn(u32 idx)
  1030. {
  1031. /*
  1032. * 0000 - 38.5 V
  1033. * 0001 - 37 V ..
  1034. * 1111 - 16 V
  1035. */
  1036. return 38500 - (idx * 1500);
  1037. }
  1038. static const struct wled_var_cfg wled5_ovp_cfg = {
  1039. .fn = wled5_ovp_values_fn,
  1040. .size = 16,
  1041. };
  1042. static u32 wled3_switch_freq_values_fn(u32 idx)
  1043. {
  1044. return 19200 / (2 * (1 + idx));
  1045. }
  1046. static const struct wled_var_cfg wled3_switch_freq_cfg = {
  1047. .fn = wled3_switch_freq_values_fn,
  1048. .size = 16,
  1049. };
  1050. static const struct wled_var_cfg wled3_string_i_limit_cfg = {
  1051. .size = 26,
  1052. };
  1053. static const u32 wled4_string_i_limit_values[] = {
  1054. 0, 2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000,
  1055. 22500, 25000, 27500, 30000,
  1056. };
  1057. static const struct wled_var_cfg wled4_string_i_limit_cfg = {
  1058. .values = wled4_string_i_limit_values,
  1059. .size = ARRAY_SIZE(wled4_string_i_limit_values),
  1060. };
  1061. static const struct wled_var_cfg wled5_mod_sel_cfg = {
  1062. .size = 2,
  1063. };
  1064. static const struct wled_var_cfg wled5_cabc_sel_cfg = {
  1065. .size = 4,
  1066. };
  1067. static u32 wled_values(const struct wled_var_cfg *cfg, u32 idx)
  1068. {
  1069. if (idx >= cfg->size)
  1070. return UINT_MAX;
  1071. if (cfg->fn)
  1072. return cfg->fn(idx);
  1073. if (cfg->values)
  1074. return cfg->values[idx];
  1075. return idx;
  1076. }
  1077. static int wled_configure(struct wled *wled)
  1078. {
  1079. struct wled_config *cfg = &wled->cfg;
  1080. struct device *dev = wled->dev;
  1081. const __be32 *prop_addr;
  1082. u32 size, val, c;
  1083. int rc, i, j, string_len;
  1084. const struct wled_u32_opts *u32_opts = NULL;
  1085. const struct wled_u32_opts wled3_opts[] = {
  1086. {
  1087. .name = "qcom,current-boost-limit",
  1088. .val_ptr = &cfg->boost_i_limit,
  1089. .cfg = &wled3_boost_i_limit_cfg,
  1090. },
  1091. {
  1092. .name = "qcom,current-limit",
  1093. .val_ptr = &cfg->string_i_limit,
  1094. .cfg = &wled3_string_i_limit_cfg,
  1095. },
  1096. {
  1097. .name = "qcom,ovp",
  1098. .val_ptr = &cfg->ovp,
  1099. .cfg = &wled3_ovp_cfg,
  1100. },
  1101. {
  1102. .name = "qcom,switching-freq",
  1103. .val_ptr = &cfg->switch_freq,
  1104. .cfg = &wled3_switch_freq_cfg,
  1105. },
  1106. };
  1107. const struct wled_u32_opts wled4_opts[] = {
  1108. {
  1109. .name = "qcom,current-boost-limit",
  1110. .val_ptr = &cfg->boost_i_limit,
  1111. .cfg = &wled4_boost_i_limit_cfg,
  1112. },
  1113. {
  1114. .name = "qcom,current-limit-microamp",
  1115. .val_ptr = &cfg->string_i_limit,
  1116. .cfg = &wled4_string_i_limit_cfg,
  1117. },
  1118. {
  1119. .name = "qcom,ovp-millivolt",
  1120. .val_ptr = &cfg->ovp,
  1121. .cfg = &wled4_ovp_cfg,
  1122. },
  1123. {
  1124. .name = "qcom,switching-freq",
  1125. .val_ptr = &cfg->switch_freq,
  1126. .cfg = &wled3_switch_freq_cfg,
  1127. },
  1128. };
  1129. const struct wled_u32_opts wled5_opts[] = {
  1130. {
  1131. .name = "qcom,current-boost-limit",
  1132. .val_ptr = &cfg->boost_i_limit,
  1133. .cfg = &wled5_boost_i_limit_cfg,
  1134. },
  1135. {
  1136. .name = "qcom,current-limit-microamp",
  1137. .val_ptr = &cfg->string_i_limit,
  1138. .cfg = &wled4_string_i_limit_cfg,
  1139. },
  1140. {
  1141. .name = "qcom,ovp-millivolt",
  1142. .val_ptr = &cfg->ovp,
  1143. .cfg = &wled5_ovp_cfg,
  1144. },
  1145. {
  1146. .name = "qcom,switching-freq",
  1147. .val_ptr = &cfg->switch_freq,
  1148. .cfg = &wled3_switch_freq_cfg,
  1149. },
  1150. {
  1151. .name = "qcom,modulator-sel",
  1152. .val_ptr = &cfg->mod_sel,
  1153. .cfg = &wled5_mod_sel_cfg,
  1154. },
  1155. {
  1156. .name = "qcom,cabc-sel",
  1157. .val_ptr = &cfg->cabc_sel,
  1158. .cfg = &wled5_cabc_sel_cfg,
  1159. },
  1160. };
  1161. const struct wled_bool_opts bool_opts[] = {
  1162. { "qcom,cs-out", &cfg->cs_out_en, },
  1163. { "qcom,ext-gen", &cfg->ext_gen, },
  1164. { "qcom,cabc", &cfg->cabc, },
  1165. { "qcom,external-pfet", &cfg->external_pfet, },
  1166. { "qcom,auto-string-detection", &cfg->auto_detection_enabled, },
  1167. };
  1168. prop_addr = of_get_address(dev->of_node, 0, NULL, NULL);
  1169. if (!prop_addr) {
  1170. dev_err(wled->dev, "invalid IO resources\n");
  1171. return -EINVAL;
  1172. }
  1173. wled->ctrl_addr = be32_to_cpu(*prop_addr);
  1174. rc = of_property_read_string(dev->of_node, "label", &wled->name);
  1175. if (rc)
  1176. wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node);
  1177. switch (wled->version) {
  1178. case 3:
  1179. u32_opts = wled3_opts;
  1180. size = ARRAY_SIZE(wled3_opts);
  1181. *cfg = wled3_config_defaults;
  1182. wled->wled_set_brightness = wled3_set_brightness;
  1183. wled->wled_sync_toggle = wled3_sync_toggle;
  1184. wled->max_string_count = 3;
  1185. wled->sink_addr = wled->ctrl_addr;
  1186. break;
  1187. case 4:
  1188. u32_opts = wled4_opts;
  1189. size = ARRAY_SIZE(wled4_opts);
  1190. *cfg = wled4_config_defaults;
  1191. wled->wled_set_brightness = wled4_set_brightness;
  1192. wled->wled_sync_toggle = wled3_sync_toggle;
  1193. wled->wled_cabc_config = wled4_cabc_config;
  1194. wled->wled_ovp_delay = wled4_ovp_delay;
  1195. wled->wled_auto_detection_required =
  1196. wled4_auto_detection_required;
  1197. wled->max_string_count = 4;
  1198. prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
  1199. if (!prop_addr) {
  1200. dev_err(wled->dev, "invalid IO resources\n");
  1201. return -EINVAL;
  1202. }
  1203. wled->sink_addr = be32_to_cpu(*prop_addr);
  1204. break;
  1205. case 5:
  1206. u32_opts = wled5_opts;
  1207. size = ARRAY_SIZE(wled5_opts);
  1208. *cfg = wled5_config_defaults;
  1209. wled->wled_set_brightness = wled5_set_brightness;
  1210. wled->wled_sync_toggle = wled3_sync_toggle;
  1211. wled->wled_cabc_config = wled5_cabc_config;
  1212. wled->wled_ovp_delay = wled5_ovp_delay;
  1213. wled->wled_auto_detection_required =
  1214. wled5_auto_detection_required;
  1215. wled->max_string_count = 4;
  1216. prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
  1217. if (!prop_addr) {
  1218. dev_err(wled->dev, "invalid IO resources\n");
  1219. return -EINVAL;
  1220. }
  1221. wled->sink_addr = be32_to_cpu(*prop_addr);
  1222. break;
  1223. default:
  1224. dev_err(wled->dev, "Invalid WLED version\n");
  1225. return -EINVAL;
  1226. }
  1227. for (i = 0; i < size; ++i) {
  1228. rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
  1229. if (rc == -EINVAL) {
  1230. continue;
  1231. } else if (rc) {
  1232. dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
  1233. return rc;
  1234. }
  1235. c = UINT_MAX;
  1236. for (j = 0; c != val; j++) {
  1237. c = wled_values(u32_opts[i].cfg, j);
  1238. if (c == UINT_MAX) {
  1239. dev_err(dev, "invalid value for '%s'\n",
  1240. u32_opts[i].name);
  1241. return -EINVAL;
  1242. }
  1243. if (c == val)
  1244. break;
  1245. }
  1246. dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
  1247. *u32_opts[i].val_ptr = j;
  1248. }
  1249. for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
  1250. if (of_property_read_bool(dev->of_node, bool_opts[i].name))
  1251. *bool_opts[i].val_ptr = true;
  1252. }
  1253. string_len = of_property_count_elems_of_size(dev->of_node,
  1254. "qcom,enabled-strings",
  1255. sizeof(u32));
  1256. if (string_len > 0) {
  1257. if (string_len > wled->max_string_count) {
  1258. dev_err(dev, "Cannot have more than %d strings\n",
  1259. wled->max_string_count);
  1260. return -EINVAL;
  1261. }
  1262. rc = of_property_read_u32_array(dev->of_node,
  1263. "qcom,enabled-strings",
  1264. wled->cfg.enabled_strings,
  1265. string_len);
  1266. if (rc) {
  1267. dev_err(dev, "Failed to read %d elements from qcom,enabled-strings: %d\n",
  1268. string_len, rc);
  1269. return rc;
  1270. }
  1271. for (i = 0; i < string_len; ++i) {
  1272. if (wled->cfg.enabled_strings[i] >= wled->max_string_count) {
  1273. dev_err(dev,
  1274. "qcom,enabled-strings index %d at %d is out of bounds\n",
  1275. wled->cfg.enabled_strings[i], i);
  1276. return -EINVAL;
  1277. }
  1278. }
  1279. cfg->num_strings = string_len;
  1280. }
  1281. rc = of_property_read_u32(dev->of_node, "qcom,num-strings", &val);
  1282. if (!rc) {
  1283. if (val < 1 || val > wled->max_string_count) {
  1284. dev_err(dev, "qcom,num-strings must be between 1 and %d\n",
  1285. wled->max_string_count);
  1286. return -EINVAL;
  1287. }
  1288. if (string_len > 0) {
  1289. dev_warn(dev, "Only one of qcom,num-strings or qcom,enabled-strings"
  1290. " should be set\n");
  1291. if (val > string_len) {
  1292. dev_err(dev, "qcom,num-strings exceeds qcom,enabled-strings\n");
  1293. return -EINVAL;
  1294. }
  1295. }
  1296. cfg->num_strings = val;
  1297. }
  1298. return 0;
  1299. }
  1300. static int wled_configure_short_irq(struct wled *wled,
  1301. struct platform_device *pdev)
  1302. {
  1303. int rc;
  1304. if (!wled->has_short_detect)
  1305. return 0;
  1306. rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
  1307. WLED4_CTRL_REG_SHORT_PROTECT,
  1308. WLED4_CTRL_REG_SHORT_EN_MASK,
  1309. WLED4_CTRL_REG_SHORT_EN_MASK);
  1310. if (rc < 0)
  1311. return rc;
  1312. wled->short_irq = platform_get_irq_byname(pdev, "short");
  1313. if (wled->short_irq < 0) {
  1314. dev_dbg(&pdev->dev, "short irq is not used\n");
  1315. return 0;
  1316. }
  1317. rc = devm_request_threaded_irq(wled->dev, wled->short_irq,
  1318. NULL, wled_short_irq_handler,
  1319. IRQF_ONESHOT,
  1320. "wled_short_irq", wled);
  1321. if (rc < 0)
  1322. dev_err(wled->dev, "Unable to request short_irq (err:%d)\n",
  1323. rc);
  1324. return rc;
  1325. }
  1326. static int wled_configure_ovp_irq(struct wled *wled,
  1327. struct platform_device *pdev)
  1328. {
  1329. int rc;
  1330. u32 val;
  1331. wled->ovp_irq = platform_get_irq_byname(pdev, "ovp");
  1332. if (wled->ovp_irq < 0) {
  1333. dev_dbg(&pdev->dev, "OVP IRQ not found - disabling automatic string detection\n");
  1334. return 0;
  1335. }
  1336. rc = devm_request_threaded_irq(wled->dev, wled->ovp_irq, NULL,
  1337. wled_ovp_irq_handler, IRQF_ONESHOT,
  1338. "wled_ovp_irq", wled);
  1339. if (rc < 0) {
  1340. dev_err(wled->dev, "Unable to request ovp_irq (err:%d)\n",
  1341. rc);
  1342. wled->ovp_irq = 0;
  1343. return 0;
  1344. }
  1345. rc = regmap_read(wled->regmap, wled->ctrl_addr +
  1346. WLED3_CTRL_REG_MOD_EN, &val);
  1347. if (rc < 0)
  1348. return rc;
  1349. /* Keep OVP irq disabled until module is enabled */
  1350. if (!(val & WLED3_CTRL_REG_MOD_EN_MASK))
  1351. disable_irq(wled->ovp_irq);
  1352. return 0;
  1353. }
  1354. static const struct backlight_ops wled_ops = {
  1355. .update_status = wled_update_status,
  1356. };
  1357. static int wled_probe(struct platform_device *pdev)
  1358. {
  1359. struct backlight_properties props;
  1360. struct backlight_device *bl;
  1361. struct wled *wled;
  1362. struct regmap *regmap;
  1363. u32 val;
  1364. int rc;
  1365. regmap = dev_get_regmap(pdev->dev.parent, NULL);
  1366. if (!regmap) {
  1367. dev_err(&pdev->dev, "Unable to get regmap\n");
  1368. return -EINVAL;
  1369. }
  1370. wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL);
  1371. if (!wled)
  1372. return -ENOMEM;
  1373. wled->regmap = regmap;
  1374. wled->dev = &pdev->dev;
  1375. wled->version = (uintptr_t)of_device_get_match_data(&pdev->dev);
  1376. if (!wled->version) {
  1377. dev_err(&pdev->dev, "Unknown device version\n");
  1378. return -ENODEV;
  1379. }
  1380. mutex_init(&wled->lock);
  1381. rc = wled_configure(wled);
  1382. if (rc)
  1383. return rc;
  1384. val = WLED3_SINK_REG_BRIGHT_MAX;
  1385. of_property_read_u32(pdev->dev.of_node, "max-brightness", &val);
  1386. wled->max_brightness = val;
  1387. switch (wled->version) {
  1388. case 3:
  1389. wled->cfg.auto_detection_enabled = false;
  1390. rc = wled3_setup(wled);
  1391. if (rc) {
  1392. dev_err(&pdev->dev, "wled3_setup failed\n");
  1393. return rc;
  1394. }
  1395. break;
  1396. case 4:
  1397. wled->has_short_detect = true;
  1398. rc = wled4_setup(wled);
  1399. if (rc) {
  1400. dev_err(&pdev->dev, "wled4_setup failed\n");
  1401. return rc;
  1402. }
  1403. break;
  1404. case 5:
  1405. wled->has_short_detect = true;
  1406. if (wled->cfg.cabc_sel)
  1407. wled->max_brightness = WLED5_SINK_REG_BRIGHT_MAX_12B;
  1408. rc = wled5_setup(wled);
  1409. if (rc) {
  1410. dev_err(&pdev->dev, "wled5_setup failed\n");
  1411. return rc;
  1412. }
  1413. break;
  1414. default:
  1415. dev_err(wled->dev, "Invalid WLED version\n");
  1416. break;
  1417. }
  1418. INIT_DELAYED_WORK(&wled->ovp_work, wled_ovp_work);
  1419. rc = wled_configure_short_irq(wled, pdev);
  1420. if (rc < 0)
  1421. return rc;
  1422. rc = wled_configure_ovp_irq(wled, pdev);
  1423. if (rc < 0)
  1424. return rc;
  1425. val = WLED_DEFAULT_BRIGHTNESS;
  1426. of_property_read_u32(pdev->dev.of_node, "default-brightness", &val);
  1427. memset(&props, 0, sizeof(struct backlight_properties));
  1428. props.type = BACKLIGHT_RAW;
  1429. props.brightness = val;
  1430. props.max_brightness = wled->max_brightness;
  1431. bl = devm_backlight_device_register(&pdev->dev, wled->name,
  1432. &pdev->dev, wled,
  1433. &wled_ops, &props);
  1434. return PTR_ERR_OR_ZERO(bl);
  1435. };
  1436. static int wled_remove(struct platform_device *pdev)
  1437. {
  1438. struct wled *wled = dev_get_drvdata(&pdev->dev);
  1439. mutex_destroy(&wled->lock);
  1440. cancel_delayed_work_sync(&wled->ovp_work);
  1441. disable_irq(wled->short_irq);
  1442. disable_irq(wled->ovp_irq);
  1443. return 0;
  1444. }
  1445. static const struct of_device_id wled_match_table[] = {
  1446. { .compatible = "qcom,pm8941-wled", .data = (void *)3 },
  1447. { .compatible = "qcom,pmi8998-wled", .data = (void *)4 },
  1448. { .compatible = "qcom,pm660l-wled", .data = (void *)4 },
  1449. { .compatible = "qcom,pm8150l-wled", .data = (void *)5 },
  1450. {}
  1451. };
  1452. MODULE_DEVICE_TABLE(of, wled_match_table);
  1453. static struct platform_driver wled_driver = {
  1454. .probe = wled_probe,
  1455. .remove = wled_remove,
  1456. .driver = {
  1457. .name = "qcom,wled",
  1458. .of_match_table = wled_match_table,
  1459. },
  1460. };
  1461. module_platform_driver(wled_driver);
  1462. MODULE_DESCRIPTION("Qualcomm WLED driver");
  1463. MODULE_LICENSE("GPL v2");