2 * Intel Quark MFD PCI driver for I2C & GPIO
4 * Copyright(c) 2014 Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * Intel Quark PCI device for I2C and GPIO controller sharing the same
16 * PCI function. This PCI driver will split the 2 devices into their
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/pci.h>
23 #include <linux/mfd/core.h>
24 #include <linux/clkdev.h>
25 #include <linux/clk-provider.h>
26 #include <linux/dmi.h>
27 #include <linux/platform_data/gpio-dwapb.h>
28 #include <linux/platform_data/i2c-designware.h>
30 /* PCI BAR for register base address */
32 #define MFD_GPIO_BAR 1
34 /* ACPI _ADR value to match the child node */
35 #define MFD_ACPI_MATCH_GPIO 0ULL
36 #define MFD_ACPI_MATCH_I2C 1ULL
38 /* The base GPIO number under GPIOLIB framework */
39 #define INTEL_QUARK_MFD_GPIO_BASE 8
41 /* The default number of South-Cluster GPIO on Quark. */
42 #define INTEL_QUARK_MFD_NGPIO 8
44 /* The DesignWare GPIO ports on Quark. */
45 #define INTEL_QUARK_GPIO_NPORTS 1
47 #define INTEL_QUARK_IORES_MEM 0
48 #define INTEL_QUARK_IORES_IRQ 1
50 #define INTEL_QUARK_I2C_CONTROLLER_CLK "i2c_designware.0"
52 /* The Quark I2C controller source clock */
53 #define INTEL_QUARK_I2C_CLK_HZ 33000000
55 struct intel_quark_mfd
{
58 struct clk_lookup
*i2c_clk_lookup
;
61 static const struct dmi_system_id dmi_platform_info
[] = {
64 DMI_EXACT_MATCH(DMI_BOARD_NAME
, "Galileo"),
66 .driver_data
= (void *)100000,
70 DMI_EXACT_MATCH(DMI_BOARD_NAME
, "GalileoGen2"),
72 .driver_data
= (void *)400000,
76 DMI_EXACT_MATCH(DMI_BOARD_NAME
, "SIMATIC IOT2000"),
78 .driver_data
= (void *)400000,
83 static struct resource intel_quark_i2c_res
[] = {
84 [INTEL_QUARK_IORES_MEM
] = {
85 .flags
= IORESOURCE_MEM
,
87 [INTEL_QUARK_IORES_IRQ
] = {
88 .flags
= IORESOURCE_IRQ
,
92 static struct mfd_cell_acpi_match intel_quark_acpi_match_i2c
= {
93 .adr
= MFD_ACPI_MATCH_I2C
,
96 static struct resource intel_quark_gpio_res
[] = {
97 [INTEL_QUARK_IORES_MEM
] = {
98 .flags
= IORESOURCE_MEM
,
102 static struct mfd_cell_acpi_match intel_quark_acpi_match_gpio
= {
103 .adr
= MFD_ACPI_MATCH_GPIO
,
106 static struct mfd_cell intel_quark_mfd_cells
[] = {
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,
117 .name
= "i2c_designware",
118 .acpi_match
= &intel_quark_acpi_match_i2c
,
119 .num_resources
= ARRAY_SIZE(intel_quark_i2c_res
),
120 .resources
= intel_quark_i2c_res
,
121 .ignore_resource_conflicts
= true,
125 static const struct pci_device_id intel_quark_mfd_ids
[] = {
126 { PCI_VDEVICE(INTEL
, 0x0934), },
129 MODULE_DEVICE_TABLE(pci
, intel_quark_mfd_ids
);
131 static int intel_quark_register_i2c_clk(struct device
*dev
)
133 struct intel_quark_mfd
*quark_mfd
= dev_get_drvdata(dev
);
136 i2c_clk
= clk_register_fixed_rate(dev
,
137 INTEL_QUARK_I2C_CONTROLLER_CLK
, NULL
,
138 0, INTEL_QUARK_I2C_CLK_HZ
);
140 return PTR_ERR(i2c_clk
);
142 quark_mfd
->i2c_clk
= i2c_clk
;
143 quark_mfd
->i2c_clk_lookup
= clkdev_create(i2c_clk
, NULL
,
144 INTEL_QUARK_I2C_CONTROLLER_CLK
);
146 if (!quark_mfd
->i2c_clk_lookup
) {
147 clk_unregister(quark_mfd
->i2c_clk
);
148 dev_err(dev
, "Fixed clk register failed\n");
155 static void intel_quark_unregister_i2c_clk(struct device
*dev
)
157 struct intel_quark_mfd
*quark_mfd
= dev_get_drvdata(dev
);
159 if (!quark_mfd
->i2c_clk_lookup
)
162 clkdev_drop(quark_mfd
->i2c_clk_lookup
);
163 clk_unregister(quark_mfd
->i2c_clk
);
166 static int intel_quark_i2c_setup(struct pci_dev
*pdev
, struct mfd_cell
*cell
)
168 const struct dmi_system_id
*dmi_id
;
169 struct dw_i2c_platform_data
*pdata
;
170 struct resource
*res
= (struct resource
*)cell
->resources
;
171 struct device
*dev
= &pdev
->dev
;
173 res
[INTEL_QUARK_IORES_MEM
].start
=
174 pci_resource_start(pdev
, MFD_I2C_BAR
);
175 res
[INTEL_QUARK_IORES_MEM
].end
=
176 pci_resource_end(pdev
, MFD_I2C_BAR
);
178 res
[INTEL_QUARK_IORES_IRQ
].start
= pdev
->irq
;
179 res
[INTEL_QUARK_IORES_IRQ
].end
= pdev
->irq
;
181 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
185 /* Normal mode by default */
186 pdata
->i2c_scl_freq
= 100000;
188 dmi_id
= dmi_first_match(dmi_platform_info
);
190 pdata
->i2c_scl_freq
= (uintptr_t)dmi_id
->driver_data
;
192 cell
->platform_data
= pdata
;
193 cell
->pdata_size
= sizeof(*pdata
);
198 static int intel_quark_gpio_setup(struct pci_dev
*pdev
, struct mfd_cell
*cell
)
200 struct dwapb_platform_data
*pdata
;
201 struct resource
*res
= (struct resource
*)cell
->resources
;
202 struct device
*dev
= &pdev
->dev
;
204 res
[INTEL_QUARK_IORES_MEM
].start
=
205 pci_resource_start(pdev
, MFD_GPIO_BAR
);
206 res
[INTEL_QUARK_IORES_MEM
].end
=
207 pci_resource_end(pdev
, MFD_GPIO_BAR
);
209 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
213 /* For intel quark x1000, it has only one port: portA */
214 pdata
->nports
= INTEL_QUARK_GPIO_NPORTS
;
215 pdata
->properties
= devm_kcalloc(dev
, pdata
->nports
,
216 sizeof(*pdata
->properties
),
218 if (!pdata
->properties
)
221 /* Set the properties for portA */
222 pdata
->properties
->fwnode
= NULL
;
223 pdata
->properties
->idx
= 0;
224 pdata
->properties
->ngpio
= INTEL_QUARK_MFD_NGPIO
;
225 pdata
->properties
->gpio_base
= INTEL_QUARK_MFD_GPIO_BASE
;
226 pdata
->properties
->irq
[0] = pdev
->irq
;
227 pdata
->properties
->has_irq
= true;
228 pdata
->properties
->irq_shared
= true;
230 cell
->platform_data
= pdata
;
231 cell
->pdata_size
= sizeof(*pdata
);
236 static int intel_quark_mfd_probe(struct pci_dev
*pdev
,
237 const struct pci_device_id
*id
)
239 struct intel_quark_mfd
*quark_mfd
;
242 ret
= pcim_enable_device(pdev
);
246 quark_mfd
= devm_kzalloc(&pdev
->dev
, sizeof(*quark_mfd
), GFP_KERNEL
);
250 quark_mfd
->dev
= &pdev
->dev
;
251 dev_set_drvdata(&pdev
->dev
, quark_mfd
);
253 ret
= intel_quark_register_i2c_clk(&pdev
->dev
);
257 ret
= intel_quark_i2c_setup(pdev
, &intel_quark_mfd_cells
[1]);
259 goto err_unregister_i2c_clk
;
261 ret
= intel_quark_gpio_setup(pdev
, &intel_quark_mfd_cells
[0]);
263 goto err_unregister_i2c_clk
;
265 ret
= mfd_add_devices(&pdev
->dev
, 0, intel_quark_mfd_cells
,
266 ARRAY_SIZE(intel_quark_mfd_cells
), NULL
, 0,
269 goto err_unregister_i2c_clk
;
273 err_unregister_i2c_clk
:
274 intel_quark_unregister_i2c_clk(&pdev
->dev
);
278 static void intel_quark_mfd_remove(struct pci_dev
*pdev
)
280 intel_quark_unregister_i2c_clk(&pdev
->dev
);
281 mfd_remove_devices(&pdev
->dev
);
284 static struct pci_driver intel_quark_mfd_driver
= {
285 .name
= "intel_quark_mfd_i2c_gpio",
286 .id_table
= intel_quark_mfd_ids
,
287 .probe
= intel_quark_mfd_probe
,
288 .remove
= intel_quark_mfd_remove
,
291 module_pci_driver(intel_quark_mfd_driver
);
293 MODULE_AUTHOR("Raymond Tan <raymond.tan@intel.com>");
294 MODULE_DESCRIPTION("Intel Quark MFD PCI driver for I2C & GPIO");
295 MODULE_LICENSE("GPL v2");