projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
pinctrl/baytrail: Use irq_set_handler_locked()
[deliverable/linux.git] / drivers / pinctrl / intel / pinctrl-baytrail.c
1 /*
2 * Pinctrl GPIO driver for Intel Baytrail
3 * Copyright (c) 2012-2013, Intel Corporation.
4 *
5 * Author: Mathias Nyman <mathias.nyman@linux.intel.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/types.h>
26 #include <linux/bitops.h>
27 #include <linux/interrupt.h>
28 #include <linux/gpio.h>
29 #include <linux/acpi.h>
30 #include <linux/platform_device.h>
31 #include <linux/seq_file.h>
32 #include <linux/io.h>
33 #include <linux/pm_runtime.h>
34 #include <linux/pinctrl/pinctrl.h>
35
36 /* memory mapped register offsets */
37 #define BYT_CONF0_REG 0x000
38 #define BYT_CONF1_REG 0x004
39 #define BYT_VAL_REG 0x008
40 #define BYT_DFT_REG 0x00c
41 #define BYT_INT_STAT_REG 0x800
42
43 /* BYT_CONF0_REG register bits */
44 #define BYT_IODEN BIT(31)
45 #define BYT_DIRECT_IRQ_EN BIT(27)
46 #define BYT_TRIG_NEG BIT(26)
47 #define BYT_TRIG_POS BIT(25)
48 #define BYT_TRIG_LVL BIT(24)
49 #define BYT_PULL_STR_SHIFT 9
50 #define BYT_PULL_STR_MASK (3 << BYT_PULL_STR_SHIFT)
51 #define BYT_PULL_STR_2K (0 << BYT_PULL_STR_SHIFT)
52 #define BYT_PULL_STR_10K (1 << BYT_PULL_STR_SHIFT)
53 #define BYT_PULL_STR_20K (2 << BYT_PULL_STR_SHIFT)
54 #define BYT_PULL_STR_40K (3 << BYT_PULL_STR_SHIFT)
55 #define BYT_PULL_ASSIGN_SHIFT 7
56 #define BYT_PULL_ASSIGN_MASK (3 << BYT_PULL_ASSIGN_SHIFT)
57 #define BYT_PULL_ASSIGN_UP (1 << BYT_PULL_ASSIGN_SHIFT)
58 #define BYT_PULL_ASSIGN_DOWN (2 << BYT_PULL_ASSIGN_SHIFT)
59 #define BYT_PIN_MUX 0x07
60
61 /* BYT_VAL_REG register bits */
62 #define BYT_INPUT_EN BIT(2) /* 0: input enabled (active low)*/
63 #define BYT_OUTPUT_EN BIT(1) /* 0: output enabled (active low)*/
64 #define BYT_LEVEL BIT(0)
65
66 #define BYT_DIR_MASK (BIT(1) | BIT(2))
67 #define BYT_TRIG_MASK (BIT(26) | BIT(25) | BIT(24))
68
69 #define BYT_CONF0_RESTORE_MASK (BYT_DIRECT_IRQ_EN | BYT_TRIG_MASK | \
70 BYT_PIN_MUX)
71 #define BYT_VAL_RESTORE_MASK (BYT_DIR_MASK | BYT_LEVEL)
72
73 #define BYT_NGPIO_SCORE 102
74 #define BYT_NGPIO_NCORE 28
75 #define BYT_NGPIO_SUS 44
76
77 #define BYT_SCORE_ACPI_UID "1"
78 #define BYT_NCORE_ACPI_UID "2"
79 #define BYT_SUS_ACPI_UID "3"
80
81 /*
82 * Baytrail gpio controller consist of three separate sub-controllers called
83 * SCORE, NCORE and SUS. The sub-controllers are identified by their acpi UID.
84 *
85 * GPIO numbering is _not_ ordered meaning that gpio # 0 in ACPI namespace does
86 * _not_ correspond to the first gpio register at controller's gpio base.
87 * There is no logic or pattern in mapping gpio numbers to registers (pads) so
88 * each sub-controller needs to have its own mapping table
89 */
90
91 /* score_pins[gpio_nr] = pad_nr */
92
93 static unsigned const score_pins[BYT_NGPIO_SCORE] = {
94 85, 89, 93, 96, 99, 102, 98, 101, 34, 37,
95 36, 38, 39, 35, 40, 84, 62, 61, 64, 59,
96 54, 56, 60, 55, 63, 57, 51, 50, 53, 47,
97 52, 49, 48, 43, 46, 41, 45, 42, 58, 44,
98 95, 105, 70, 68, 67, 66, 69, 71, 65, 72,
99 86, 90, 88, 92, 103, 77, 79, 83, 78, 81,
100 80, 82, 13, 12, 15, 14, 17, 18, 19, 16,
101 2, 1, 0, 4, 6, 7, 9, 8, 33, 32,
102 31, 30, 29, 27, 25, 28, 26, 23, 21, 20,
103 24, 22, 5, 3, 10, 11, 106, 87, 91, 104,
104 97, 100,
105 };
106
107 static unsigned const ncore_pins[BYT_NGPIO_NCORE] = {
108 19, 18, 17, 20, 21, 22, 24, 25, 23, 16,
109 14, 15, 12, 26, 27, 1, 4, 8, 11, 0,
110 3, 6, 10, 13, 2, 5, 9, 7,
111 };
112
113 static unsigned const sus_pins[BYT_NGPIO_SUS] = {
114 29, 33, 30, 31, 32, 34, 36, 35, 38, 37,
115 18, 7, 11, 20, 17, 1, 8, 10, 19, 12,
116 0, 2, 23, 39, 28, 27, 22, 21, 24, 25,
117 26, 51, 56, 54, 49, 55, 48, 57, 50, 58,
118 52, 53, 59, 40,
119 };
120
121 static struct pinctrl_gpio_range byt_ranges[] = {
122 {
123 .name = BYT_SCORE_ACPI_UID, /* match with acpi _UID in probe */
124 .npins = BYT_NGPIO_SCORE,
125 .pins = score_pins,
126 },
127 {
128 .name = BYT_NCORE_ACPI_UID,
129 .npins = BYT_NGPIO_NCORE,
130 .pins = ncore_pins,
131 },
132 {
133 .name = BYT_SUS_ACPI_UID,
134 .npins = BYT_NGPIO_SUS,
135 .pins = sus_pins,
136 },
137 {
138 },
139 };
140
141 struct byt_gpio_pin_context {
142 u32 conf0;
143 u32 val;
144 };
145
146 struct byt_gpio {
147 struct gpio_chip chip;
148 struct platform_device *pdev;
149 spinlock_t lock;
150 void __iomem *reg_base;
151 struct pinctrl_gpio_range *range;
152 struct byt_gpio_pin_context *saved_context;
153 };
154
155 #define to_byt_gpio(c) container_of(c, struct byt_gpio, chip)
156
157 static void __iomem *byt_gpio_reg(struct gpio_chip *chip, unsigned offset,
158 int reg)
159 {
160 struct byt_gpio *vg = to_byt_gpio(chip);
161 u32 reg_offset;
162
163 if (reg == BYT_INT_STAT_REG)
164 reg_offset = (offset / 32) * 4;
165 else
166 reg_offset = vg->range->pins[offset] * 16;
167
168 return vg->reg_base + reg_offset + reg;
169 }
170
171 static void byt_gpio_clear_triggering(struct byt_gpio *vg, unsigned offset)
172 {
173 void __iomem *reg = byt_gpio_reg(&vg->chip, offset, BYT_CONF0_REG);
174 unsigned long flags;
175 u32 value;
176
177 spin_lock_irqsave(&vg->lock, flags);
178 value = readl(reg);
179 value &= ~(BYT_TRIG_POS | BYT_TRIG_NEG | BYT_TRIG_LVL);
180 writel(value, reg);
181 spin_unlock_irqrestore(&vg->lock, flags);
182 }
183
184 static u32 byt_get_gpio_mux(struct byt_gpio *vg, unsigned offset)
185 {
186 /* SCORE pin 92-93 */
187 if (!strcmp(vg->range->name, BYT_SCORE_ACPI_UID) &&
188 offset >= 92 && offset <= 93)
189 return 1;
190
191 /* SUS pin 11-21 */
192 if (!strcmp(vg->range->name, BYT_SUS_ACPI_UID) &&
193 offset >= 11 && offset <= 21)
194 return 1;
195
196 return 0;
197 }
198
199 static int byt_gpio_request(struct gpio_chip *chip, unsigned offset)
200 {
201 struct byt_gpio *vg = to_byt_gpio(chip);
202 void __iomem *reg = byt_gpio_reg(chip, offset, BYT_CONF0_REG);
203 u32 value, gpio_mux;
204
205 /*
206 * In most cases, func pin mux 000 means GPIO function.
207 * But, some pins may have func pin mux 001 represents
208 * GPIO function.
209 *
210 * Because there are devices out there where some pins were not
211 * configured correctly we allow changing the mux value from
212 * request (but print out warning about that).
213 */
214 value = readl(reg) & BYT_PIN_MUX;
215 gpio_mux = byt_get_gpio_mux(vg, offset);
216 if (WARN_ON(gpio_mux != value)) {
217 unsigned long flags;
218
219 spin_lock_irqsave(&vg->lock, flags);
220 value = readl(reg) & ~BYT_PIN_MUX;
221 value |= gpio_mux;
222 writel(value, reg);
223 spin_unlock_irqrestore(&vg->lock, flags);
224
225 dev_warn(&vg->pdev->dev,
226 "pin %u forcibly re-configured as GPIO\n", offset);
227 }
228
229 pm_runtime_get(&vg->pdev->dev);
230
231 return 0;
232 }
233
234 static void byt_gpio_free(struct gpio_chip *chip, unsigned offset)
235 {
236 struct byt_gpio *vg = to_byt_gpio(chip);
237
238 byt_gpio_clear_triggering(vg, offset);
239 pm_runtime_put(&vg->pdev->dev);
240 }
241
242 static int byt_irq_type(struct irq_data *d, unsigned type)
243 {
244 struct byt_gpio *vg = to_byt_gpio(irq_data_get_irq_chip_data(d));
245 u32 offset = irqd_to_hwirq(d);
246 u32 value;
247 unsigned long flags;
248 void __iomem *reg = byt_gpio_reg(&vg->chip, offset, BYT_CONF0_REG);
249
250 if (offset >= vg->chip.ngpio)
251 return -EINVAL;
252
253 spin_lock_irqsave(&vg->lock, flags);
254 value = readl(reg);
255
256 WARN(value & BYT_DIRECT_IRQ_EN,
257 "Bad pad config for io mode, force direct_irq_en bit clearing");
258
259 /* For level trigges the BYT_TRIG_POS and BYT_TRIG_NEG bits
260 * are used to indicate high and low level triggering
261 */
262 value &= ~(BYT_DIRECT_IRQ_EN | BYT_TRIG_POS | BYT_TRIG_NEG |
263 BYT_TRIG_LVL);
264
265 writel(value, reg);
266
267 if (type & IRQ_TYPE_EDGE_BOTH)
268 irq_set_handler_locked(d, handle_edge_irq);
269 else if (type & IRQ_TYPE_LEVEL_MASK)
270 irq_set_handler_locked(d, handle_level_irq);
271
272 spin_unlock_irqrestore(&vg->lock, flags);
273
274 return 0;
275 }
276
277 static int byt_gpio_get(struct gpio_chip *chip, unsigned offset)
278 {
279 void __iomem *reg = byt_gpio_reg(chip, offset, BYT_VAL_REG);
280 return readl(reg) & BYT_LEVEL;
281 }
282
283 static void byt_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
284 {
285 struct byt_gpio *vg = to_byt_gpio(chip);
286 void __iomem *reg = byt_gpio_reg(chip, offset, BYT_VAL_REG);
287 unsigned long flags;
288 u32 old_val;
289
290 spin_lock_irqsave(&vg->lock, flags);
291
292 old_val = readl(reg);
293
294 if (value)
295 writel(old_val | BYT_LEVEL, reg);
296 else
297 writel(old_val & ~BYT_LEVEL, reg);
298
299 spin_unlock_irqrestore(&vg->lock, flags);
300 }
301
302 static int byt_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
303 {
304 struct byt_gpio *vg = to_byt_gpio(chip);
305 void __iomem *reg = byt_gpio_reg(chip, offset, BYT_VAL_REG);
306 unsigned long flags;
307 u32 value;
308
309 spin_lock_irqsave(&vg->lock, flags);
310
311 value = readl(reg) | BYT_DIR_MASK;
312 value &= ~BYT_INPUT_EN; /* active low */
313 writel(value, reg);
314
315 spin_unlock_irqrestore(&vg->lock, flags);
316
317 return 0;
318 }
319
320 static int byt_gpio_direction_output(struct gpio_chip *chip,
321 unsigned gpio, int value)
322 {
323 struct byt_gpio *vg = to_byt_gpio(chip);
324 void __iomem *conf_reg = byt_gpio_reg(chip, gpio, BYT_CONF0_REG);
325 void __iomem *reg = byt_gpio_reg(chip, gpio, BYT_VAL_REG);
326 unsigned long flags;
327 u32 reg_val;
328
329 spin_lock_irqsave(&vg->lock, flags);
330
331 /*
332 * Before making any direction modifications, do a check if gpio
333 * is set for direct IRQ. On baytrail, setting GPIO to output does
334 * not make sense, so let's at least warn the caller before they shoot
335 * themselves in the foot.
336 */
337 WARN(readl(conf_reg) & BYT_DIRECT_IRQ_EN,
338 "Potential Error: Setting GPIO with direct_irq_en to output");
339
340 reg_val = readl(reg) | BYT_DIR_MASK;
341 reg_val &= ~(BYT_OUTPUT_EN | BYT_INPUT_EN);
342
343 if (value)
344 writel(reg_val | BYT_LEVEL, reg);
345 else
346 writel(reg_val & ~BYT_LEVEL, reg);
347
348 spin_unlock_irqrestore(&vg->lock, flags);
349
350 return 0;
351 }
352
353 static void byt_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
354 {
355 struct byt_gpio *vg = to_byt_gpio(chip);
356 int i;
357 unsigned long flags;
358 u32 conf0, val, offs;
359
360 spin_lock_irqsave(&vg->lock, flags);
361
362 for (i = 0; i < vg->chip.ngpio; i++) {
363 const char *pull_str = NULL;
364 const char *pull = NULL;
365 const char *label;
366 offs = vg->range->pins[i] * 16;
367 conf0 = readl(vg->reg_base + offs + BYT_CONF0_REG);
368 val = readl(vg->reg_base + offs + BYT_VAL_REG);
369
370 label = gpiochip_is_requested(chip, i);
371 if (!label)
372 label = "Unrequested";
373
374 switch (conf0 & BYT_PULL_ASSIGN_MASK) {
375 case BYT_PULL_ASSIGN_UP:
376 pull = "up";
377 break;
378 case BYT_PULL_ASSIGN_DOWN:
379 pull = "down";
380 break;
381 }
382
383 switch (conf0 & BYT_PULL_STR_MASK) {
384 case BYT_PULL_STR_2K:
385 pull_str = "2k";
386 break;
387 case BYT_PULL_STR_10K:
388 pull_str = "10k";
389 break;
390 case BYT_PULL_STR_20K:
391 pull_str = "20k";
392 break;
393 case BYT_PULL_STR_40K:
394 pull_str = "40k";
395 break;
396 }
397
398 seq_printf(s,
399 " gpio-%-3d (%-20.20s) %s %s %s pad-%-3d offset:0x%03x mux:%d %s%s%s",
400 i,
401 label,
402 val & BYT_INPUT_EN ? " " : "in",
403 val & BYT_OUTPUT_EN ? " " : "out",
404 val & BYT_LEVEL ? "hi" : "lo",
405 vg->range->pins[i], offs,
406 conf0 & 0x7,
407 conf0 & BYT_TRIG_NEG ? " fall" : " ",
408 conf0 & BYT_TRIG_POS ? " rise" : " ",
409 conf0 & BYT_TRIG_LVL ? " level" : " ");
410
411 if (pull && pull_str)
412 seq_printf(s, " %-4s %-3s", pull, pull_str);
413 else
414 seq_puts(s, " ");
415
416 if (conf0 & BYT_IODEN)
417 seq_puts(s, " open-drain");
418
419 seq_puts(s, "\n");
420 }
421 spin_unlock_irqrestore(&vg->lock, flags);
422 }
423
424 static void byt_gpio_irq_handler(unsigned irq, struct irq_desc *desc)
425 {
426 struct irq_data *data = irq_desc_get_irq_data(desc);
427 struct byt_gpio *vg = to_byt_gpio(irq_desc_get_handler_data(desc));
428 struct irq_chip *chip = irq_data_get_irq_chip(data);
429 u32 base, pin;
430 void __iomem *reg;
431 unsigned long pending;
432 unsigned virq;
433
434 /* check from GPIO controller which pin triggered the interrupt */
435 for (base = 0; base < vg->chip.ngpio; base += 32) {
436 reg = byt_gpio_reg(&vg->chip, base, BYT_INT_STAT_REG);
437 pending = readl(reg);
438 for_each_set_bit(pin, &pending, 32) {
439 virq = irq_find_mapping(vg->chip.irqdomain, base + pin);
440 generic_handle_irq(virq);
441 }
442 }
443 chip->irq_eoi(data);
444 }
445
446 static void byt_irq_ack(struct irq_data *d)
447 {
448 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
449 struct byt_gpio *vg = to_byt_gpio(gc);
450 unsigned offset = irqd_to_hwirq(d);
451 void __iomem *reg;
452
453 reg = byt_gpio_reg(&vg->chip, offset, BYT_INT_STAT_REG);
454 writel(BIT(offset % 32), reg);
455 }
456
457 static void byt_irq_unmask(struct irq_data *d)
458 {
459 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
460 struct byt_gpio *vg = to_byt_gpio(gc);
461 unsigned offset = irqd_to_hwirq(d);
462 unsigned long flags;
463 void __iomem *reg;
464 u32 value;
465
466 spin_lock_irqsave(&vg->lock, flags);
467
468 reg = byt_gpio_reg(&vg->chip, offset, BYT_CONF0_REG);
469 value = readl(reg);
470
471 switch (irqd_get_trigger_type(d)) {
472 case IRQ_TYPE_LEVEL_HIGH:
473 value |= BYT_TRIG_LVL;
474 case IRQ_TYPE_EDGE_RISING:
475 value |= BYT_TRIG_POS;
476 break;
477 case IRQ_TYPE_LEVEL_LOW:
478 value |= BYT_TRIG_LVL;
479 case IRQ_TYPE_EDGE_FALLING:
480 value |= BYT_TRIG_NEG;
481 break;
482 case IRQ_TYPE_EDGE_BOTH:
483 value |= (BYT_TRIG_NEG | BYT_TRIG_POS);
484 break;
485 }
486
487 writel(value, reg);
488
489 spin_unlock_irqrestore(&vg->lock, flags);
490 }
491
492 static void byt_irq_mask(struct irq_data *d)
493 {
494 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
495 struct byt_gpio *vg = to_byt_gpio(gc);
496
497 byt_gpio_clear_triggering(vg, irqd_to_hwirq(d));
498 }
499
500 static struct irq_chip byt_irqchip = {
501 .name = "BYT-GPIO",
502 .irq_ack = byt_irq_ack,
503 .irq_mask = byt_irq_mask,
504 .irq_unmask = byt_irq_unmask,
505 .irq_set_type = byt_irq_type,
506 .flags = IRQCHIP_SKIP_SET_WAKE,
507 };
508
509 static void byt_gpio_irq_init_hw(struct byt_gpio *vg)
510 {
511 void __iomem *reg;
512 u32 base, value;
513 int i;
514
515 /*
516 * Clear interrupt triggers for all pins that are GPIOs and
517 * do not use direct IRQ mode. This will prevent spurious
518 * interrupts from misconfigured pins.
519 */
520 for (i = 0; i < vg->chip.ngpio; i++) {
521 value = readl(byt_gpio_reg(&vg->chip, i, BYT_CONF0_REG));
522 if ((value & BYT_PIN_MUX) == byt_get_gpio_mux(vg, i) &&
523 !(value & BYT_DIRECT_IRQ_EN)) {
524 byt_gpio_clear_triggering(vg, i);
525 dev_dbg(&vg->pdev->dev, "disabling GPIO %d\n", i);
526 }
527 }
528
529 /* clear interrupt status trigger registers */
530 for (base = 0; base < vg->chip.ngpio; base += 32) {
531 reg = byt_gpio_reg(&vg->chip, base, BYT_INT_STAT_REG);
532 writel(0xffffffff, reg);
533 /* make sure trigger bits are cleared, if not then a pin
534 might be misconfigured in bios */
535 value = readl(reg);
536 if (value)
537 dev_err(&vg->pdev->dev,
538 "GPIO interrupt error, pins misconfigured\n");
539 }
540 }
541
542 static int byt_gpio_probe(struct platform_device *pdev)
543 {
544 struct byt_gpio *vg;
545 struct gpio_chip *gc;
546 struct resource *mem_rc, *irq_rc;
547 struct device *dev = &pdev->dev;
548 struct acpi_device *acpi_dev;
549 struct pinctrl_gpio_range *range;
550 acpi_handle handle = ACPI_HANDLE(dev);
551 int ret;
552
553 if (acpi_bus_get_device(handle, &acpi_dev))
554 return -ENODEV;
555
556 vg = devm_kzalloc(dev, sizeof(struct byt_gpio), GFP_KERNEL);
557 if (!vg) {
558 dev_err(&pdev->dev, "can't allocate byt_gpio chip data\n");
559 return -ENOMEM;
560 }
561
562 for (range = byt_ranges; range->name; range++) {
563 if (!strcmp(acpi_dev->pnp.unique_id, range->name)) {
564 vg->chip.ngpio = range->npins;
565 vg->range = range;
566 break;
567 }
568 }
569
570 if (!vg->chip.ngpio || !vg->range)
571 return -ENODEV;
572
573 vg->pdev = pdev;
574 platform_set_drvdata(pdev, vg);
575
576 mem_rc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
577 vg->reg_base = devm_ioremap_resource(dev, mem_rc);
578 if (IS_ERR(vg->reg_base))
579 return PTR_ERR(vg->reg_base);
580
581 spin_lock_init(&vg->lock);
582
583 gc = &vg->chip;
584 gc->label = dev_name(&pdev->dev);
585 gc->owner = THIS_MODULE;
586 gc->request = byt_gpio_request;
587 gc->free = byt_gpio_free;
588 gc->direction_input = byt_gpio_direction_input;
589 gc->direction_output = byt_gpio_direction_output;
590 gc->get = byt_gpio_get;
591 gc->set = byt_gpio_set;
592 gc->dbg_show = byt_gpio_dbg_show;
593 gc->base = -1;
594 gc->can_sleep = false;
595 gc->dev = dev;
596
597 #ifdef CONFIG_PM_SLEEP
598 vg->saved_context = devm_kcalloc(&pdev->dev, gc->ngpio,
599 sizeof(*vg->saved_context), GFP_KERNEL);
600 #endif
601
602 ret = gpiochip_add(gc);
603 if (ret) {
604 dev_err(&pdev->dev, "failed adding byt-gpio chip\n");
605 return ret;
606 }
607
608 /* set up interrupts */
609 irq_rc = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
610 if (irq_rc && irq_rc->start) {
611 byt_gpio_irq_init_hw(vg);
612 ret = gpiochip_irqchip_add(gc, &byt_irqchip, 0,
613 handle_simple_irq, IRQ_TYPE_NONE);
614 if (ret) {
615 dev_err(dev, "failed to add irqchip\n");
616 gpiochip_remove(gc);
617 return ret;
618 }
619
620 gpiochip_set_chained_irqchip(gc, &byt_irqchip,
621 (unsigned)irq_rc->start,
622 byt_gpio_irq_handler);
623 }
624
625 pm_runtime_enable(dev);
626
627 return 0;
628 }
629
630 #ifdef CONFIG_PM_SLEEP
631 static int byt_gpio_suspend(struct device *dev)
632 {
633 struct platform_device *pdev = to_platform_device(dev);
634 struct byt_gpio *vg = platform_get_drvdata(pdev);
635 int i;
636
637 for (i = 0; i < vg->chip.ngpio; i++) {
638 void __iomem *reg;
639 u32 value;
640
641 reg = byt_gpio_reg(&vg->chip, i, BYT_CONF0_REG);
642 value = readl(reg) & BYT_CONF0_RESTORE_MASK;
643 vg->saved_context[i].conf0 = value;
644
645 reg = byt_gpio_reg(&vg->chip, i, BYT_VAL_REG);
646 value = readl(reg) & BYT_VAL_RESTORE_MASK;
647 vg->saved_context[i].val = value;
648 }
649
650 return 0;
651 }
652
653 static int byt_gpio_resume(struct device *dev)
654 {
655 struct platform_device *pdev = to_platform_device(dev);
656 struct byt_gpio *vg = platform_get_drvdata(pdev);
657 int i;
658
659 for (i = 0; i < vg->chip.ngpio; i++) {
660 void __iomem *reg;
661 u32 value;
662
663 reg = byt_gpio_reg(&vg->chip, i, BYT_CONF0_REG);
664 value = readl(reg);
665 if ((value & BYT_CONF0_RESTORE_MASK) !=
666 vg->saved_context[i].conf0) {
667 value &= ~BYT_CONF0_RESTORE_MASK;
668 value |= vg->saved_context[i].conf0;
669 writel(value, reg);
670 dev_info(dev, "restored pin %d conf0 %#08x", i, value);
671 }
672
673 reg = byt_gpio_reg(&vg->chip, i, BYT_VAL_REG);
674 value = readl(reg);
675 if ((value & BYT_VAL_RESTORE_MASK) !=
676 vg->saved_context[i].val) {
677 u32 v;
678
679 v = value & ~BYT_VAL_RESTORE_MASK;
680 v |= vg->saved_context[i].val;
681 if (v != value) {
682 writel(v, reg);
683 dev_dbg(dev, "restored pin %d val %#08x\n",
684 i, v);
685 }
686 }
687 }
688
689 return 0;
690 }
691 #endif
692
693 static int byt_gpio_runtime_suspend(struct device *dev)
694 {
695 return 0;
696 }
697
698 static int byt_gpio_runtime_resume(struct device *dev)
699 {
700 return 0;
701 }
702
703 static const struct dev_pm_ops byt_gpio_pm_ops = {
704 SET_LATE_SYSTEM_SLEEP_PM_OPS(byt_gpio_suspend, byt_gpio_resume)
705 SET_RUNTIME_PM_OPS(byt_gpio_runtime_suspend, byt_gpio_runtime_resume,
706 NULL)
707 };
708
709 static const struct acpi_device_id byt_gpio_acpi_match[] = {
710 { "INT33B2", 0 },
711 { "INT33FC", 0 },
712 { }
713 };
714 MODULE_DEVICE_TABLE(acpi, byt_gpio_acpi_match);
715
716 static int byt_gpio_remove(struct platform_device *pdev)
717 {
718 struct byt_gpio *vg = platform_get_drvdata(pdev);
719
720 pm_runtime_disable(&pdev->dev);
721 gpiochip_remove(&vg->chip);
722
723 return 0;
724 }
725
726 static struct platform_driver byt_gpio_driver = {
727 .probe = byt_gpio_probe,
728 .remove = byt_gpio_remove,
729 .driver = {
730 .name = "byt_gpio",
731 .pm = &byt_gpio_pm_ops,
732 .acpi_match_table = ACPI_PTR(byt_gpio_acpi_match),
733 },
734 };
735
736 static int __init byt_gpio_init(void)
737 {
738 return platform_driver_register(&byt_gpio_driver);
739 }
740 subsys_initcall(byt_gpio_init);
741
742 static void __exit byt_gpio_exit(void)
743 {
744 platform_driver_unregister(&byt_gpio_driver);
745 }
746 module_exit(byt_gpio_exit);
Linux kernel - Deliverables
This page took 0.060416 seconds and 5 git commands to generate.