diff options
Diffstat (limited to 'drivers/gpio/gpio-pch.c')
-rw-r--r-- | drivers/gpio/gpio-pch.c | 250 |
1 files changed, 243 insertions, 7 deletions
diff --git a/drivers/gpio/gpio-pch.c b/drivers/gpio/gpio-pch.c index 36919e77c49..1e8a4a53881 100644 --- a/drivers/gpio/gpio-pch.c +++ b/drivers/gpio/gpio-pch.c | |||
@@ -17,9 +17,17 @@ | |||
17 | #include <linux/kernel.h> | 17 | #include <linux/kernel.h> |
18 | #include <linux/pci.h> | 18 | #include <linux/pci.h> |
19 | #include <linux/gpio.h> | 19 | #include <linux/gpio.h> |
20 | #include <linux/interrupt.h> | ||
21 | #include <linux/irq.h> | ||
20 | 22 | ||
21 | #define PCH_GPIO_ALL_PINS 0xfff /* Mask for GPIO pins 0 to 11 */ | 23 | #define PCH_EDGE_FALLING 0 |
22 | #define GPIO_NUM_PINS 12 /* Specifies number of GPIO PINS GPIO0-GPIO11 */ | 24 | #define PCH_EDGE_RISING BIT(0) |
25 | #define PCH_LEVEL_L BIT(1) | ||
26 | #define PCH_LEVEL_H (BIT(0) | BIT(1)) | ||
27 | #define PCH_EDGE_BOTH BIT(2) | ||
28 | #define PCH_IM_MASK (BIT(0) | BIT(1) | BIT(2)) | ||
29 | |||
30 | #define PCH_IRQ_BASE 24 | ||
23 | 31 | ||
24 | struct pch_regs { | 32 | struct pch_regs { |
25 | u32 ien; | 33 | u32 ien; |
@@ -33,18 +41,43 @@ struct pch_regs { | |||
33 | u32 pm; | 41 | u32 pm; |
34 | u32 im0; | 42 | u32 im0; |
35 | u32 im1; | 43 | u32 im1; |
36 | u32 reserved[4]; | 44 | u32 reserved[3]; |
45 | u32 gpio_use_sel; | ||
37 | u32 reset; | 46 | u32 reset; |
38 | }; | 47 | }; |
39 | 48 | ||
49 | enum pch_type_t { | ||
50 | INTEL_EG20T_PCH, | ||
51 | OKISEMI_ML7223m_IOH, /* OKISEMI ML7223 IOH PCIe Bus-m */ | ||
52 | OKISEMI_ML7223n_IOH /* OKISEMI ML7223 IOH PCIe Bus-n */ | ||
53 | }; | ||
54 | |||
55 | /* Specifies number of GPIO PINS */ | ||
56 | static int gpio_pins[] = { | ||
57 | [INTEL_EG20T_PCH] = 12, | ||
58 | [OKISEMI_ML7223m_IOH] = 8, | ||
59 | [OKISEMI_ML7223n_IOH] = 8, | ||
60 | }; | ||
61 | |||
40 | /** | 62 | /** |
41 | * struct pch_gpio_reg_data - The register store data. | 63 | * struct pch_gpio_reg_data - The register store data. |
64 | * @ien_reg: To store contents of IEN register. | ||
65 | * @imask_reg: To store contents of IMASK register. | ||
42 | * @po_reg: To store contents of PO register. | 66 | * @po_reg: To store contents of PO register. |
43 | * @pm_reg: To store contents of PM register. | 67 | * @pm_reg: To store contents of PM register. |
68 | * @im0_reg: To store contents of IM0 register. | ||
69 | * @im1_reg: To store contents of IM1 register. | ||
70 | * @gpio_use_sel_reg : To store contents of GPIO_USE_SEL register. | ||
71 | * (Only ML7223 Bus-n) | ||
44 | */ | 72 | */ |
45 | struct pch_gpio_reg_data { | 73 | struct pch_gpio_reg_data { |
74 | u32 ien_reg; | ||
75 | u32 imask_reg; | ||
46 | u32 po_reg; | 76 | u32 po_reg; |
47 | u32 pm_reg; | 77 | u32 pm_reg; |
78 | u32 im0_reg; | ||
79 | u32 im1_reg; | ||
80 | u32 gpio_use_sel_reg; | ||
48 | }; | 81 | }; |
49 | 82 | ||
50 | /** | 83 | /** |
@@ -55,6 +88,12 @@ struct pch_gpio_reg_data { | |||
55 | * @gpio: Data for GPIO infrastructure. | 88 | * @gpio: Data for GPIO infrastructure. |
56 | * @pch_gpio_reg: Memory mapped Register data is saved here | 89 | * @pch_gpio_reg: Memory mapped Register data is saved here |
57 | * when suspend. | 90 | * when suspend. |
91 | * @lock: Used for register access protection | ||
92 | * @irq_base: Save base of IRQ number for interrupt | ||
93 | * @ioh: IOH ID | ||
94 | * @spinlock: Used for register access protection in | ||
95 | * interrupt context pch_irq_mask, | ||
96 | * pch_irq_unmask and pch_irq_type; | ||
58 | */ | 97 | */ |
59 | struct pch_gpio { | 98 | struct pch_gpio { |
60 | void __iomem *base; | 99 | void __iomem *base; |
@@ -63,6 +102,9 @@ struct pch_gpio { | |||
63 | struct gpio_chip gpio; | 102 | struct gpio_chip gpio; |
64 | struct pch_gpio_reg_data pch_gpio_reg; | 103 | struct pch_gpio_reg_data pch_gpio_reg; |
65 | struct mutex lock; | 104 | struct mutex lock; |
105 | int irq_base; | ||
106 | enum pch_type_t ioh; | ||
107 | spinlock_t spinlock; | ||
66 | }; | 108 | }; |
67 | 109 | ||
68 | static void pch_gpio_set(struct gpio_chip *gpio, unsigned nr, int val) | 110 | static void pch_gpio_set(struct gpio_chip *gpio, unsigned nr, int val) |
@@ -96,7 +138,7 @@ static int pch_gpio_direction_output(struct gpio_chip *gpio, unsigned nr, | |||
96 | u32 reg_val; | 138 | u32 reg_val; |
97 | 139 | ||
98 | mutex_lock(&chip->lock); | 140 | mutex_lock(&chip->lock); |
99 | pm = ioread32(&chip->reg->pm) & PCH_GPIO_ALL_PINS; | 141 | pm = ioread32(&chip->reg->pm) & ((1 << gpio_pins[chip->ioh]) - 1); |
100 | pm |= (1 << nr); | 142 | pm |= (1 << nr); |
101 | iowrite32(pm, &chip->reg->pm); | 143 | iowrite32(pm, &chip->reg->pm); |
102 | 144 | ||
@@ -118,7 +160,7 @@ static int pch_gpio_direction_input(struct gpio_chip *gpio, unsigned nr) | |||
118 | u32 pm; | 160 | u32 pm; |
119 | 161 | ||
120 | mutex_lock(&chip->lock); | 162 | mutex_lock(&chip->lock); |
121 | pm = ioread32(&chip->reg->pm) & PCH_GPIO_ALL_PINS; /*bits 0-11*/ | 163 | pm = ioread32(&chip->reg->pm) & ((1 << gpio_pins[chip->ioh]) - 1); |
122 | pm &= ~(1 << nr); | 164 | pm &= ~(1 << nr); |
123 | iowrite32(pm, &chip->reg->pm); | 165 | iowrite32(pm, &chip->reg->pm); |
124 | mutex_unlock(&chip->lock); | 166 | mutex_unlock(&chip->lock); |
@@ -131,8 +173,16 @@ static int pch_gpio_direction_input(struct gpio_chip *gpio, unsigned nr) | |||
131 | */ | 173 | */ |
132 | static void pch_gpio_save_reg_conf(struct pch_gpio *chip) | 174 | static void pch_gpio_save_reg_conf(struct pch_gpio *chip) |
133 | { | 175 | { |
176 | chip->pch_gpio_reg.ien_reg = ioread32(&chip->reg->ien); | ||
177 | chip->pch_gpio_reg.imask_reg = ioread32(&chip->reg->imask); | ||
134 | chip->pch_gpio_reg.po_reg = ioread32(&chip->reg->po); | 178 | chip->pch_gpio_reg.po_reg = ioread32(&chip->reg->po); |
135 | chip->pch_gpio_reg.pm_reg = ioread32(&chip->reg->pm); | 179 | chip->pch_gpio_reg.pm_reg = ioread32(&chip->reg->pm); |
180 | chip->pch_gpio_reg.im0_reg = ioread32(&chip->reg->im0); | ||
181 | if (chip->ioh == INTEL_EG20T_PCH) | ||
182 | chip->pch_gpio_reg.im1_reg = ioread32(&chip->reg->im1); | ||
183 | if (chip->ioh == OKISEMI_ML7223n_IOH) | ||
184 | chip->pch_gpio_reg.gpio_use_sel_reg =\ | ||
185 | ioread32(&chip->reg->gpio_use_sel); | ||
136 | } | 186 | } |
137 | 187 | ||
138 | /* | 188 | /* |
@@ -140,10 +190,24 @@ static void pch_gpio_save_reg_conf(struct pch_gpio *chip) | |||
140 | */ | 190 | */ |
141 | static void pch_gpio_restore_reg_conf(struct pch_gpio *chip) | 191 | static void pch_gpio_restore_reg_conf(struct pch_gpio *chip) |
142 | { | 192 | { |
193 | iowrite32(chip->pch_gpio_reg.ien_reg, &chip->reg->ien); | ||
194 | iowrite32(chip->pch_gpio_reg.imask_reg, &chip->reg->imask); | ||
143 | /* to store contents of PO register */ | 195 | /* to store contents of PO register */ |
144 | iowrite32(chip->pch_gpio_reg.po_reg, &chip->reg->po); | 196 | iowrite32(chip->pch_gpio_reg.po_reg, &chip->reg->po); |
145 | /* to store contents of PM register */ | 197 | /* to store contents of PM register */ |
146 | iowrite32(chip->pch_gpio_reg.pm_reg, &chip->reg->pm); | 198 | iowrite32(chip->pch_gpio_reg.pm_reg, &chip->reg->pm); |
199 | iowrite32(chip->pch_gpio_reg.im0_reg, &chip->reg->im0); | ||
200 | if (chip->ioh == INTEL_EG20T_PCH) | ||
201 | iowrite32(chip->pch_gpio_reg.im1_reg, &chip->reg->im1); | ||
202 | if (chip->ioh == OKISEMI_ML7223n_IOH) | ||
203 | iowrite32(chip->pch_gpio_reg.gpio_use_sel_reg, | ||
204 | &chip->reg->gpio_use_sel); | ||
205 | } | ||
206 | |||
207 | static int pch_gpio_to_irq(struct gpio_chip *gpio, unsigned offset) | ||
208 | { | ||
209 | struct pch_gpio *chip = container_of(gpio, struct pch_gpio, gpio); | ||
210 | return chip->irq_base + offset; | ||
147 | } | 211 | } |
148 | 212 | ||
149 | static void pch_gpio_setup(struct pch_gpio *chip) | 213 | static void pch_gpio_setup(struct pch_gpio *chip) |
@@ -158,8 +222,132 @@ static void pch_gpio_setup(struct pch_gpio *chip) | |||
158 | gpio->set = pch_gpio_set; | 222 | gpio->set = pch_gpio_set; |
159 | gpio->dbg_show = NULL; | 223 | gpio->dbg_show = NULL; |
160 | gpio->base = -1; | 224 | gpio->base = -1; |
161 | gpio->ngpio = GPIO_NUM_PINS; | 225 | gpio->ngpio = gpio_pins[chip->ioh]; |
162 | gpio->can_sleep = 0; | 226 | gpio->can_sleep = 0; |
227 | gpio->to_irq = pch_gpio_to_irq; | ||
228 | } | ||
229 | |||
230 | static int pch_irq_type(struct irq_data *d, unsigned int type) | ||
231 | { | ||
232 | u32 im; | ||
233 | u32 *im_reg; | ||
234 | u32 ien; | ||
235 | u32 im_pos; | ||
236 | int ch; | ||
237 | unsigned long flags; | ||
238 | u32 val; | ||
239 | int irq = d->irq; | ||
240 | struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); | ||
241 | struct pch_gpio *chip = gc->private; | ||
242 | |||
243 | ch = irq - chip->irq_base; | ||
244 | if (irq <= chip->irq_base + 7) { | ||
245 | im_reg = &chip->reg->im0; | ||
246 | im_pos = ch; | ||
247 | } else { | ||
248 | im_reg = &chip->reg->im1; | ||
249 | im_pos = ch - 8; | ||
250 | } | ||
251 | dev_dbg(chip->dev, "%s:irq=%d type=%d ch=%d pos=%d\n", | ||
252 | __func__, irq, type, ch, im_pos); | ||
253 | |||
254 | spin_lock_irqsave(&chip->spinlock, flags); | ||
255 | |||
256 | switch (type) { | ||
257 | case IRQ_TYPE_EDGE_RISING: | ||
258 | val = PCH_EDGE_RISING; | ||
259 | break; | ||
260 | case IRQ_TYPE_EDGE_FALLING: | ||
261 | val = PCH_EDGE_FALLING; | ||
262 | break; | ||
263 | case IRQ_TYPE_EDGE_BOTH: | ||
264 | val = PCH_EDGE_BOTH; | ||
265 | break; | ||
266 | case IRQ_TYPE_LEVEL_HIGH: | ||
267 | val = PCH_LEVEL_H; | ||
268 | break; | ||
269 | case IRQ_TYPE_LEVEL_LOW: | ||
270 | val = PCH_LEVEL_L; | ||
271 | break; | ||
272 | case IRQ_TYPE_PROBE: | ||
273 | goto end; | ||
274 | default: | ||
275 | dev_warn(chip->dev, "%s: unknown type(%dd)", | ||
276 | __func__, type); | ||
277 | goto end; | ||
278 | } | ||
279 | |||
280 | /* Set interrupt mode */ | ||
281 | im = ioread32(im_reg) & ~(PCH_IM_MASK << (im_pos * 4)); | ||
282 | iowrite32(im | (val << (im_pos * 4)), im_reg); | ||
283 | |||
284 | /* iclr */ | ||
285 | iowrite32(BIT(ch), &chip->reg->iclr); | ||
286 | |||
287 | /* IMASKCLR */ | ||
288 | iowrite32(BIT(ch), &chip->reg->imaskclr); | ||
289 | |||
290 | /* Enable interrupt */ | ||
291 | ien = ioread32(&chip->reg->ien); | ||
292 | iowrite32(ien | BIT(ch), &chip->reg->ien); | ||
293 | end: | ||
294 | spin_unlock_irqrestore(&chip->spinlock, flags); | ||
295 | |||
296 | return 0; | ||
297 | } | ||
298 | |||
299 | static void pch_irq_unmask(struct irq_data *d) | ||
300 | { | ||
301 | struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); | ||
302 | struct pch_gpio *chip = gc->private; | ||
303 | |||
304 | iowrite32(1 << (d->irq - chip->irq_base), &chip->reg->imaskclr); | ||
305 | } | ||
306 | |||
307 | static void pch_irq_mask(struct irq_data *d) | ||
308 | { | ||
309 | struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d); | ||
310 | struct pch_gpio *chip = gc->private; | ||
311 | |||
312 | iowrite32(1 << (d->irq - chip->irq_base), &chip->reg->imask); | ||
313 | } | ||
314 | |||
315 | static irqreturn_t pch_gpio_handler(int irq, void *dev_id) | ||
316 | { | ||
317 | struct pch_gpio *chip = dev_id; | ||
318 | u32 reg_val = ioread32(&chip->reg->istatus); | ||
319 | int i; | ||
320 | int ret = IRQ_NONE; | ||
321 | |||
322 | for (i = 0; i < gpio_pins[chip->ioh]; i++) { | ||
323 | if (reg_val & BIT(i)) { | ||
324 | dev_dbg(chip->dev, "%s:[%d]:irq=%d status=0x%x\n", | ||
325 | __func__, i, irq, reg_val); | ||
326 | iowrite32(BIT(i), &chip->reg->iclr); | ||
327 | generic_handle_irq(chip->irq_base + i); | ||
328 | ret = IRQ_HANDLED; | ||
329 | } | ||
330 | } | ||
331 | return ret; | ||
332 | } | ||
333 | |||
334 | static __devinit void pch_gpio_alloc_generic_chip(struct pch_gpio *chip, | ||
335 | unsigned int irq_start, unsigned int num) | ||
336 | { | ||
337 | struct irq_chip_generic *gc; | ||
338 | struct irq_chip_type *ct; | ||
339 | |||
340 | gc = irq_alloc_generic_chip("pch_gpio", 1, irq_start, chip->base, | ||
341 | handle_simple_irq); | ||
342 | gc->private = chip; | ||
343 | ct = gc->chip_types; | ||
344 | |||
345 | ct->chip.irq_mask = pch_irq_mask; | ||
346 | ct->chip.irq_unmask = pch_irq_unmask; | ||
347 | ct->chip.irq_set_type = pch_irq_type; | ||
348 | |||
349 | irq_setup_generic_chip(gc, IRQ_MSK(num), IRQ_GC_INIT_MASK_CACHE, | ||
350 | IRQ_NOREQUEST | IRQ_NOPROBE, 0); | ||
163 | } | 351 | } |
164 | 352 | ||
165 | static int __devinit pch_gpio_probe(struct pci_dev *pdev, | 353 | static int __devinit pch_gpio_probe(struct pci_dev *pdev, |
@@ -167,6 +355,7 @@ static int __devinit pch_gpio_probe(struct pci_dev *pdev, | |||
167 | { | 355 | { |
168 | s32 ret; | 356 | s32 ret; |
169 | struct pch_gpio *chip; | 357 | struct pch_gpio *chip; |
358 | int irq_base; | ||
170 | 359 | ||
171 | chip = kzalloc(sizeof(*chip), GFP_KERNEL); | 360 | chip = kzalloc(sizeof(*chip), GFP_KERNEL); |
172 | if (chip == NULL) | 361 | if (chip == NULL) |
@@ -192,6 +381,13 @@ static int __devinit pch_gpio_probe(struct pci_dev *pdev, | |||
192 | goto err_iomap; | 381 | goto err_iomap; |
193 | } | 382 | } |
194 | 383 | ||
384 | if (pdev->device == 0x8803) | ||
385 | chip->ioh = INTEL_EG20T_PCH; | ||
386 | else if (pdev->device == 0x8014) | ||
387 | chip->ioh = OKISEMI_ML7223m_IOH; | ||
388 | else if (pdev->device == 0x8043) | ||
389 | chip->ioh = OKISEMI_ML7223n_IOH; | ||
390 | |||
195 | chip->reg = chip->base; | 391 | chip->reg = chip->base; |
196 | pci_set_drvdata(pdev, chip); | 392 | pci_set_drvdata(pdev, chip); |
197 | mutex_init(&chip->lock); | 393 | mutex_init(&chip->lock); |
@@ -202,8 +398,36 @@ static int __devinit pch_gpio_probe(struct pci_dev *pdev, | |||
202 | goto err_gpiochip_add; | 398 | goto err_gpiochip_add; |
203 | } | 399 | } |
204 | 400 | ||
401 | irq_base = irq_alloc_descs(-1, 0, gpio_pins[chip->ioh], NUMA_NO_NODE); | ||
402 | if (irq_base < 0) { | ||
403 | dev_warn(&pdev->dev, "PCH gpio: Failed to get IRQ base num\n"); | ||
404 | chip->irq_base = -1; | ||
405 | goto end; | ||
406 | } | ||
407 | chip->irq_base = irq_base; | ||
408 | |||
409 | ret = request_irq(pdev->irq, pch_gpio_handler, | ||
410 | IRQF_SHARED, KBUILD_MODNAME, chip); | ||
411 | if (ret != 0) { | ||
412 | dev_err(&pdev->dev, | ||
413 | "%s request_irq failed\n", __func__); | ||
414 | goto err_request_irq; | ||
415 | } | ||
416 | |||
417 | pch_gpio_alloc_generic_chip(chip, irq_base, gpio_pins[chip->ioh]); | ||
418 | |||
419 | /* Initialize interrupt ien register */ | ||
420 | iowrite32(0, &chip->reg->ien); | ||
421 | end: | ||
205 | return 0; | 422 | return 0; |
206 | 423 | ||
424 | err_request_irq: | ||
425 | irq_free_descs(irq_base, gpio_pins[chip->ioh]); | ||
426 | |||
427 | ret = gpiochip_remove(&chip->gpio); | ||
428 | if (ret) | ||
429 | dev_err(&pdev->dev, "%s gpiochip_remove failed\n", __func__); | ||
430 | |||
207 | err_gpiochip_add: | 431 | err_gpiochip_add: |
208 | pci_iounmap(pdev, chip->base); | 432 | pci_iounmap(pdev, chip->base); |
209 | 433 | ||
@@ -224,6 +448,12 @@ static void __devexit pch_gpio_remove(struct pci_dev *pdev) | |||
224 | int err; | 448 | int err; |
225 | struct pch_gpio *chip = pci_get_drvdata(pdev); | 449 | struct pch_gpio *chip = pci_get_drvdata(pdev); |
226 | 450 | ||
451 | if (chip->irq_base != -1) { | ||
452 | free_irq(pdev->irq, chip); | ||
453 | |||
454 | irq_free_descs(chip->irq_base, gpio_pins[chip->ioh]); | ||
455 | } | ||
456 | |||
227 | err = gpiochip_remove(&chip->gpio); | 457 | err = gpiochip_remove(&chip->gpio); |
228 | if (err) | 458 | if (err) |
229 | dev_err(&pdev->dev, "Failed gpiochip_remove\n"); | 459 | dev_err(&pdev->dev, "Failed gpiochip_remove\n"); |
@@ -239,9 +469,11 @@ static int pch_gpio_suspend(struct pci_dev *pdev, pm_message_t state) | |||
239 | { | 469 | { |
240 | s32 ret; | 470 | s32 ret; |
241 | struct pch_gpio *chip = pci_get_drvdata(pdev); | 471 | struct pch_gpio *chip = pci_get_drvdata(pdev); |
472 | unsigned long flags; | ||
242 | 473 | ||
474 | spin_lock_irqsave(&chip->spinlock, flags); | ||
243 | pch_gpio_save_reg_conf(chip); | 475 | pch_gpio_save_reg_conf(chip); |
244 | pch_gpio_restore_reg_conf(chip); | 476 | spin_unlock_irqrestore(&chip->spinlock, flags); |
245 | 477 | ||
246 | ret = pci_save_state(pdev); | 478 | ret = pci_save_state(pdev); |
247 | if (ret) { | 479 | if (ret) { |
@@ -261,6 +493,7 @@ static int pch_gpio_resume(struct pci_dev *pdev) | |||
261 | { | 493 | { |
262 | s32 ret; | 494 | s32 ret; |
263 | struct pch_gpio *chip = pci_get_drvdata(pdev); | 495 | struct pch_gpio *chip = pci_get_drvdata(pdev); |
496 | unsigned long flags; | ||
264 | 497 | ||
265 | ret = pci_enable_wake(pdev, PCI_D0, 0); | 498 | ret = pci_enable_wake(pdev, PCI_D0, 0); |
266 | 499 | ||
@@ -272,9 +505,11 @@ static int pch_gpio_resume(struct pci_dev *pdev) | |||
272 | } | 505 | } |
273 | pci_restore_state(pdev); | 506 | pci_restore_state(pdev); |
274 | 507 | ||
508 | spin_lock_irqsave(&chip->spinlock, flags); | ||
275 | iowrite32(0x01, &chip->reg->reset); | 509 | iowrite32(0x01, &chip->reg->reset); |
276 | iowrite32(0x00, &chip->reg->reset); | 510 | iowrite32(0x00, &chip->reg->reset); |
277 | pch_gpio_restore_reg_conf(chip); | 511 | pch_gpio_restore_reg_conf(chip); |
512 | spin_unlock_irqrestore(&chip->spinlock, flags); | ||
278 | 513 | ||
279 | return 0; | 514 | return 0; |
280 | } | 515 | } |
@@ -287,6 +522,7 @@ static int pch_gpio_resume(struct pci_dev *pdev) | |||
287 | static DEFINE_PCI_DEVICE_TABLE(pch_gpio_pcidev_id) = { | 522 | static DEFINE_PCI_DEVICE_TABLE(pch_gpio_pcidev_id) = { |
288 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x8803) }, | 523 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x8803) }, |
289 | { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8014) }, | 524 | { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8014) }, |
525 | { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8043) }, | ||
290 | { 0, } | 526 | { 0, } |
291 | }; | 527 | }; |
292 | MODULE_DEVICE_TABLE(pci, pch_gpio_pcidev_id); | 528 | MODULE_DEVICE_TABLE(pci, pch_gpio_pcidev_id); |