GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / gpio / gpio-sch.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * GPIO interface for Intel Poulsbo SCH
4  *
5  *  Copyright (c) 2010 CompuLab Ltd
6  *  Author: Denis Turischev <denis@compulab.co.il>
7  */
8
9 #include <linux/acpi.h>
10 #include <linux/bitops.h>
11 #include <linux/errno.h>
12 #include <linux/gpio/driver.h>
13 #include <linux/io.h>
14 #include <linux/irq.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/pci_ids.h>
18 #include <linux/platform_device.h>
19 #include <linux/types.h>
20
21 #define GEN     0x00
22 #define GIO     0x04
23 #define GLV     0x08
24 #define GTPE    0x0c
25 #define GTNE    0x10
26 #define GGPE    0x14
27 #define GSMI    0x18
28 #define GTS     0x1c
29
30 #define CORE_BANK_OFFSET        0x00
31 #define RESUME_BANK_OFFSET      0x20
32
33 /*
34  * iLB datasheet describes GPE0BLK registers, in particular GPE0E.GPIO bit.
35  * Document Number: 328195-001
36  */
37 #define GPE0E_GPIO      14
38
39 struct sch_gpio {
40         struct gpio_chip chip;
41         spinlock_t lock;
42         unsigned short iobase;
43         unsigned short resume_base;
44
45         /* GPE handling */
46         u32 gpe;
47         acpi_gpe_handler gpe_handler;
48 };
49
50 static unsigned int sch_gpio_offset(struct sch_gpio *sch, unsigned int gpio,
51                                 unsigned int reg)
52 {
53         unsigned int base = CORE_BANK_OFFSET;
54
55         if (gpio >= sch->resume_base) {
56                 gpio -= sch->resume_base;
57                 base = RESUME_BANK_OFFSET;
58         }
59
60         return base + reg + gpio / 8;
61 }
62
63 static unsigned int sch_gpio_bit(struct sch_gpio *sch, unsigned int gpio)
64 {
65         if (gpio >= sch->resume_base)
66                 gpio -= sch->resume_base;
67         return gpio % 8;
68 }
69
70 static int sch_gpio_reg_get(struct sch_gpio *sch, unsigned int gpio, unsigned int reg)
71 {
72         unsigned short offset, bit;
73         u8 reg_val;
74
75         offset = sch_gpio_offset(sch, gpio, reg);
76         bit = sch_gpio_bit(sch, gpio);
77
78         reg_val = !!(inb(sch->iobase + offset) & BIT(bit));
79
80         return reg_val;
81 }
82
83 static void sch_gpio_reg_set(struct sch_gpio *sch, unsigned int gpio, unsigned int reg,
84                              int val)
85 {
86         unsigned short offset, bit;
87         u8 reg_val;
88
89         offset = sch_gpio_offset(sch, gpio, reg);
90         bit = sch_gpio_bit(sch, gpio);
91
92         reg_val = inb(sch->iobase + offset);
93
94         if (val)
95                 outb(reg_val | BIT(bit), sch->iobase + offset);
96         else
97                 outb((reg_val & ~BIT(bit)), sch->iobase + offset);
98 }
99
100 static int sch_gpio_direction_in(struct gpio_chip *gc, unsigned int gpio_num)
101 {
102         struct sch_gpio *sch = gpiochip_get_data(gc);
103         unsigned long flags;
104
105         spin_lock_irqsave(&sch->lock, flags);
106         sch_gpio_reg_set(sch, gpio_num, GIO, 1);
107         spin_unlock_irqrestore(&sch->lock, flags);
108         return 0;
109 }
110
111 static int sch_gpio_get(struct gpio_chip *gc, unsigned int gpio_num)
112 {
113         struct sch_gpio *sch = gpiochip_get_data(gc);
114
115         return sch_gpio_reg_get(sch, gpio_num, GLV);
116 }
117
118 static void sch_gpio_set(struct gpio_chip *gc, unsigned int gpio_num, int val)
119 {
120         struct sch_gpio *sch = gpiochip_get_data(gc);
121         unsigned long flags;
122
123         spin_lock_irqsave(&sch->lock, flags);
124         sch_gpio_reg_set(sch, gpio_num, GLV, val);
125         spin_unlock_irqrestore(&sch->lock, flags);
126 }
127
128 static int sch_gpio_direction_out(struct gpio_chip *gc, unsigned int gpio_num,
129                                   int val)
130 {
131         struct sch_gpio *sch = gpiochip_get_data(gc);
132         unsigned long flags;
133
134         spin_lock_irqsave(&sch->lock, flags);
135         sch_gpio_reg_set(sch, gpio_num, GIO, 0);
136         spin_unlock_irqrestore(&sch->lock, flags);
137
138         /*
139          * according to the datasheet, writing to the level register has no
140          * effect when GPIO is programmed as input.
141          * Actually the level register is read-only when configured as input.
142          * Thus presetting the output level before switching to output is _NOT_ possible.
143          * Hence we set the level after configuring the GPIO as output.
144          * But we cannot prevent a short low pulse if direction is set to high
145          * and an external pull-up is connected.
146          */
147         sch_gpio_set(gc, gpio_num, val);
148         return 0;
149 }
150
151 static int sch_gpio_get_direction(struct gpio_chip *gc, unsigned int gpio_num)
152 {
153         struct sch_gpio *sch = gpiochip_get_data(gc);
154
155         if (sch_gpio_reg_get(sch, gpio_num, GIO))
156                 return GPIO_LINE_DIRECTION_IN;
157
158         return GPIO_LINE_DIRECTION_OUT;
159 }
160
161 static const struct gpio_chip sch_gpio_chip = {
162         .label                  = "sch_gpio",
163         .owner                  = THIS_MODULE,
164         .direction_input        = sch_gpio_direction_in,
165         .get                    = sch_gpio_get,
166         .direction_output       = sch_gpio_direction_out,
167         .set                    = sch_gpio_set,
168         .get_direction          = sch_gpio_get_direction,
169 };
170
171 static int sch_irq_type(struct irq_data *d, unsigned int type)
172 {
173         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
174         struct sch_gpio *sch = gpiochip_get_data(gc);
175         irq_hw_number_t gpio_num = irqd_to_hwirq(d);
176         unsigned long flags;
177         int rising, falling;
178
179         switch (type & IRQ_TYPE_SENSE_MASK) {
180         case IRQ_TYPE_EDGE_RISING:
181                 rising = 1;
182                 falling = 0;
183                 break;
184         case IRQ_TYPE_EDGE_FALLING:
185                 rising = 0;
186                 falling = 1;
187                 break;
188         case IRQ_TYPE_EDGE_BOTH:
189                 rising = 1;
190                 falling = 1;
191                 break;
192         default:
193                 return -EINVAL;
194         }
195
196         spin_lock_irqsave(&sch->lock, flags);
197
198         sch_gpio_reg_set(sch, gpio_num, GTPE, rising);
199         sch_gpio_reg_set(sch, gpio_num, GTNE, falling);
200
201         irq_set_handler_locked(d, handle_edge_irq);
202
203         spin_unlock_irqrestore(&sch->lock, flags);
204
205         return 0;
206 }
207
208 static void sch_irq_ack(struct irq_data *d)
209 {
210         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
211         struct sch_gpio *sch = gpiochip_get_data(gc);
212         irq_hw_number_t gpio_num = irqd_to_hwirq(d);
213         unsigned long flags;
214
215         spin_lock_irqsave(&sch->lock, flags);
216         sch_gpio_reg_set(sch, gpio_num, GTS, 1);
217         spin_unlock_irqrestore(&sch->lock, flags);
218 }
219
220 static void sch_irq_mask_unmask(struct gpio_chip *gc, irq_hw_number_t gpio_num, int val)
221 {
222         struct sch_gpio *sch = gpiochip_get_data(gc);
223         unsigned long flags;
224
225         spin_lock_irqsave(&sch->lock, flags);
226         sch_gpio_reg_set(sch, gpio_num, GGPE, val);
227         spin_unlock_irqrestore(&sch->lock, flags);
228 }
229
230 static void sch_irq_mask(struct irq_data *d)
231 {
232         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
233         irq_hw_number_t gpio_num = irqd_to_hwirq(d);
234
235         sch_irq_mask_unmask(gc, gpio_num, 0);
236         gpiochip_disable_irq(gc, gpio_num);
237 }
238
239 static void sch_irq_unmask(struct irq_data *d)
240 {
241         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
242         irq_hw_number_t gpio_num = irqd_to_hwirq(d);
243
244         gpiochip_enable_irq(gc, gpio_num);
245         sch_irq_mask_unmask(gc, gpio_num, 1);
246 }
247
248 static const struct irq_chip sch_irqchip = {
249         .name = "sch_gpio",
250         .irq_ack = sch_irq_ack,
251         .irq_mask = sch_irq_mask,
252         .irq_unmask = sch_irq_unmask,
253         .irq_set_type = sch_irq_type,
254         .flags = IRQCHIP_IMMUTABLE,
255         GPIOCHIP_IRQ_RESOURCE_HELPERS,
256 };
257
258 static u32 sch_gpio_gpe_handler(acpi_handle gpe_device, u32 gpe, void *context)
259 {
260         struct sch_gpio *sch = context;
261         struct gpio_chip *gc = &sch->chip;
262         unsigned long core_status, resume_status;
263         unsigned long pending;
264         unsigned long flags;
265         int offset;
266         u32 ret;
267
268         spin_lock_irqsave(&sch->lock, flags);
269
270         core_status = inl(sch->iobase + CORE_BANK_OFFSET + GTS);
271         resume_status = inl(sch->iobase + RESUME_BANK_OFFSET + GTS);
272
273         spin_unlock_irqrestore(&sch->lock, flags);
274
275         pending = (resume_status << sch->resume_base) | core_status;
276         for_each_set_bit(offset, &pending, sch->chip.ngpio)
277                 generic_handle_domain_irq(gc->irq.domain, offset);
278
279         /* Set returning value depending on whether we handled an interrupt */
280         ret = pending ? ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
281
282         /* Acknowledge GPE to ACPICA */
283         ret |= ACPI_REENABLE_GPE;
284
285         return ret;
286 }
287
288 static void sch_gpio_remove_gpe_handler(void *data)
289 {
290         struct sch_gpio *sch = data;
291
292         acpi_disable_gpe(NULL, sch->gpe);
293         acpi_remove_gpe_handler(NULL, sch->gpe, sch->gpe_handler);
294 }
295
296 static int sch_gpio_install_gpe_handler(struct sch_gpio *sch)
297 {
298         struct device *dev = sch->chip.parent;
299         acpi_status status;
300
301         status = acpi_install_gpe_handler(NULL, sch->gpe, ACPI_GPE_LEVEL_TRIGGERED,
302                                           sch->gpe_handler, sch);
303         if (ACPI_FAILURE(status)) {
304                 dev_err(dev, "Failed to install GPE handler for %u: %s\n",
305                         sch->gpe, acpi_format_exception(status));
306                 return -ENODEV;
307         }
308
309         status = acpi_enable_gpe(NULL, sch->gpe);
310         if (ACPI_FAILURE(status)) {
311                 dev_err(dev, "Failed to enable GPE handler for %u: %s\n",
312                         sch->gpe, acpi_format_exception(status));
313                 acpi_remove_gpe_handler(NULL, sch->gpe, sch->gpe_handler);
314                 return -ENODEV;
315         }
316
317         return devm_add_action_or_reset(dev, sch_gpio_remove_gpe_handler, sch);
318 }
319
320 static int sch_gpio_probe(struct platform_device *pdev)
321 {
322         struct gpio_irq_chip *girq;
323         struct sch_gpio *sch;
324         struct resource *res;
325         int ret;
326
327         sch = devm_kzalloc(&pdev->dev, sizeof(*sch), GFP_KERNEL);
328         if (!sch)
329                 return -ENOMEM;
330
331         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
332         if (!res)
333                 return -EBUSY;
334
335         if (!devm_request_region(&pdev->dev, res->start, resource_size(res),
336                                  pdev->name))
337                 return -EBUSY;
338
339         spin_lock_init(&sch->lock);
340         sch->iobase = res->start;
341         sch->chip = sch_gpio_chip;
342         sch->chip.label = dev_name(&pdev->dev);
343         sch->chip.parent = &pdev->dev;
344
345         switch (pdev->id) {
346         case PCI_DEVICE_ID_INTEL_SCH_LPC:
347                 sch->resume_base = 10;
348                 sch->chip.ngpio = 14;
349
350                 /*
351                  * GPIO[6:0] enabled by default
352                  * GPIO7 is configured by the CMC as SLPIOVR
353                  * Enable GPIO[9:8] core powered gpios explicitly
354                  */
355                 sch_gpio_reg_set(sch, 8, GEN, 1);
356                 sch_gpio_reg_set(sch, 9, GEN, 1);
357                 /*
358                  * SUS_GPIO[2:0] enabled by default
359                  * Enable SUS_GPIO3 resume powered gpio explicitly
360                  */
361                 sch_gpio_reg_set(sch, 13, GEN, 1);
362                 break;
363
364         case PCI_DEVICE_ID_INTEL_ITC_LPC:
365                 sch->resume_base = 5;
366                 sch->chip.ngpio = 14;
367                 break;
368
369         case PCI_DEVICE_ID_INTEL_CENTERTON_ILB:
370                 sch->resume_base = 21;
371                 sch->chip.ngpio = 30;
372                 break;
373
374         case PCI_DEVICE_ID_INTEL_QUARK_X1000_ILB:
375                 sch->resume_base = 2;
376                 sch->chip.ngpio = 8;
377                 break;
378
379         default:
380                 return -ENODEV;
381         }
382
383         platform_set_drvdata(pdev, sch);
384
385         girq = &sch->chip.irq;
386         gpio_irq_chip_set_chip(girq, &sch_irqchip);
387         girq->num_parents = 0;
388         girq->parents = NULL;
389         girq->parent_handler = NULL;
390         girq->default_type = IRQ_TYPE_NONE;
391         girq->handler = handle_bad_irq;
392
393         /* GPE setup is optional */
394         sch->gpe = GPE0E_GPIO;
395         sch->gpe_handler = sch_gpio_gpe_handler;
396
397         ret = sch_gpio_install_gpe_handler(sch);
398         if (ret)
399                 dev_warn(&pdev->dev, "Can't setup GPE, no IRQ support\n");
400
401         return devm_gpiochip_add_data(&pdev->dev, &sch->chip, sch);
402 }
403
404 static struct platform_driver sch_gpio_driver = {
405         .driver = {
406                 .name = "sch_gpio",
407         },
408         .probe          = sch_gpio_probe,
409 };
410
411 module_platform_driver(sch_gpio_driver);
412
413 MODULE_AUTHOR("Denis Turischev <denis@compulab.co.il>");
414 MODULE_DESCRIPTION("GPIO interface for Intel Poulsbo SCH");
415 MODULE_LICENSE("GPL v2");
416 MODULE_ALIAS("platform:sch_gpio");