2 * Intel MID GPIO driver
4 * Copyright (c) 2008-2014 Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 * Moorestown platform Langwell chip.
18 * Medfield platform Penwell chip.
19 * Clovertrail platform Cloverview chip.
22 #include <linux/module.h>
23 #include <linux/pci.h>
24 #include <linux/platform_device.h>
25 #include <linux/kernel.h>
26 #include <linux/delay.h>
27 #include <linux/stddef.h>
28 #include <linux/interrupt.h>
29 #include <linux/init.h>
31 #include <linux/gpio/driver.h>
32 #include <linux/slab.h>
33 #include <linux/pm_runtime.h>
35 #define INTEL_MID_IRQ_TYPE_EDGE (1 << 0)
36 #define INTEL_MID_IRQ_TYPE_LEVEL (1 << 1)
39 * Langwell chip has 64 pins and thus there are 2 32bit registers to control
40 * each feature, while Penwell chip has 96 pins for each block, and need 3 32bit
41 * registers to control them, so we only define the order here instead of a
42 * structure, to get a bit offset for a pin (use GPDR as an example):
47 * reg_addr = reg_base + GPDR * nreg * 4 + reg * 4;
49 * so the bit of reg_addr is to control pin offset's GPDR feature
53 GPLR
= 0, /* pin level read-only */
54 GPDR
, /* pin direction */
57 GRER
, /* rising edge detect */
58 GFER
, /* falling edge detect */
59 GEDR
, /* edge detect result */
60 GAFR
, /* alt function */
63 /* intel_mid gpio driver data */
64 struct intel_mid_gpio_ddata
{
65 u16 ngpio
; /* number of gpio pins */
66 u32 chip_irq_type
; /* chip interrupt type */
69 struct intel_mid_gpio
{
70 struct gpio_chip chip
;
71 void __iomem
*reg_base
;
76 static inline struct intel_mid_gpio
*to_intel_gpio_priv(struct gpio_chip
*gc
)
78 return container_of(gc
, struct intel_mid_gpio
, chip
);
81 static void __iomem
*gpio_reg(struct gpio_chip
*chip
, unsigned offset
,
82 enum GPIO_REG reg_type
)
84 struct intel_mid_gpio
*priv
= to_intel_gpio_priv(chip
);
85 unsigned nreg
= chip
->ngpio
/ 32;
88 return priv
->reg_base
+ reg_type
* nreg
* 4 + reg
* 4;
91 static void __iomem
*gpio_reg_2bit(struct gpio_chip
*chip
, unsigned offset
,
92 enum GPIO_REG reg_type
)
94 struct intel_mid_gpio
*priv
= to_intel_gpio_priv(chip
);
95 unsigned nreg
= chip
->ngpio
/ 32;
98 return priv
->reg_base
+ reg_type
* nreg
* 4 + reg
* 4;
101 static int intel_gpio_request(struct gpio_chip
*chip
, unsigned offset
)
103 void __iomem
*gafr
= gpio_reg_2bit(chip
, offset
, GAFR
);
104 u32 value
= readl(gafr
);
105 int shift
= (offset
% 16) << 1, af
= (value
>> shift
) & 3;
108 value
&= ~(3 << shift
);
114 static int intel_gpio_get(struct gpio_chip
*chip
, unsigned offset
)
116 void __iomem
*gplr
= gpio_reg(chip
, offset
, GPLR
);
118 return readl(gplr
) & BIT(offset
% 32);
121 static void intel_gpio_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
123 void __iomem
*gpsr
, *gpcr
;
126 gpsr
= gpio_reg(chip
, offset
, GPSR
);
127 writel(BIT(offset
% 32), gpsr
);
129 gpcr
= gpio_reg(chip
, offset
, GPCR
);
130 writel(BIT(offset
% 32), gpcr
);
134 static int intel_gpio_direction_input(struct gpio_chip
*chip
, unsigned offset
)
136 struct intel_mid_gpio
*priv
= to_intel_gpio_priv(chip
);
137 void __iomem
*gpdr
= gpio_reg(chip
, offset
, GPDR
);
142 pm_runtime_get(&priv
->pdev
->dev
);
144 spin_lock_irqsave(&priv
->lock
, flags
);
146 value
&= ~BIT(offset
% 32);
148 spin_unlock_irqrestore(&priv
->lock
, flags
);
151 pm_runtime_put(&priv
->pdev
->dev
);
156 static int intel_gpio_direction_output(struct gpio_chip
*chip
,
157 unsigned offset
, int value
)
159 struct intel_mid_gpio
*priv
= to_intel_gpio_priv(chip
);
160 void __iomem
*gpdr
= gpio_reg(chip
, offset
, GPDR
);
163 intel_gpio_set(chip
, offset
, value
);
166 pm_runtime_get(&priv
->pdev
->dev
);
168 spin_lock_irqsave(&priv
->lock
, flags
);
170 value
|= BIT(offset
% 32);
172 spin_unlock_irqrestore(&priv
->lock
, flags
);
175 pm_runtime_put(&priv
->pdev
->dev
);
180 static int intel_mid_irq_type(struct irq_data
*d
, unsigned type
)
182 struct gpio_chip
*gc
= irq_data_get_irq_chip_data(d
);
183 struct intel_mid_gpio
*priv
= to_intel_gpio_priv(gc
);
184 u32 gpio
= irqd_to_hwirq(d
);
187 void __iomem
*grer
= gpio_reg(&priv
->chip
, gpio
, GRER
);
188 void __iomem
*gfer
= gpio_reg(&priv
->chip
, gpio
, GFER
);
190 if (gpio
>= priv
->chip
.ngpio
)
194 pm_runtime_get(&priv
->pdev
->dev
);
196 spin_lock_irqsave(&priv
->lock
, flags
);
197 if (type
& IRQ_TYPE_EDGE_RISING
)
198 value
= readl(grer
) | BIT(gpio
% 32);
200 value
= readl(grer
) & (~BIT(gpio
% 32));
203 if (type
& IRQ_TYPE_EDGE_FALLING
)
204 value
= readl(gfer
) | BIT(gpio
% 32);
206 value
= readl(gfer
) & (~BIT(gpio
% 32));
208 spin_unlock_irqrestore(&priv
->lock
, flags
);
211 pm_runtime_put(&priv
->pdev
->dev
);
216 static void intel_mid_irq_unmask(struct irq_data
*d
)
220 static void intel_mid_irq_mask(struct irq_data
*d
)
224 static struct irq_chip intel_mid_irqchip
= {
225 .name
= "INTEL_MID-GPIO",
226 .irq_mask
= intel_mid_irq_mask
,
227 .irq_unmask
= intel_mid_irq_unmask
,
228 .irq_set_type
= intel_mid_irq_type
,
231 static const struct intel_mid_gpio_ddata gpio_lincroft
= {
235 static const struct intel_mid_gpio_ddata gpio_penwell_aon
= {
237 .chip_irq_type
= INTEL_MID_IRQ_TYPE_EDGE
,
240 static const struct intel_mid_gpio_ddata gpio_penwell_core
= {
242 .chip_irq_type
= INTEL_MID_IRQ_TYPE_EDGE
,
245 static const struct intel_mid_gpio_ddata gpio_cloverview_aon
= {
247 .chip_irq_type
= INTEL_MID_IRQ_TYPE_EDGE
| INTEL_MID_IRQ_TYPE_LEVEL
,
250 static const struct intel_mid_gpio_ddata gpio_cloverview_core
= {
252 .chip_irq_type
= INTEL_MID_IRQ_TYPE_EDGE
,
255 static const struct pci_device_id intel_gpio_ids
[] = {
258 PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x080f),
259 .driver_data
= (kernel_ulong_t
)&gpio_lincroft
,
263 PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x081f),
264 .driver_data
= (kernel_ulong_t
)&gpio_penwell_aon
,
268 PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x081a),
269 .driver_data
= (kernel_ulong_t
)&gpio_penwell_core
,
273 PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x08eb),
274 .driver_data
= (kernel_ulong_t
)&gpio_cloverview_aon
,
277 /* Cloverview Core */
278 PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x08f7),
279 .driver_data
= (kernel_ulong_t
)&gpio_cloverview_core
,
283 MODULE_DEVICE_TABLE(pci
, intel_gpio_ids
);
285 static void intel_mid_irq_handler(struct irq_desc
*desc
)
287 struct gpio_chip
*gc
= irq_desc_get_handler_data(desc
);
288 struct intel_mid_gpio
*priv
= to_intel_gpio_priv(gc
);
289 struct irq_data
*data
= irq_desc_get_irq_data(desc
);
290 struct irq_chip
*chip
= irq_data_get_irq_chip(data
);
291 u32 base
, gpio
, mask
;
292 unsigned long pending
;
295 /* check GPIO controller to check which pin triggered the interrupt */
296 for (base
= 0; base
< priv
->chip
.ngpio
; base
+= 32) {
297 gedr
= gpio_reg(&priv
->chip
, base
, GEDR
);
298 while ((pending
= readl(gedr
))) {
299 gpio
= __ffs(pending
);
301 /* Clear before handling so we can't lose an edge */
303 generic_handle_irq(irq_find_mapping(gc
->irqdomain
,
311 static void intel_mid_irq_init_hw(struct intel_mid_gpio
*priv
)
316 for (base
= 0; base
< priv
->chip
.ngpio
; base
+= 32) {
317 /* Clear the rising-edge detect register */
318 reg
= gpio_reg(&priv
->chip
, base
, GRER
);
320 /* Clear the falling-edge detect register */
321 reg
= gpio_reg(&priv
->chip
, base
, GFER
);
323 /* Clear the edge detect status register */
324 reg
= gpio_reg(&priv
->chip
, base
, GEDR
);
329 static int __maybe_unused
intel_gpio_runtime_idle(struct device
*dev
)
331 int err
= pm_schedule_suspend(dev
, 500);
332 return err
?: -EBUSY
;
335 static const struct dev_pm_ops intel_gpio_pm_ops
= {
336 SET_RUNTIME_PM_OPS(NULL
, NULL
, intel_gpio_runtime_idle
)
339 static int intel_gpio_probe(struct pci_dev
*pdev
,
340 const struct pci_device_id
*id
)
343 struct intel_mid_gpio
*priv
;
347 struct intel_mid_gpio_ddata
*ddata
=
348 (struct intel_mid_gpio_ddata
*)id
->driver_data
;
350 retval
= pcim_enable_device(pdev
);
354 retval
= pcim_iomap_regions(pdev
, 1 << 0 | 1 << 1, pci_name(pdev
));
356 dev_err(&pdev
->dev
, "I/O memory mapping error\n");
360 base
= pcim_iomap_table(pdev
)[1];
362 irq_base
= readl(base
);
363 gpio_base
= readl(sizeof(u32
) + base
);
365 /* release the IO mapping, since we already get the info from bar1 */
366 pcim_iounmap_regions(pdev
, 1 << 1);
368 priv
= devm_kzalloc(&pdev
->dev
, sizeof(*priv
), GFP_KERNEL
);
370 dev_err(&pdev
->dev
, "can't allocate chip data\n");
374 priv
->reg_base
= pcim_iomap_table(pdev
)[0];
375 priv
->chip
.label
= dev_name(&pdev
->dev
);
376 priv
->chip
.dev
= &pdev
->dev
;
377 priv
->chip
.request
= intel_gpio_request
;
378 priv
->chip
.direction_input
= intel_gpio_direction_input
;
379 priv
->chip
.direction_output
= intel_gpio_direction_output
;
380 priv
->chip
.get
= intel_gpio_get
;
381 priv
->chip
.set
= intel_gpio_set
;
382 priv
->chip
.base
= gpio_base
;
383 priv
->chip
.ngpio
= ddata
->ngpio
;
384 priv
->chip
.can_sleep
= false;
387 spin_lock_init(&priv
->lock
);
389 pci_set_drvdata(pdev
, priv
);
390 retval
= gpiochip_add(&priv
->chip
);
392 dev_err(&pdev
->dev
, "gpiochip_add error %d\n", retval
);
396 retval
= gpiochip_irqchip_add(&priv
->chip
,
403 "could not connect irqchip to gpiochip\n");
407 intel_mid_irq_init_hw(priv
);
409 gpiochip_set_chained_irqchip(&priv
->chip
,
412 intel_mid_irq_handler
);
414 pm_runtime_put_noidle(&pdev
->dev
);
415 pm_runtime_allow(&pdev
->dev
);
420 static struct pci_driver intel_gpio_driver
= {
421 .name
= "intel_mid_gpio",
422 .id_table
= intel_gpio_ids
,
423 .probe
= intel_gpio_probe
,
425 .pm
= &intel_gpio_pm_ops
,
429 static int __init
intel_gpio_init(void)
431 return pci_register_driver(&intel_gpio_driver
);
434 device_initcall(intel_gpio_init
);