intel_quark_i2c_gpio.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Intel Quark MFD PCI driver for I2C & GPIO
  4. *
  5. * Copyright(c) 2014 Intel Corporation.
  6. *
  7. * Intel Quark PCI device for I2C and GPIO controller sharing the same
  8. * PCI function. This PCI driver will split the 2 devices into their
  9. * respective drivers.
  10. */
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/pci.h>
  14. #include <linux/mfd/core.h>
  15. #include <linux/clkdev.h>
  16. #include <linux/clk-provider.h>
  17. #include <linux/dmi.h>
  18. #include <linux/platform_data/gpio-dwapb.h>
  19. #include <linux/platform_data/i2c-designware.h>
  20. /* PCI BAR for register base address */
  21. #define MFD_I2C_BAR 0
  22. #define MFD_GPIO_BAR 1
  23. /* ACPI _ADR value to match the child node */
  24. #define MFD_ACPI_MATCH_GPIO 0ULL
  25. #define MFD_ACPI_MATCH_I2C 1ULL
  26. /* The base GPIO number under GPIOLIB framework */
  27. #define INTEL_QUARK_MFD_GPIO_BASE 8
  28. /* The default number of South-Cluster GPIO on Quark. */
  29. #define INTEL_QUARK_MFD_NGPIO 8
  30. /* The DesignWare GPIO ports on Quark. */
  31. #define INTEL_QUARK_GPIO_NPORTS 1
  32. #define INTEL_QUARK_IORES_MEM 0
  33. #define INTEL_QUARK_IORES_IRQ 1
  34. #define INTEL_QUARK_I2C_CONTROLLER_CLK "i2c_designware.0"
  35. /* The Quark I2C controller source clock */
  36. #define INTEL_QUARK_I2C_CLK_HZ 33000000
  37. struct intel_quark_mfd {
  38. struct device *dev;
  39. struct clk *i2c_clk;
  40. struct clk_lookup *i2c_clk_lookup;
  41. };
  42. static const struct dmi_system_id dmi_platform_info[] = {
  43. {
  44. .matches = {
  45. DMI_EXACT_MATCH(DMI_BOARD_NAME, "Galileo"),
  46. },
  47. .driver_data = (void *)100000,
  48. },
  49. {
  50. .matches = {
  51. DMI_EXACT_MATCH(DMI_BOARD_NAME, "GalileoGen2"),
  52. },
  53. .driver_data = (void *)400000,
  54. },
  55. {
  56. .matches = {
  57. DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
  58. },
  59. .driver_data = (void *)400000,
  60. },
  61. {}
  62. };
  63. static struct resource intel_quark_i2c_res[] = {
  64. [INTEL_QUARK_IORES_MEM] = {
  65. .flags = IORESOURCE_MEM,
  66. },
  67. [INTEL_QUARK_IORES_IRQ] = {
  68. .flags = IORESOURCE_IRQ,
  69. },
  70. };
  71. static struct mfd_cell_acpi_match intel_quark_acpi_match_i2c = {
  72. .adr = MFD_ACPI_MATCH_I2C,
  73. };
  74. static struct resource intel_quark_gpio_res[] = {
  75. [INTEL_QUARK_IORES_MEM] = {
  76. .flags = IORESOURCE_MEM,
  77. },
  78. };
  79. static struct mfd_cell_acpi_match intel_quark_acpi_match_gpio = {
  80. .adr = MFD_ACPI_MATCH_GPIO,
  81. };
  82. static struct mfd_cell intel_quark_mfd_cells[] = {
  83. {
  84. .id = MFD_GPIO_BAR,
  85. .name = "gpio-dwapb",
  86. .acpi_match = &intel_quark_acpi_match_gpio,
  87. .num_resources = ARRAY_SIZE(intel_quark_gpio_res),
  88. .resources = intel_quark_gpio_res,
  89. .ignore_resource_conflicts = true,
  90. },
  91. {
  92. .id = MFD_I2C_BAR,
  93. .name = "i2c_designware",
  94. .acpi_match = &intel_quark_acpi_match_i2c,
  95. .num_resources = ARRAY_SIZE(intel_quark_i2c_res),
  96. .resources = intel_quark_i2c_res,
  97. .ignore_resource_conflicts = true,
  98. },
  99. };
  100. static const struct pci_device_id intel_quark_mfd_ids[] = {
  101. { PCI_VDEVICE(INTEL, 0x0934), },
  102. {},
  103. };
  104. MODULE_DEVICE_TABLE(pci, intel_quark_mfd_ids);
  105. static int intel_quark_register_i2c_clk(struct device *dev)
  106. {
  107. struct intel_quark_mfd *quark_mfd = dev_get_drvdata(dev);
  108. struct clk *i2c_clk;
  109. i2c_clk = clk_register_fixed_rate(dev,
  110. INTEL_QUARK_I2C_CONTROLLER_CLK, NULL,
  111. 0, INTEL_QUARK_I2C_CLK_HZ);
  112. if (IS_ERR(i2c_clk))
  113. return PTR_ERR(i2c_clk);
  114. quark_mfd->i2c_clk = i2c_clk;
  115. quark_mfd->i2c_clk_lookup = clkdev_create(i2c_clk, NULL,
  116. INTEL_QUARK_I2C_CONTROLLER_CLK);
  117. if (!quark_mfd->i2c_clk_lookup) {
  118. clk_unregister(quark_mfd->i2c_clk);
  119. dev_err(dev, "Fixed clk register failed\n");
  120. return -ENOMEM;
  121. }
  122. return 0;
  123. }
  124. static void intel_quark_unregister_i2c_clk(struct device *dev)
  125. {
  126. struct intel_quark_mfd *quark_mfd = dev_get_drvdata(dev);
  127. if (!quark_mfd->i2c_clk_lookup)
  128. return;
  129. clkdev_drop(quark_mfd->i2c_clk_lookup);
  130. clk_unregister(quark_mfd->i2c_clk);
  131. }
  132. static int intel_quark_i2c_setup(struct pci_dev *pdev, struct mfd_cell *cell)
  133. {
  134. const struct dmi_system_id *dmi_id;
  135. struct dw_i2c_platform_data *pdata;
  136. struct resource *res = (struct resource *)cell->resources;
  137. struct device *dev = &pdev->dev;
  138. res[INTEL_QUARK_IORES_MEM].start =
  139. pci_resource_start(pdev, MFD_I2C_BAR);
  140. res[INTEL_QUARK_IORES_MEM].end =
  141. pci_resource_end(pdev, MFD_I2C_BAR);
  142. res[INTEL_QUARK_IORES_IRQ].start = pdev->irq;
  143. res[INTEL_QUARK_IORES_IRQ].end = pdev->irq;
  144. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  145. if (!pdata)
  146. return -ENOMEM;
  147. /* Normal mode by default */
  148. pdata->i2c_scl_freq = 100000;
  149. dmi_id = dmi_first_match(dmi_platform_info);
  150. if (dmi_id)
  151. pdata->i2c_scl_freq = (uintptr_t)dmi_id->driver_data;
  152. cell->platform_data = pdata;
  153. cell->pdata_size = sizeof(*pdata);
  154. return 0;
  155. }
  156. static int intel_quark_gpio_setup(struct pci_dev *pdev, struct mfd_cell *cell)
  157. {
  158. struct dwapb_platform_data *pdata;
  159. struct resource *res = (struct resource *)cell->resources;
  160. struct device *dev = &pdev->dev;
  161. res[INTEL_QUARK_IORES_MEM].start =
  162. pci_resource_start(pdev, MFD_GPIO_BAR);
  163. res[INTEL_QUARK_IORES_MEM].end =
  164. pci_resource_end(pdev, MFD_GPIO_BAR);
  165. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  166. if (!pdata)
  167. return -ENOMEM;
  168. /* For intel quark x1000, it has only one port: portA */
  169. pdata->nports = INTEL_QUARK_GPIO_NPORTS;
  170. pdata->properties = devm_kcalloc(dev, pdata->nports,
  171. sizeof(*pdata->properties),
  172. GFP_KERNEL);
  173. if (!pdata->properties)
  174. return -ENOMEM;
  175. /* Set the properties for portA */
  176. pdata->properties->fwnode = NULL;
  177. pdata->properties->idx = 0;
  178. pdata->properties->ngpio = INTEL_QUARK_MFD_NGPIO;
  179. pdata->properties->gpio_base = INTEL_QUARK_MFD_GPIO_BASE;
  180. pdata->properties->irq[0] = pdev->irq;
  181. pdata->properties->irq_shared = true;
  182. cell->platform_data = pdata;
  183. cell->pdata_size = sizeof(*pdata);
  184. return 0;
  185. }
  186. static int intel_quark_mfd_probe(struct pci_dev *pdev,
  187. const struct pci_device_id *id)
  188. {
  189. struct intel_quark_mfd *quark_mfd;
  190. int ret;
  191. ret = pcim_enable_device(pdev);
  192. if (ret)
  193. return ret;
  194. quark_mfd = devm_kzalloc(&pdev->dev, sizeof(*quark_mfd), GFP_KERNEL);
  195. if (!quark_mfd)
  196. return -ENOMEM;
  197. quark_mfd->dev = &pdev->dev;
  198. dev_set_drvdata(&pdev->dev, quark_mfd);
  199. ret = intel_quark_register_i2c_clk(&pdev->dev);
  200. if (ret)
  201. return ret;
  202. ret = intel_quark_i2c_setup(pdev, &intel_quark_mfd_cells[1]);
  203. if (ret)
  204. goto err_unregister_i2c_clk;
  205. ret = intel_quark_gpio_setup(pdev, &intel_quark_mfd_cells[0]);
  206. if (ret)
  207. goto err_unregister_i2c_clk;
  208. ret = mfd_add_devices(&pdev->dev, 0, intel_quark_mfd_cells,
  209. ARRAY_SIZE(intel_quark_mfd_cells), NULL, 0,
  210. NULL);
  211. if (ret)
  212. goto err_unregister_i2c_clk;
  213. return 0;
  214. err_unregister_i2c_clk:
  215. intel_quark_unregister_i2c_clk(&pdev->dev);
  216. return ret;
  217. }
  218. static void intel_quark_mfd_remove(struct pci_dev *pdev)
  219. {
  220. intel_quark_unregister_i2c_clk(&pdev->dev);
  221. mfd_remove_devices(&pdev->dev);
  222. }
  223. static struct pci_driver intel_quark_mfd_driver = {
  224. .name = "intel_quark_mfd_i2c_gpio",
  225. .id_table = intel_quark_mfd_ids,
  226. .probe = intel_quark_mfd_probe,
  227. .remove = intel_quark_mfd_remove,
  228. };
  229. module_pci_driver(intel_quark_mfd_driver);
  230. MODULE_AUTHOR("Raymond Tan <raymond.tan@intel.com>");
  231. MODULE_DESCRIPTION("Intel Quark MFD PCI driver for I2C & GPIO");
  232. MODULE_LICENSE("GPL v2");