leds-netxbig.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs
  4. *
  5. * Copyright (C) 2010 LaCie
  6. *
  7. * Author: Simon Guinot <sguinot@lacie.com>
  8. */
  9. #include <linux/module.h>
  10. #include <linux/irq.h>
  11. #include <linux/slab.h>
  12. #include <linux/spinlock.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/gpio/consumer.h>
  15. #include <linux/leds.h>
  16. #include <linux/of.h>
  17. #include <linux/of_platform.h>
  18. struct netxbig_gpio_ext {
  19. struct gpio_desc **addr;
  20. int num_addr;
  21. struct gpio_desc **data;
  22. int num_data;
  23. struct gpio_desc *enable;
  24. };
  25. enum netxbig_led_mode {
  26. NETXBIG_LED_OFF,
  27. NETXBIG_LED_ON,
  28. NETXBIG_LED_SATA,
  29. NETXBIG_LED_TIMER1,
  30. NETXBIG_LED_TIMER2,
  31. NETXBIG_LED_MODE_NUM,
  32. };
  33. #define NETXBIG_LED_INVALID_MODE NETXBIG_LED_MODE_NUM
  34. struct netxbig_led_timer {
  35. unsigned long delay_on;
  36. unsigned long delay_off;
  37. enum netxbig_led_mode mode;
  38. };
  39. struct netxbig_led {
  40. const char *name;
  41. const char *default_trigger;
  42. int mode_addr;
  43. int *mode_val;
  44. int bright_addr;
  45. int bright_max;
  46. };
  47. struct netxbig_led_platform_data {
  48. struct netxbig_gpio_ext *gpio_ext;
  49. struct netxbig_led_timer *timer;
  50. int num_timer;
  51. struct netxbig_led *leds;
  52. int num_leds;
  53. };
  54. /*
  55. * GPIO extension bus.
  56. */
  57. static DEFINE_SPINLOCK(gpio_ext_lock);
  58. static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr)
  59. {
  60. int pin;
  61. for (pin = 0; pin < gpio_ext->num_addr; pin++)
  62. gpiod_set_value(gpio_ext->addr[pin], (addr >> pin) & 1);
  63. }
  64. static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data)
  65. {
  66. int pin;
  67. for (pin = 0; pin < gpio_ext->num_data; pin++)
  68. gpiod_set_value(gpio_ext->data[pin], (data >> pin) & 1);
  69. }
  70. static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext)
  71. {
  72. /* Enable select is done on the raising edge. */
  73. gpiod_set_value(gpio_ext->enable, 0);
  74. gpiod_set_value(gpio_ext->enable, 1);
  75. }
  76. static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext,
  77. int addr, int value)
  78. {
  79. unsigned long flags;
  80. spin_lock_irqsave(&gpio_ext_lock, flags);
  81. gpio_ext_set_addr(gpio_ext, addr);
  82. gpio_ext_set_data(gpio_ext, value);
  83. gpio_ext_enable_select(gpio_ext);
  84. spin_unlock_irqrestore(&gpio_ext_lock, flags);
  85. }
  86. /*
  87. * Class LED driver.
  88. */
  89. struct netxbig_led_data {
  90. struct netxbig_gpio_ext *gpio_ext;
  91. struct led_classdev cdev;
  92. int mode_addr;
  93. int *mode_val;
  94. int bright_addr;
  95. struct netxbig_led_timer *timer;
  96. int num_timer;
  97. enum netxbig_led_mode mode;
  98. int sata;
  99. spinlock_t lock;
  100. };
  101. static int netxbig_led_get_timer_mode(enum netxbig_led_mode *mode,
  102. unsigned long delay_on,
  103. unsigned long delay_off,
  104. struct netxbig_led_timer *timer,
  105. int num_timer)
  106. {
  107. int i;
  108. for (i = 0; i < num_timer; i++) {
  109. if (timer[i].delay_on == delay_on &&
  110. timer[i].delay_off == delay_off) {
  111. *mode = timer[i].mode;
  112. return 0;
  113. }
  114. }
  115. return -EINVAL;
  116. }
  117. static int netxbig_led_blink_set(struct led_classdev *led_cdev,
  118. unsigned long *delay_on,
  119. unsigned long *delay_off)
  120. {
  121. struct netxbig_led_data *led_dat =
  122. container_of(led_cdev, struct netxbig_led_data, cdev);
  123. enum netxbig_led_mode mode;
  124. int mode_val;
  125. int ret;
  126. /* Look for a LED mode with the requested timer frequency. */
  127. ret = netxbig_led_get_timer_mode(&mode, *delay_on, *delay_off,
  128. led_dat->timer, led_dat->num_timer);
  129. if (ret < 0)
  130. return ret;
  131. mode_val = led_dat->mode_val[mode];
  132. if (mode_val == NETXBIG_LED_INVALID_MODE)
  133. return -EINVAL;
  134. spin_lock_irq(&led_dat->lock);
  135. gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
  136. led_dat->mode = mode;
  137. spin_unlock_irq(&led_dat->lock);
  138. return 0;
  139. }
  140. static void netxbig_led_set(struct led_classdev *led_cdev,
  141. enum led_brightness value)
  142. {
  143. struct netxbig_led_data *led_dat =
  144. container_of(led_cdev, struct netxbig_led_data, cdev);
  145. enum netxbig_led_mode mode;
  146. int mode_val;
  147. int set_brightness = 1;
  148. unsigned long flags;
  149. spin_lock_irqsave(&led_dat->lock, flags);
  150. if (value == LED_OFF) {
  151. mode = NETXBIG_LED_OFF;
  152. set_brightness = 0;
  153. } else {
  154. if (led_dat->sata)
  155. mode = NETXBIG_LED_SATA;
  156. else if (led_dat->mode == NETXBIG_LED_OFF)
  157. mode = NETXBIG_LED_ON;
  158. else /* Keep 'timer' mode. */
  159. mode = led_dat->mode;
  160. }
  161. mode_val = led_dat->mode_val[mode];
  162. gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
  163. led_dat->mode = mode;
  164. /*
  165. * Note that the brightness register is shared between all the
  166. * SATA LEDs. So, change the brightness setting for a single
  167. * SATA LED will affect all the others.
  168. */
  169. if (set_brightness)
  170. gpio_ext_set_value(led_dat->gpio_ext,
  171. led_dat->bright_addr, value);
  172. spin_unlock_irqrestore(&led_dat->lock, flags);
  173. }
  174. static ssize_t netxbig_led_sata_store(struct device *dev,
  175. struct device_attribute *attr,
  176. const char *buff, size_t count)
  177. {
  178. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  179. struct netxbig_led_data *led_dat =
  180. container_of(led_cdev, struct netxbig_led_data, cdev);
  181. unsigned long enable;
  182. enum netxbig_led_mode mode;
  183. int mode_val;
  184. int ret;
  185. ret = kstrtoul(buff, 10, &enable);
  186. if (ret < 0)
  187. return ret;
  188. enable = !!enable;
  189. spin_lock_irq(&led_dat->lock);
  190. if (led_dat->sata == enable) {
  191. ret = count;
  192. goto exit_unlock;
  193. }
  194. if (led_dat->mode != NETXBIG_LED_ON &&
  195. led_dat->mode != NETXBIG_LED_SATA)
  196. mode = led_dat->mode; /* Keep modes 'off' and 'timer'. */
  197. else if (enable)
  198. mode = NETXBIG_LED_SATA;
  199. else
  200. mode = NETXBIG_LED_ON;
  201. mode_val = led_dat->mode_val[mode];
  202. if (mode_val == NETXBIG_LED_INVALID_MODE) {
  203. ret = -EINVAL;
  204. goto exit_unlock;
  205. }
  206. gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
  207. led_dat->mode = mode;
  208. led_dat->sata = enable;
  209. ret = count;
  210. exit_unlock:
  211. spin_unlock_irq(&led_dat->lock);
  212. return ret;
  213. }
  214. static ssize_t netxbig_led_sata_show(struct device *dev,
  215. struct device_attribute *attr, char *buf)
  216. {
  217. struct led_classdev *led_cdev = dev_get_drvdata(dev);
  218. struct netxbig_led_data *led_dat =
  219. container_of(led_cdev, struct netxbig_led_data, cdev);
  220. return sprintf(buf, "%d\n", led_dat->sata);
  221. }
  222. static DEVICE_ATTR(sata, 0644, netxbig_led_sata_show, netxbig_led_sata_store);
  223. static struct attribute *netxbig_led_attrs[] = {
  224. &dev_attr_sata.attr,
  225. NULL
  226. };
  227. ATTRIBUTE_GROUPS(netxbig_led);
  228. static int create_netxbig_led(struct platform_device *pdev,
  229. struct netxbig_led_platform_data *pdata,
  230. struct netxbig_led_data *led_dat,
  231. const struct netxbig_led *template)
  232. {
  233. spin_lock_init(&led_dat->lock);
  234. led_dat->gpio_ext = pdata->gpio_ext;
  235. led_dat->cdev.name = template->name;
  236. led_dat->cdev.default_trigger = template->default_trigger;
  237. led_dat->cdev.blink_set = netxbig_led_blink_set;
  238. led_dat->cdev.brightness_set = netxbig_led_set;
  239. /*
  240. * Because the GPIO extension bus don't allow to read registers
  241. * value, there is no way to probe the LED initial state.
  242. * So, the initial sysfs LED value for the "brightness" and "sata"
  243. * attributes are inconsistent.
  244. *
  245. * Note that the initial LED state can't be reconfigured.
  246. * The reason is that the LED behaviour must stay uniform during
  247. * the whole boot process (bootloader+linux).
  248. */
  249. led_dat->sata = 0;
  250. led_dat->cdev.brightness = LED_OFF;
  251. led_dat->cdev.max_brightness = template->bright_max;
  252. led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
  253. led_dat->mode_addr = template->mode_addr;
  254. led_dat->mode_val = template->mode_val;
  255. led_dat->bright_addr = template->bright_addr;
  256. led_dat->timer = pdata->timer;
  257. led_dat->num_timer = pdata->num_timer;
  258. /*
  259. * If available, expose the SATA activity blink capability through
  260. * a "sata" sysfs attribute.
  261. */
  262. if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE)
  263. led_dat->cdev.groups = netxbig_led_groups;
  264. return devm_led_classdev_register(&pdev->dev, &led_dat->cdev);
  265. }
  266. /**
  267. * netxbig_gpio_ext_remove() - Clean up GPIO extension data
  268. * @data: managed resource data to clean up
  269. *
  270. * Since we pick GPIO descriptors from another device than the device our
  271. * driver is probing to, we need to register a specific callback to free
  272. * these up using managed resources.
  273. */
  274. static void netxbig_gpio_ext_remove(void *data)
  275. {
  276. struct netxbig_gpio_ext *gpio_ext = data;
  277. int i;
  278. for (i = 0; i < gpio_ext->num_addr; i++)
  279. gpiod_put(gpio_ext->addr[i]);
  280. for (i = 0; i < gpio_ext->num_data; i++)
  281. gpiod_put(gpio_ext->data[i]);
  282. gpiod_put(gpio_ext->enable);
  283. }
  284. /**
  285. * netxbig_gpio_ext_get() - Obtain GPIO extension device data
  286. * @dev: main LED device
  287. * @gpio_ext_dev: the GPIO extension device
  288. * @gpio_ext: the data structure holding the GPIO extension data
  289. *
  290. * This function walks the subdevice that only contain GPIO line
  291. * handles in the device tree and obtains the GPIO descriptors from that
  292. * device.
  293. */
  294. static int netxbig_gpio_ext_get(struct device *dev,
  295. struct device *gpio_ext_dev,
  296. struct netxbig_gpio_ext *gpio_ext)
  297. {
  298. struct gpio_desc **addr, **data;
  299. int num_addr, num_data;
  300. struct gpio_desc *gpiod;
  301. int ret;
  302. int i;
  303. ret = gpiod_count(gpio_ext_dev, "addr");
  304. if (ret < 0) {
  305. dev_err(dev,
  306. "Failed to count GPIOs in DT property addr-gpios\n");
  307. return ret;
  308. }
  309. num_addr = ret;
  310. addr = devm_kcalloc(dev, num_addr, sizeof(*addr), GFP_KERNEL);
  311. if (!addr)
  312. return -ENOMEM;
  313. /*
  314. * We cannot use devm_ managed resources with these GPIO descriptors
  315. * since they are associated with the "GPIO extension device" which
  316. * does not probe any driver. The device tree parser will however
  317. * populate a platform device for it so we can anyway obtain the
  318. * GPIO descriptors from the device.
  319. */
  320. for (i = 0; i < num_addr; i++) {
  321. gpiod = gpiod_get_index(gpio_ext_dev, "addr", i,
  322. GPIOD_OUT_LOW);
  323. if (IS_ERR(gpiod))
  324. return PTR_ERR(gpiod);
  325. gpiod_set_consumer_name(gpiod, "GPIO extension addr");
  326. addr[i] = gpiod;
  327. }
  328. gpio_ext->addr = addr;
  329. gpio_ext->num_addr = num_addr;
  330. ret = gpiod_count(gpio_ext_dev, "data");
  331. if (ret < 0) {
  332. dev_err(dev,
  333. "Failed to count GPIOs in DT property data-gpios\n");
  334. return ret;
  335. }
  336. num_data = ret;
  337. data = devm_kcalloc(dev, num_data, sizeof(*data), GFP_KERNEL);
  338. if (!data)
  339. return -ENOMEM;
  340. for (i = 0; i < num_data; i++) {
  341. gpiod = gpiod_get_index(gpio_ext_dev, "data", i,
  342. GPIOD_OUT_LOW);
  343. if (IS_ERR(gpiod))
  344. return PTR_ERR(gpiod);
  345. gpiod_set_consumer_name(gpiod, "GPIO extension data");
  346. data[i] = gpiod;
  347. }
  348. gpio_ext->data = data;
  349. gpio_ext->num_data = num_data;
  350. gpiod = gpiod_get(gpio_ext_dev, "enable", GPIOD_OUT_LOW);
  351. if (IS_ERR(gpiod)) {
  352. dev_err(dev,
  353. "Failed to get GPIO from DT property enable-gpio\n");
  354. return PTR_ERR(gpiod);
  355. }
  356. gpiod_set_consumer_name(gpiod, "GPIO extension enable");
  357. gpio_ext->enable = gpiod;
  358. return devm_add_action_or_reset(dev, netxbig_gpio_ext_remove, gpio_ext);
  359. }
  360. static int netxbig_leds_get_of_pdata(struct device *dev,
  361. struct netxbig_led_platform_data *pdata)
  362. {
  363. struct device_node *np = dev_of_node(dev);
  364. struct device_node *gpio_ext_np;
  365. struct platform_device *gpio_ext_pdev;
  366. struct device *gpio_ext_dev;
  367. struct device_node *child;
  368. struct netxbig_gpio_ext *gpio_ext;
  369. struct netxbig_led_timer *timers;
  370. struct netxbig_led *leds, *led;
  371. int num_timers;
  372. int num_leds = 0;
  373. int ret;
  374. int i;
  375. /* GPIO extension */
  376. gpio_ext_np = of_parse_phandle(np, "gpio-ext", 0);
  377. if (!gpio_ext_np) {
  378. dev_err(dev, "Failed to get DT handle gpio-ext\n");
  379. return -EINVAL;
  380. }
  381. gpio_ext_pdev = of_find_device_by_node(gpio_ext_np);
  382. if (!gpio_ext_pdev) {
  383. dev_err(dev, "Failed to find platform device for gpio-ext\n");
  384. return -ENODEV;
  385. }
  386. gpio_ext_dev = &gpio_ext_pdev->dev;
  387. gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL);
  388. if (!gpio_ext) {
  389. of_node_put(gpio_ext_np);
  390. ret = -ENOMEM;
  391. goto put_device;
  392. }
  393. ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext);
  394. of_node_put(gpio_ext_np);
  395. if (ret)
  396. goto put_device;
  397. pdata->gpio_ext = gpio_ext;
  398. /* Timers (optional) */
  399. ret = of_property_count_u32_elems(np, "timers");
  400. if (ret > 0) {
  401. if (ret % 3) {
  402. ret = -EINVAL;
  403. goto put_device;
  404. }
  405. num_timers = ret / 3;
  406. timers = devm_kcalloc(dev, num_timers, sizeof(*timers),
  407. GFP_KERNEL);
  408. if (!timers) {
  409. ret = -ENOMEM;
  410. goto put_device;
  411. }
  412. for (i = 0; i < num_timers; i++) {
  413. u32 tmp;
  414. of_property_read_u32_index(np, "timers", 3 * i,
  415. &timers[i].mode);
  416. if (timers[i].mode >= NETXBIG_LED_MODE_NUM) {
  417. ret = -EINVAL;
  418. goto put_device;
  419. }
  420. of_property_read_u32_index(np, "timers",
  421. 3 * i + 1, &tmp);
  422. timers[i].delay_on = tmp;
  423. of_property_read_u32_index(np, "timers",
  424. 3 * i + 2, &tmp);
  425. timers[i].delay_off = tmp;
  426. }
  427. pdata->timer = timers;
  428. pdata->num_timer = num_timers;
  429. }
  430. /* LEDs */
  431. num_leds = of_get_available_child_count(np);
  432. if (!num_leds) {
  433. dev_err(dev, "No LED subnodes found in DT\n");
  434. ret = -ENODEV;
  435. goto put_device;
  436. }
  437. leds = devm_kcalloc(dev, num_leds, sizeof(*leds), GFP_KERNEL);
  438. if (!leds) {
  439. ret = -ENOMEM;
  440. goto put_device;
  441. }
  442. led = leds;
  443. for_each_available_child_of_node(np, child) {
  444. const char *string;
  445. int *mode_val;
  446. int num_modes;
  447. ret = of_property_read_u32(child, "mode-addr",
  448. &led->mode_addr);
  449. if (ret)
  450. goto err_node_put;
  451. ret = of_property_read_u32(child, "bright-addr",
  452. &led->bright_addr);
  453. if (ret)
  454. goto err_node_put;
  455. ret = of_property_read_u32(child, "max-brightness",
  456. &led->bright_max);
  457. if (ret)
  458. goto err_node_put;
  459. mode_val =
  460. devm_kcalloc(dev,
  461. NETXBIG_LED_MODE_NUM, sizeof(*mode_val),
  462. GFP_KERNEL);
  463. if (!mode_val) {
  464. ret = -ENOMEM;
  465. goto err_node_put;
  466. }
  467. for (i = 0; i < NETXBIG_LED_MODE_NUM; i++)
  468. mode_val[i] = NETXBIG_LED_INVALID_MODE;
  469. ret = of_property_count_u32_elems(child, "mode-val");
  470. if (ret < 0 || ret % 2) {
  471. ret = -EINVAL;
  472. goto err_node_put;
  473. }
  474. num_modes = ret / 2;
  475. if (num_modes > NETXBIG_LED_MODE_NUM) {
  476. ret = -EINVAL;
  477. goto err_node_put;
  478. }
  479. for (i = 0; i < num_modes; i++) {
  480. int mode;
  481. int val;
  482. of_property_read_u32_index(child,
  483. "mode-val", 2 * i, &mode);
  484. of_property_read_u32_index(child,
  485. "mode-val", 2 * i + 1, &val);
  486. if (mode >= NETXBIG_LED_MODE_NUM) {
  487. ret = -EINVAL;
  488. goto err_node_put;
  489. }
  490. mode_val[mode] = val;
  491. }
  492. led->mode_val = mode_val;
  493. if (!of_property_read_string(child, "label", &string))
  494. led->name = string;
  495. else
  496. led->name = child->name;
  497. if (!of_property_read_string(child,
  498. "linux,default-trigger", &string))
  499. led->default_trigger = string;
  500. led++;
  501. }
  502. pdata->leds = leds;
  503. pdata->num_leds = num_leds;
  504. return 0;
  505. err_node_put:
  506. of_node_put(child);
  507. put_device:
  508. put_device(gpio_ext_dev);
  509. return ret;
  510. }
  511. static const struct of_device_id of_netxbig_leds_match[] = {
  512. { .compatible = "lacie,netxbig-leds", },
  513. {},
  514. };
  515. MODULE_DEVICE_TABLE(of, of_netxbig_leds_match);
  516. static int netxbig_led_probe(struct platform_device *pdev)
  517. {
  518. struct netxbig_led_platform_data *pdata;
  519. struct netxbig_led_data *leds_data;
  520. int i;
  521. int ret;
  522. pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
  523. if (!pdata)
  524. return -ENOMEM;
  525. ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata);
  526. if (ret)
  527. return ret;
  528. leds_data = devm_kcalloc(&pdev->dev,
  529. pdata->num_leds, sizeof(*leds_data),
  530. GFP_KERNEL);
  531. if (!leds_data)
  532. return -ENOMEM;
  533. for (i = 0; i < pdata->num_leds; i++) {
  534. ret = create_netxbig_led(pdev, pdata,
  535. &leds_data[i], &pdata->leds[i]);
  536. if (ret < 0)
  537. return ret;
  538. }
  539. return 0;
  540. }
  541. static struct platform_driver netxbig_led_driver = {
  542. .probe = netxbig_led_probe,
  543. .driver = {
  544. .name = "leds-netxbig",
  545. .of_match_table = of_netxbig_leds_match,
  546. },
  547. };
  548. module_platform_driver(netxbig_led_driver);
  549. MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
  550. MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards");
  551. MODULE_LICENSE("GPL");
  552. MODULE_ALIAS("platform:leds-netxbig");