gpio-kempld.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Kontron PLD GPIO driver
  4. *
  5. * Copyright (c) 2010-2013 Kontron Europe GmbH
  6. * Author: Michael Brunner <michael.brunner@kontron.com>
  7. */
  8. #include <linux/init.h>
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/bitops.h>
  12. #include <linux/errno.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/gpio/driver.h>
  15. #include <linux/mfd/kempld.h>
  16. #define KEMPLD_GPIO_MAX_NUM 16
  17. #define KEMPLD_GPIO_MASK(x) (BIT((x) % 8))
  18. #define KEMPLD_GPIO_DIR_NUM(x) (0x40 + (x) / 8)
  19. #define KEMPLD_GPIO_LVL_NUM(x) (0x42 + (x) / 8)
  20. #define KEMPLD_GPIO_EVT_LVL_EDGE 0x46
  21. #define KEMPLD_GPIO_IEN 0x4A
  22. struct kempld_gpio_data {
  23. struct gpio_chip chip;
  24. struct kempld_device_data *pld;
  25. };
  26. /*
  27. * Set or clear GPIO bit
  28. * kempld_get_mutex must be called prior to calling this function.
  29. */
  30. static void kempld_gpio_bitop(struct kempld_device_data *pld,
  31. u8 reg, u8 bit, u8 val)
  32. {
  33. u8 status;
  34. status = kempld_read8(pld, reg);
  35. if (val)
  36. status |= KEMPLD_GPIO_MASK(bit);
  37. else
  38. status &= ~KEMPLD_GPIO_MASK(bit);
  39. kempld_write8(pld, reg, status);
  40. }
  41. static int kempld_gpio_get_bit(struct kempld_device_data *pld, u8 reg, u8 bit)
  42. {
  43. u8 status;
  44. kempld_get_mutex(pld);
  45. status = kempld_read8(pld, reg);
  46. kempld_release_mutex(pld);
  47. return !!(status & KEMPLD_GPIO_MASK(bit));
  48. }
  49. static int kempld_gpio_get(struct gpio_chip *chip, unsigned offset)
  50. {
  51. struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
  52. struct kempld_device_data *pld = gpio->pld;
  53. return !!kempld_gpio_get_bit(pld, KEMPLD_GPIO_LVL_NUM(offset), offset);
  54. }
  55. static void kempld_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
  56. {
  57. struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
  58. struct kempld_device_data *pld = gpio->pld;
  59. kempld_get_mutex(pld);
  60. kempld_gpio_bitop(pld, KEMPLD_GPIO_LVL_NUM(offset), offset, value);
  61. kempld_release_mutex(pld);
  62. }
  63. static int kempld_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
  64. {
  65. struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
  66. struct kempld_device_data *pld = gpio->pld;
  67. kempld_get_mutex(pld);
  68. kempld_gpio_bitop(pld, KEMPLD_GPIO_DIR_NUM(offset), offset, 0);
  69. kempld_release_mutex(pld);
  70. return 0;
  71. }
  72. static int kempld_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
  73. int value)
  74. {
  75. struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
  76. struct kempld_device_data *pld = gpio->pld;
  77. kempld_get_mutex(pld);
  78. kempld_gpio_bitop(pld, KEMPLD_GPIO_LVL_NUM(offset), offset, value);
  79. kempld_gpio_bitop(pld, KEMPLD_GPIO_DIR_NUM(offset), offset, 1);
  80. kempld_release_mutex(pld);
  81. return 0;
  82. }
  83. static int kempld_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
  84. {
  85. struct kempld_gpio_data *gpio = gpiochip_get_data(chip);
  86. struct kempld_device_data *pld = gpio->pld;
  87. if (kempld_gpio_get_bit(pld, KEMPLD_GPIO_DIR_NUM(offset), offset))
  88. return GPIO_LINE_DIRECTION_OUT;
  89. return GPIO_LINE_DIRECTION_IN;
  90. }
  91. static int kempld_gpio_pincount(struct kempld_device_data *pld)
  92. {
  93. u16 evt, evt_back;
  94. kempld_get_mutex(pld);
  95. /* Backup event register as it might be already initialized */
  96. evt_back = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE);
  97. /* Clear event register */
  98. kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, 0x0000);
  99. /* Read back event register */
  100. evt = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE);
  101. /* Restore event register */
  102. kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, evt_back);
  103. kempld_release_mutex(pld);
  104. return evt ? __ffs(evt) : 16;
  105. }
  106. static int kempld_gpio_probe(struct platform_device *pdev)
  107. {
  108. struct device *dev = &pdev->dev;
  109. struct kempld_device_data *pld = dev_get_drvdata(dev->parent);
  110. struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
  111. struct kempld_gpio_data *gpio;
  112. struct gpio_chip *chip;
  113. int ret;
  114. if (pld->info.spec_major < 2) {
  115. dev_err(dev,
  116. "Driver only supports GPIO devices compatible to PLD spec. rev. 2.0 or higher\n");
  117. return -ENODEV;
  118. }
  119. gpio = devm_kzalloc(dev, sizeof(*gpio), GFP_KERNEL);
  120. if (!gpio)
  121. return -ENOMEM;
  122. gpio->pld = pld;
  123. platform_set_drvdata(pdev, gpio);
  124. chip = &gpio->chip;
  125. chip->label = "gpio-kempld";
  126. chip->owner = THIS_MODULE;
  127. chip->parent = dev;
  128. chip->can_sleep = true;
  129. if (pdata && pdata->gpio_base)
  130. chip->base = pdata->gpio_base;
  131. else
  132. chip->base = -1;
  133. chip->direction_input = kempld_gpio_direction_input;
  134. chip->direction_output = kempld_gpio_direction_output;
  135. chip->get_direction = kempld_gpio_get_direction;
  136. chip->get = kempld_gpio_get;
  137. chip->set = kempld_gpio_set;
  138. chip->ngpio = kempld_gpio_pincount(pld);
  139. if (chip->ngpio == 0) {
  140. dev_err(dev, "No GPIO pins detected\n");
  141. return -ENODEV;
  142. }
  143. ret = devm_gpiochip_add_data(dev, chip, gpio);
  144. if (ret) {
  145. dev_err(dev, "Could not register GPIO chip\n");
  146. return ret;
  147. }
  148. dev_info(dev, "GPIO functionality initialized with %d pins\n",
  149. chip->ngpio);
  150. return 0;
  151. }
  152. static struct platform_driver kempld_gpio_driver = {
  153. .driver = {
  154. .name = "kempld-gpio",
  155. },
  156. .probe = kempld_gpio_probe,
  157. };
  158. module_platform_driver(kempld_gpio_driver);
  159. MODULE_DESCRIPTION("KEM PLD GPIO Driver");
  160. MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>");
  161. MODULE_LICENSE("GPL");
  162. MODULE_ALIAS("platform:kempld-gpio");