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