]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/video/via/via-core.c
31e30338e89306cf7e85387d2fcc8f969e9a0ac4
[~shefty/rdma-dev.git] / drivers / video / via / via-core.c
1 /*
2  * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
3  * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
4  * Copyright 2009 Jonathan Corbet <corbet@lwn.net>
5  */
6
7 /*
8  * Core code for the Via multifunction framebuffer device.
9  */
10 #include <linux/via-core.h>
11 #include <linux/via_i2c.h>
12 #include <linux/via-gpio.h>
13 #include "global.h"
14
15 #include <linux/module.h>
16 #include <linux/interrupt.h>
17 #include <linux/platform_device.h>
18
19 /*
20  * The default port config.
21  */
22 static struct via_port_cfg adap_configs[] = {
23         [VIA_PORT_26]   = { VIA_PORT_I2C,  VIA_MODE_I2C, VIASR, 0x26 },
24         [VIA_PORT_31]   = { VIA_PORT_I2C,  VIA_MODE_I2C, VIASR, 0x31 },
25         [VIA_PORT_25]   = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x25 },
26         [VIA_PORT_2C]   = { VIA_PORT_GPIO, VIA_MODE_I2C, VIASR, 0x2c },
27         [VIA_PORT_3D]   = { VIA_PORT_GPIO, VIA_MODE_GPIO, VIASR, 0x3d },
28         { 0, 0, 0, 0 }
29 };
30
31 /*
32  * We currently only support one viafb device (will there ever be
33  * more than one?), so just declare it globally here.
34  */
35 static struct viafb_dev global_dev;
36
37
38 /*
39  * Basic register access; spinlock required.
40  */
41 static inline void viafb_mmio_write(int reg, u32 v)
42 {
43         iowrite32(v, global_dev.engine_mmio + reg);
44 }
45
46 static inline int viafb_mmio_read(int reg)
47 {
48         return ioread32(global_dev.engine_mmio + reg);
49 }
50
51 /* ---------------------------------------------------------------------- */
52 /*
53  * Interrupt management.  We have a single IRQ line for a lot of
54  * different functions, so we need to share it.  The design here
55  * is that we don't want to reimplement the shared IRQ code here;
56  * we also want to avoid having contention for a single handler thread.
57  * So each subdev driver which needs interrupts just requests
58  * them directly from the kernel.  We just have what's needed for
59  * overall access to the interrupt control register.
60  */
61
62 /*
63  * Which interrupts are enabled now?
64  */
65 static u32 viafb_enabled_ints;
66
67 static void __devinit viafb_int_init(void)
68 {
69         viafb_enabled_ints = 0;
70
71         viafb_mmio_write(VDE_INTERRUPT, 0);
72 }
73
74 /*
75  * Allow subdevs to ask for specific interrupts to be enabled.  These
76  * functions must be called with reg_lock held
77  */
78 void viafb_irq_enable(u32 mask)
79 {
80         viafb_enabled_ints |= mask;
81         viafb_mmio_write(VDE_INTERRUPT, viafb_enabled_ints | VDE_I_ENABLE);
82 }
83 EXPORT_SYMBOL_GPL(viafb_irq_enable);
84
85 void viafb_irq_disable(u32 mask)
86 {
87         viafb_enabled_ints &= ~mask;
88         if (viafb_enabled_ints == 0)
89                 viafb_mmio_write(VDE_INTERRUPT, 0);  /* Disable entirely */
90         else
91                 viafb_mmio_write(VDE_INTERRUPT,
92                                 viafb_enabled_ints | VDE_I_ENABLE);
93 }
94 EXPORT_SYMBOL_GPL(viafb_irq_disable);
95
96 /* ---------------------------------------------------------------------- */
97 /*
98  * Access to the DMA engine.  This currently provides what the camera
99  * driver needs (i.e. outgoing only) but is easily expandable if need
100  * be.
101  */
102
103 /*
104  * There are four DMA channels in the vx855.  For now, we only
105  * use one of them, though.  Most of the time, the DMA channel
106  * will be idle, so we keep the IRQ handler unregistered except
107  * when some subsystem has indicated an interest.
108  */
109 static int viafb_dma_users;
110 static DECLARE_COMPLETION(viafb_dma_completion);
111 /*
112  * This mutex protects viafb_dma_users and our global interrupt
113  * registration state; it also serializes access to the DMA
114  * engine.
115  */
116 static DEFINE_MUTEX(viafb_dma_lock);
117
118 /*
119  * The VX855 DMA descriptor (used for s/g transfers) looks
120  * like this.
121  */
122 struct viafb_vx855_dma_descr {
123         u32     addr_low;       /* Low part of phys addr */
124         u32     addr_high;      /* High 12 bits of addr */
125         u32     fb_offset;      /* Offset into FB memory */
126         u32     seg_size;       /* Size, 16-byte units */
127         u32     tile_mode;      /* "tile mode" setting */
128         u32     next_desc_low;  /* Next descriptor addr */
129         u32     next_desc_high;
130         u32     pad;            /* Fill out to 64 bytes */
131 };
132
133 /*
134  * Flags added to the "next descriptor low" pointers
135  */
136 #define VIAFB_DMA_MAGIC         0x01  /* ??? Just has to be there */
137 #define VIAFB_DMA_FINAL_SEGMENT 0x02  /* Final segment */
138
139 /*
140  * The completion IRQ handler.
141  */
142 static irqreturn_t viafb_dma_irq(int irq, void *data)
143 {
144         int csr;
145         irqreturn_t ret = IRQ_NONE;
146
147         spin_lock(&global_dev.reg_lock);
148         csr = viafb_mmio_read(VDMA_CSR0);
149         if (csr & VDMA_C_DONE) {
150                 viafb_mmio_write(VDMA_CSR0, VDMA_C_DONE);
151                 complete(&viafb_dma_completion);
152                 ret = IRQ_HANDLED;
153         }
154         spin_unlock(&global_dev.reg_lock);
155         return ret;
156 }
157
158 /*
159  * Indicate a need for DMA functionality.
160  */
161 int viafb_request_dma(void)
162 {
163         int ret = 0;
164
165         /*
166          * Only VX855 is supported currently.
167          */
168         if (global_dev.chip_type != UNICHROME_VX855)
169                 return -ENODEV;
170         /*
171          * Note the new user and set up our interrupt handler
172          * if need be.
173          */
174         mutex_lock(&viafb_dma_lock);
175         viafb_dma_users++;
176         if (viafb_dma_users == 1) {
177                 ret = request_irq(global_dev.pdev->irq, viafb_dma_irq,
178                                 IRQF_SHARED, "via-dma", &viafb_dma_users);
179                 if (ret)
180                         viafb_dma_users--;
181                 else
182                         viafb_irq_enable(VDE_I_DMA0TDEN);
183         }
184         mutex_unlock(&viafb_dma_lock);
185         return ret;
186 }
187 EXPORT_SYMBOL_GPL(viafb_request_dma);
188
189 void viafb_release_dma(void)
190 {
191         mutex_lock(&viafb_dma_lock);
192         viafb_dma_users--;
193         if (viafb_dma_users == 0) {
194                 viafb_irq_disable(VDE_I_DMA0TDEN);
195                 free_irq(global_dev.pdev->irq, &viafb_dma_users);
196         }
197         mutex_unlock(&viafb_dma_lock);
198 }
199 EXPORT_SYMBOL_GPL(viafb_release_dma);
200
201
202 #if 0
203 /*
204  * Copy a single buffer from FB memory, synchronously.  This code works
205  * but is not currently used.
206  */
207 void viafb_dma_copy_out(unsigned int offset, dma_addr_t paddr, int len)
208 {
209         unsigned long flags;
210         int csr;
211
212         mutex_lock(&viafb_dma_lock);
213         init_completion(&viafb_dma_completion);
214         /*
215          * Program the controller.
216          */
217         spin_lock_irqsave(&global_dev.reg_lock, flags);
218         viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_DONE);
219         /* Enable ints; must happen after CSR0 write! */
220         viafb_mmio_write(VDMA_MR0, VDMA_MR_TDIE);
221         viafb_mmio_write(VDMA_MARL0, (int) (paddr & 0xfffffff0));
222         viafb_mmio_write(VDMA_MARH0, (int) ((paddr >> 28) & 0xfff));
223         /* Data sheet suggests DAR0 should be <<4, but it lies */
224         viafb_mmio_write(VDMA_DAR0, offset);
225         viafb_mmio_write(VDMA_DQWCR0, len >> 4);
226         viafb_mmio_write(VDMA_TMR0, 0);
227         viafb_mmio_write(VDMA_DPRL0, 0);
228         viafb_mmio_write(VDMA_DPRH0, 0);
229         viafb_mmio_write(VDMA_PMR0, 0);
230         csr = viafb_mmio_read(VDMA_CSR0);
231         viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_START);
232         spin_unlock_irqrestore(&global_dev.reg_lock, flags);
233         /*
234          * Now we just wait until the interrupt handler says
235          * we're done.
236          */
237         wait_for_completion_interruptible(&viafb_dma_completion);
238         viafb_mmio_write(VDMA_MR0, 0); /* Reset int enable */
239         mutex_unlock(&viafb_dma_lock);
240 }
241 EXPORT_SYMBOL_GPL(viafb_dma_copy_out);
242 #endif
243
244 /*
245  * Do a scatter/gather DMA copy from FB memory.  You must have done
246  * a successful call to viafb_request_dma() first.
247  */
248 int viafb_dma_copy_out_sg(unsigned int offset, struct scatterlist *sg, int nsg)
249 {
250         struct viafb_vx855_dma_descr *descr;
251         void *descrpages;
252         dma_addr_t descr_handle;
253         unsigned long flags;
254         int i;
255         struct scatterlist *sgentry;
256         dma_addr_t nextdesc;
257
258         /*
259          * Get a place to put the descriptors.
260          */
261         descrpages = dma_alloc_coherent(&global_dev.pdev->dev,
262                         nsg*sizeof(struct viafb_vx855_dma_descr),
263                         &descr_handle, GFP_KERNEL);
264         if (descrpages == NULL) {
265                 dev_err(&global_dev.pdev->dev, "Unable to get descr page.\n");
266                 return -ENOMEM;
267         }
268         mutex_lock(&viafb_dma_lock);
269         /*
270          * Fill them in.
271          */
272         descr = descrpages;
273         nextdesc = descr_handle + sizeof(struct viafb_vx855_dma_descr);
274         for_each_sg(sg, sgentry, nsg, i) {
275                 dma_addr_t paddr = sg_dma_address(sgentry);
276                 descr->addr_low = paddr & 0xfffffff0;
277                 descr->addr_high = ((u64) paddr >> 32) & 0x0fff;
278                 descr->fb_offset = offset;
279                 descr->seg_size = sg_dma_len(sgentry) >> 4;
280                 descr->tile_mode = 0;
281                 descr->next_desc_low = (nextdesc&0xfffffff0) | VIAFB_DMA_MAGIC;
282                 descr->next_desc_high = ((u64) nextdesc >> 32) & 0x0fff;
283                 descr->pad = 0xffffffff;  /* VIA driver does this */
284                 offset += sg_dma_len(sgentry);
285                 nextdesc += sizeof(struct viafb_vx855_dma_descr);
286                 descr++;
287         }
288         descr[-1].next_desc_low = VIAFB_DMA_FINAL_SEGMENT|VIAFB_DMA_MAGIC;
289         /*
290          * Program the engine.
291          */
292         spin_lock_irqsave(&global_dev.reg_lock, flags);
293         init_completion(&viafb_dma_completion);
294         viafb_mmio_write(VDMA_DQWCR0, 0);
295         viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_DONE);
296         viafb_mmio_write(VDMA_MR0, VDMA_MR_TDIE | VDMA_MR_CHAIN);
297         viafb_mmio_write(VDMA_DPRL0, descr_handle | VIAFB_DMA_MAGIC);
298         viafb_mmio_write(VDMA_DPRH0,
299                         (((u64)descr_handle >> 32) & 0x0fff) | 0xf0000);
300         (void) viafb_mmio_read(VDMA_CSR0);
301         viafb_mmio_write(VDMA_CSR0, VDMA_C_ENABLE|VDMA_C_START);
302         spin_unlock_irqrestore(&global_dev.reg_lock, flags);
303         /*
304          * Now we just wait until the interrupt handler says
305          * we're done.  Except that, actually, we need to wait a little
306          * longer: the interrupts seem to jump the gun a little and we
307          * get corrupted frames sometimes.
308          */
309         wait_for_completion_timeout(&viafb_dma_completion, 1);
310         msleep(1);
311         if ((viafb_mmio_read(VDMA_CSR0)&VDMA_C_DONE) == 0)
312                 printk(KERN_ERR "VIA DMA timeout!\n");
313         /*
314          * Clean up and we're done.
315          */
316         viafb_mmio_write(VDMA_CSR0, VDMA_C_DONE);
317         viafb_mmio_write(VDMA_MR0, 0); /* Reset int enable */
318         mutex_unlock(&viafb_dma_lock);
319         dma_free_coherent(&global_dev.pdev->dev,
320                         nsg*sizeof(struct viafb_vx855_dma_descr), descrpages,
321                         descr_handle);
322         return 0;
323 }
324 EXPORT_SYMBOL_GPL(viafb_dma_copy_out_sg);
325
326
327 /* ---------------------------------------------------------------------- */
328 /*
329  * Figure out how big our framebuffer memory is.  Kind of ugly,
330  * but evidently we can't trust the information found in the
331  * fbdev configuration area.
332  */
333 static u16 via_function3[] = {
334         CLE266_FUNCTION3, KM400_FUNCTION3, CN400_FUNCTION3, CN700_FUNCTION3,
335         CX700_FUNCTION3, KM800_FUNCTION3, KM890_FUNCTION3, P4M890_FUNCTION3,
336         P4M900_FUNCTION3, VX800_FUNCTION3, VX855_FUNCTION3, VX900_FUNCTION3,
337 };
338
339 /* Get the BIOS-configured framebuffer size from PCI configuration space
340  * of function 3 in the respective chipset */
341 static int viafb_get_fb_size_from_pci(int chip_type)
342 {
343         int i;
344         u8 offset = 0;
345         u32 FBSize;
346         u32 VideoMemSize;
347
348         /* search for the "FUNCTION3" device in this chipset */
349         for (i = 0; i < ARRAY_SIZE(via_function3); i++) {
350                 struct pci_dev *pdev;
351
352                 pdev = pci_get_device(PCI_VENDOR_ID_VIA, via_function3[i],
353                                       NULL);
354                 if (!pdev)
355                         continue;
356
357                 DEBUG_MSG(KERN_INFO "Device ID = %x\n", pdev->device);
358
359                 switch (pdev->device) {
360                 case CLE266_FUNCTION3:
361                 case KM400_FUNCTION3:
362                         offset = 0xE0;
363                         break;
364                 case CN400_FUNCTION3:
365                 case CN700_FUNCTION3:
366                 case CX700_FUNCTION3:
367                 case KM800_FUNCTION3:
368                 case KM890_FUNCTION3:
369                 case P4M890_FUNCTION3:
370                 case P4M900_FUNCTION3:
371                 case VX800_FUNCTION3:
372                 case VX855_FUNCTION3:
373                 case VX900_FUNCTION3:
374                 /*case CN750_FUNCTION3: */
375                         offset = 0xA0;
376                         break;
377                 }
378
379                 if (!offset)
380                         break;
381
382                 pci_read_config_dword(pdev, offset, &FBSize);
383                 pci_dev_put(pdev);
384         }
385
386         if (!offset) {
387                 printk(KERN_ERR "cannot determine framebuffer size\n");
388                 return -EIO;
389         }
390
391         FBSize = FBSize & 0x00007000;
392         DEBUG_MSG(KERN_INFO "FB Size = %x\n", FBSize);
393
394         if (chip_type < UNICHROME_CX700) {
395                 switch (FBSize) {
396                 case 0x00004000:
397                         VideoMemSize = (16 << 20);      /*16M */
398                         break;
399
400                 case 0x00005000:
401                         VideoMemSize = (32 << 20);      /*32M */
402                         break;
403
404                 case 0x00006000:
405                         VideoMemSize = (64 << 20);      /*64M */
406                         break;
407
408                 default:
409                         VideoMemSize = (32 << 20);      /*32M */
410                         break;
411                 }
412         } else {
413                 switch (FBSize) {
414                 case 0x00001000:
415                         VideoMemSize = (8 << 20);       /*8M */
416                         break;
417
418                 case 0x00002000:
419                         VideoMemSize = (16 << 20);      /*16M */
420                         break;
421
422                 case 0x00003000:
423                         VideoMemSize = (32 << 20);      /*32M */
424                         break;
425
426                 case 0x00004000:
427                         VideoMemSize = (64 << 20);      /*64M */
428                         break;
429
430                 case 0x00005000:
431                         VideoMemSize = (128 << 20);     /*128M */
432                         break;
433
434                 case 0x00006000:
435                         VideoMemSize = (256 << 20);     /*256M */
436                         break;
437
438                 case 0x00007000:        /* Only on VX855/875 */
439                         VideoMemSize = (512 << 20);     /*512M */
440                         break;
441
442                 default:
443                         VideoMemSize = (32 << 20);      /*32M */
444                         break;
445                 }
446         }
447
448         return VideoMemSize;
449 }
450
451
452 /*
453  * Figure out and map our MMIO regions.
454  */
455 static int __devinit via_pci_setup_mmio(struct viafb_dev *vdev)
456 {
457         int ret;
458         /*
459          * Hook up to the device registers.  Note that we soldier
460          * on if it fails; the framebuffer can operate (without
461          * acceleration) without this region.
462          */
463         vdev->engine_start = pci_resource_start(vdev->pdev, 1);
464         vdev->engine_len = pci_resource_len(vdev->pdev, 1);
465         vdev->engine_mmio = ioremap_nocache(vdev->engine_start,
466                         vdev->engine_len);
467         if (vdev->engine_mmio == NULL)
468                 dev_err(&vdev->pdev->dev,
469                                 "Unable to map engine MMIO; operation will be "
470                                 "slow and crippled.\n");
471         /*
472          * Map in framebuffer memory.  For now, failure here is
473          * fatal.  Unfortunately, in the absence of significant
474          * vmalloc space, failure here is also entirely plausible.
475          * Eventually we want to move away from mapping this
476          * entire region.
477          */
478         if (vdev->chip_type == UNICHROME_VX900)
479                 vdev->fbmem_start = pci_resource_start(vdev->pdev, 2);
480         else
481                 vdev->fbmem_start = pci_resource_start(vdev->pdev, 0);
482         ret = vdev->fbmem_len = viafb_get_fb_size_from_pci(vdev->chip_type);
483         if (ret < 0)
484                 goto out_unmap;
485         vdev->fbmem = ioremap_nocache(vdev->fbmem_start, vdev->fbmem_len);
486         if (vdev->fbmem == NULL) {
487                 ret = -ENOMEM;
488                 goto out_unmap;
489         }
490         return 0;
491 out_unmap:
492         iounmap(vdev->engine_mmio);
493         return ret;
494 }
495
496 static void via_pci_teardown_mmio(struct viafb_dev *vdev)
497 {
498         iounmap(vdev->fbmem);
499         iounmap(vdev->engine_mmio);
500 }
501
502 /*
503  * Create our subsidiary devices.
504  */
505 static struct viafb_subdev_info {
506         char *name;
507         struct platform_device *platdev;
508 } viafb_subdevs[] = {
509         {
510                 .name = "viafb-gpio",
511         },
512         {
513                 .name = "viafb-i2c",
514         }
515 };
516 #define N_SUBDEVS ARRAY_SIZE(viafb_subdevs)
517
518 static int __devinit via_create_subdev(struct viafb_dev *vdev,
519                 struct viafb_subdev_info *info)
520 {
521         int ret;
522
523         info->platdev = platform_device_alloc(info->name, -1);
524         if (!info->platdev) {
525                 dev_err(&vdev->pdev->dev, "Unable to allocate pdev %s\n",
526                         info->name);
527                 return -ENOMEM;
528         }
529         info->platdev->dev.parent = &vdev->pdev->dev;
530         info->platdev->dev.platform_data = vdev;
531         ret = platform_device_add(info->platdev);
532         if (ret) {
533                 dev_err(&vdev->pdev->dev, "Unable to add pdev %s\n",
534                                 info->name);
535                 platform_device_put(info->platdev);
536                 info->platdev = NULL;
537         }
538         return ret;
539 }
540
541 static int __devinit via_setup_subdevs(struct viafb_dev *vdev)
542 {
543         int i;
544
545         /*
546          * Ignore return values.  Even if some of the devices
547          * fail to be created, we'll still be able to use some
548          * of the rest.
549          */
550         for (i = 0; i < N_SUBDEVS; i++)
551                 via_create_subdev(vdev, viafb_subdevs + i);
552         return 0;
553 }
554
555 static void via_teardown_subdevs(void)
556 {
557         int i;
558
559         for (i = 0; i < N_SUBDEVS; i++)
560                 if (viafb_subdevs[i].platdev) {
561                         viafb_subdevs[i].platdev->dev.platform_data = NULL;
562                         platform_device_unregister(viafb_subdevs[i].platdev);
563                 }
564 }
565
566
567 static int __devinit via_pci_probe(struct pci_dev *pdev,
568                 const struct pci_device_id *ent)
569 {
570         int ret;
571
572         ret = pci_enable_device(pdev);
573         if (ret)
574                 return ret;
575         /*
576          * Global device initialization.
577          */
578         memset(&global_dev, 0, sizeof(global_dev));
579         global_dev.pdev = pdev;
580         global_dev.chip_type = ent->driver_data;
581         global_dev.port_cfg = adap_configs;
582         spin_lock_init(&global_dev.reg_lock);
583         ret = via_pci_setup_mmio(&global_dev);
584         if (ret)
585                 goto out_disable;
586         /*
587          * Set up interrupts and create our subdevices.  Continue even if
588          * some things fail.
589          */
590         viafb_int_init();
591         via_setup_subdevs(&global_dev);
592         /*
593          * Set up the framebuffer device
594          */
595         ret = via_fb_pci_probe(&global_dev);
596         if (ret)
597                 goto out_subdevs;
598         return 0;
599
600 out_subdevs:
601         via_teardown_subdevs();
602         via_pci_teardown_mmio(&global_dev);
603 out_disable:
604         pci_disable_device(pdev);
605         return ret;
606 }
607
608 static void __devexit via_pci_remove(struct pci_dev *pdev)
609 {
610         via_teardown_subdevs();
611         via_fb_pci_remove(pdev);
612         via_pci_teardown_mmio(&global_dev);
613         pci_disable_device(pdev);
614 }
615
616
617 static struct pci_device_id via_pci_table[] __devinitdata = {
618         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CLE266_DID),
619           .driver_data = UNICHROME_CLE266 },
620         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_K400_DID),
621           .driver_data = UNICHROME_K400 },
622         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_K800_DID),
623           .driver_data = UNICHROME_K800 },
624         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_PM800_DID),
625           .driver_data = UNICHROME_PM800 },
626         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CN700_DID),
627           .driver_data = UNICHROME_CN700 },
628         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CX700_DID),
629           .driver_data = UNICHROME_CX700 },
630         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_CN750_DID),
631           .driver_data = UNICHROME_CN750 },
632         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_K8M890_DID),
633           .driver_data = UNICHROME_K8M890 },
634         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_P4M890_DID),
635           .driver_data = UNICHROME_P4M890 },
636         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_P4M900_DID),
637           .driver_data = UNICHROME_P4M900 },
638         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_VX800_DID),
639           .driver_data = UNICHROME_VX800 },
640         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_VX855_DID),
641           .driver_data = UNICHROME_VX855 },
642         { PCI_DEVICE(PCI_VENDOR_ID_VIA, UNICHROME_VX900_DID),
643           .driver_data = UNICHROME_VX900 },
644         { }
645 };
646 MODULE_DEVICE_TABLE(pci, via_pci_table);
647
648 static struct pci_driver via_driver = {
649         .name           = "viafb",
650         .id_table       = via_pci_table,
651         .probe          = via_pci_probe,
652         .remove         = __devexit_p(via_pci_remove),
653 #ifdef CONFIG_PM
654         .suspend        = viafb_suspend,
655         .resume         = viafb_resume,
656 #endif
657 };
658
659 static int __init via_core_init(void)
660 {
661         int ret;
662
663         ret = viafb_init();
664         if (ret)
665                 return ret;
666         viafb_i2c_init();
667         viafb_gpio_init();
668         return pci_register_driver(&via_driver);
669 }
670
671 static void __exit via_core_exit(void)
672 {
673         pci_unregister_driver(&via_driver);
674         viafb_gpio_exit();
675         viafb_i2c_exit();
676         viafb_exit();
677 }
678
679 module_init(via_core_init);
680 module_exit(via_core_exit);