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>
8 * Core code for the Via multifunction framebuffer device.
10 #include <linux/via-core.h>
11 #include <linux/via_i2c.h>
12 #include <linux/via-gpio.h>
15 #include <linux/module.h>
16 #include <linux/interrupt.h>
17 #include <linux/platform_device.h>
18 #include <linux/list.h>
23 * The default port config.
25 static struct via_port_cfg adap_configs
[] = {
26 [VIA_PORT_26
] = { VIA_PORT_I2C
, VIA_MODE_I2C
, VIASR
, 0x26 },
27 [VIA_PORT_31
] = { VIA_PORT_I2C
, VIA_MODE_I2C
, VIASR
, 0x31 },
28 [VIA_PORT_25
] = { VIA_PORT_GPIO
, VIA_MODE_GPIO
, VIASR
, 0x25 },
29 [VIA_PORT_2C
] = { VIA_PORT_GPIO
, VIA_MODE_I2C
, VIASR
, 0x2c },
30 [VIA_PORT_3D
] = { VIA_PORT_GPIO
, VIA_MODE_GPIO
, VIASR
, 0x3d },
35 * The OLPC XO-1.5 puts the camera power and reset lines onto
38 static struct via_port_cfg olpc_adap_configs
[] = {
39 [VIA_PORT_26
] = { VIA_PORT_I2C
, VIA_MODE_I2C
, VIASR
, 0x26 },
40 [VIA_PORT_31
] = { VIA_PORT_I2C
, VIA_MODE_I2C
, VIASR
, 0x31 },
41 [VIA_PORT_25
] = { VIA_PORT_GPIO
, VIA_MODE_GPIO
, VIASR
, 0x25 },
42 [VIA_PORT_2C
] = { VIA_PORT_GPIO
, VIA_MODE_GPIO
, VIASR
, 0x2c },
43 [VIA_PORT_3D
] = { VIA_PORT_GPIO
, VIA_MODE_GPIO
, VIASR
, 0x3d },
48 * We currently only support one viafb device (will there ever be
49 * more than one?), so just declare it globally here.
51 static struct viafb_dev global_dev
;
55 * Basic register access; spinlock required.
57 static inline void viafb_mmio_write(int reg
, u32 v
)
59 iowrite32(v
, global_dev
.engine_mmio
+ reg
);
62 static inline int viafb_mmio_read(int reg
)
64 return ioread32(global_dev
.engine_mmio
+ reg
);
67 /* ---------------------------------------------------------------------- */
69 * Interrupt management. We have a single IRQ line for a lot of
70 * different functions, so we need to share it. The design here
71 * is that we don't want to reimplement the shared IRQ code here;
72 * we also want to avoid having contention for a single handler thread.
73 * So each subdev driver which needs interrupts just requests
74 * them directly from the kernel. We just have what's needed for
75 * overall access to the interrupt control register.
79 * Which interrupts are enabled now?
81 static u32 viafb_enabled_ints
;
83 static void viafb_int_init(void)
85 viafb_enabled_ints
= 0;
87 viafb_mmio_write(VDE_INTERRUPT
, 0);
91 * Allow subdevs to ask for specific interrupts to be enabled. These
92 * functions must be called with reg_lock held
94 void viafb_irq_enable(u32 mask
)
96 viafb_enabled_ints
|= mask
;
97 viafb_mmio_write(VDE_INTERRUPT
, viafb_enabled_ints
| VDE_I_ENABLE
);
99 EXPORT_SYMBOL_GPL(viafb_irq_enable
);
101 void viafb_irq_disable(u32 mask
)
103 viafb_enabled_ints
&= ~mask
;
104 if (viafb_enabled_ints
== 0)
105 viafb_mmio_write(VDE_INTERRUPT
, 0); /* Disable entirely */
107 viafb_mmio_write(VDE_INTERRUPT
,
108 viafb_enabled_ints
| VDE_I_ENABLE
);
110 EXPORT_SYMBOL_GPL(viafb_irq_disable
);
112 /* ---------------------------------------------------------------------- */
114 * Currently, the camera driver is the only user of the DMA code, so we
115 * only compile it in if the camera driver is being built. Chances are,
116 * most viafb systems will not need to have this extra code for a while.
117 * As soon as another user comes long, the ifdef can be removed.
119 #if IS_ENABLED(CONFIG_VIDEO_VIA_CAMERA)
121 * Access to the DMA engine. This currently provides what the camera
122 * driver needs (i.e. outgoing only) but is easily expandable if need
127 * There are four DMA channels in the vx855. For now, we only
128 * use one of them, though. Most of the time, the DMA channel
129 * will be idle, so we keep the IRQ handler unregistered except
130 * when some subsystem has indicated an interest.
132 static int viafb_dma_users
;
133 static DECLARE_COMPLETION(viafb_dma_completion
);
135 * This mutex protects viafb_dma_users and our global interrupt
136 * registration state; it also serializes access to the DMA
139 static DEFINE_MUTEX(viafb_dma_lock
);
142 * The VX855 DMA descriptor (used for s/g transfers) looks
145 struct viafb_vx855_dma_descr
{
146 u32 addr_low
; /* Low part of phys addr */
147 u32 addr_high
; /* High 12 bits of addr */
148 u32 fb_offset
; /* Offset into FB memory */
149 u32 seg_size
; /* Size, 16-byte units */
150 u32 tile_mode
; /* "tile mode" setting */
151 u32 next_desc_low
; /* Next descriptor addr */
153 u32 pad
; /* Fill out to 64 bytes */
157 * Flags added to the "next descriptor low" pointers
159 #define VIAFB_DMA_MAGIC 0x01 /* ??? Just has to be there */
160 #define VIAFB_DMA_FINAL_SEGMENT 0x02 /* Final segment */
163 * The completion IRQ handler.
165 static irqreturn_t
viafb_dma_irq(int irq
, void *data
)
168 irqreturn_t ret
= IRQ_NONE
;
170 spin_lock(&global_dev
.reg_lock
);
171 csr
= viafb_mmio_read(VDMA_CSR0
);
172 if (csr
& VDMA_C_DONE
) {
173 viafb_mmio_write(VDMA_CSR0
, VDMA_C_DONE
);
174 complete(&viafb_dma_completion
);
177 spin_unlock(&global_dev
.reg_lock
);
182 * Indicate a need for DMA functionality.
184 int viafb_request_dma(void)
189 * Only VX855 is supported currently.
191 if (global_dev
.chip_type
!= UNICHROME_VX855
)
194 * Note the new user and set up our interrupt handler
197 mutex_lock(&viafb_dma_lock
);
199 if (viafb_dma_users
== 1) {
200 ret
= request_irq(global_dev
.pdev
->irq
, viafb_dma_irq
,
201 IRQF_SHARED
, "via-dma", &viafb_dma_users
);
205 viafb_irq_enable(VDE_I_DMA0TDEN
);
207 mutex_unlock(&viafb_dma_lock
);
210 EXPORT_SYMBOL_GPL(viafb_request_dma
);
212 void viafb_release_dma(void)
214 mutex_lock(&viafb_dma_lock
);
216 if (viafb_dma_users
== 0) {
217 viafb_irq_disable(VDE_I_DMA0TDEN
);
218 free_irq(global_dev
.pdev
->irq
, &viafb_dma_users
);
220 mutex_unlock(&viafb_dma_lock
);
222 EXPORT_SYMBOL_GPL(viafb_release_dma
);
227 * Copy a single buffer from FB memory, synchronously. This code works
228 * but is not currently used.
230 void viafb_dma_copy_out(unsigned int offset
, dma_addr_t paddr
, int len
)
235 mutex_lock(&viafb_dma_lock
);
236 init_completion(&viafb_dma_completion
);
238 * Program the controller.
240 spin_lock_irqsave(&global_dev
.reg_lock
, flags
);
241 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_DONE
);
242 /* Enable ints; must happen after CSR0 write! */
243 viafb_mmio_write(VDMA_MR0
, VDMA_MR_TDIE
);
244 viafb_mmio_write(VDMA_MARL0
, (int) (paddr
& 0xfffffff0));
245 viafb_mmio_write(VDMA_MARH0
, (int) ((paddr
>> 28) & 0xfff));
246 /* Data sheet suggests DAR0 should be <<4, but it lies */
247 viafb_mmio_write(VDMA_DAR0
, offset
);
248 viafb_mmio_write(VDMA_DQWCR0
, len
>> 4);
249 viafb_mmio_write(VDMA_TMR0
, 0);
250 viafb_mmio_write(VDMA_DPRL0
, 0);
251 viafb_mmio_write(VDMA_DPRH0
, 0);
252 viafb_mmio_write(VDMA_PMR0
, 0);
253 csr
= viafb_mmio_read(VDMA_CSR0
);
254 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_START
);
255 spin_unlock_irqrestore(&global_dev
.reg_lock
, flags
);
257 * Now we just wait until the interrupt handler says
260 wait_for_completion_interruptible(&viafb_dma_completion
);
261 viafb_mmio_write(VDMA_MR0
, 0); /* Reset int enable */
262 mutex_unlock(&viafb_dma_lock
);
264 EXPORT_SYMBOL_GPL(viafb_dma_copy_out
);
268 * Do a scatter/gather DMA copy from FB memory. You must have done
269 * a successful call to viafb_request_dma() first.
271 int viafb_dma_copy_out_sg(unsigned int offset
, struct scatterlist
*sg
, int nsg
)
273 struct viafb_vx855_dma_descr
*descr
;
275 dma_addr_t descr_handle
;
278 struct scatterlist
*sgentry
;
282 * Get a place to put the descriptors.
284 descrpages
= dma_alloc_coherent(&global_dev
.pdev
->dev
,
285 nsg
*sizeof(struct viafb_vx855_dma_descr
),
286 &descr_handle
, GFP_KERNEL
);
287 if (descrpages
== NULL
) {
288 dev_err(&global_dev
.pdev
->dev
, "Unable to get descr page.\n");
291 mutex_lock(&viafb_dma_lock
);
296 nextdesc
= descr_handle
+ sizeof(struct viafb_vx855_dma_descr
);
297 for_each_sg(sg
, sgentry
, nsg
, i
) {
298 dma_addr_t paddr
= sg_dma_address(sgentry
);
299 descr
->addr_low
= paddr
& 0xfffffff0;
300 descr
->addr_high
= ((u64
) paddr
>> 32) & 0x0fff;
301 descr
->fb_offset
= offset
;
302 descr
->seg_size
= sg_dma_len(sgentry
) >> 4;
303 descr
->tile_mode
= 0;
304 descr
->next_desc_low
= (nextdesc
&0xfffffff0) | VIAFB_DMA_MAGIC
;
305 descr
->next_desc_high
= ((u64
) nextdesc
>> 32) & 0x0fff;
306 descr
->pad
= 0xffffffff; /* VIA driver does this */
307 offset
+= sg_dma_len(sgentry
);
308 nextdesc
+= sizeof(struct viafb_vx855_dma_descr
);
311 descr
[-1].next_desc_low
= VIAFB_DMA_FINAL_SEGMENT
|VIAFB_DMA_MAGIC
;
313 * Program the engine.
315 spin_lock_irqsave(&global_dev
.reg_lock
, flags
);
316 init_completion(&viafb_dma_completion
);
317 viafb_mmio_write(VDMA_DQWCR0
, 0);
318 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_DONE
);
319 viafb_mmio_write(VDMA_MR0
, VDMA_MR_TDIE
| VDMA_MR_CHAIN
);
320 viafb_mmio_write(VDMA_DPRL0
, descr_handle
| VIAFB_DMA_MAGIC
);
321 viafb_mmio_write(VDMA_DPRH0
,
322 (((u64
)descr_handle
>> 32) & 0x0fff) | 0xf0000);
323 (void) viafb_mmio_read(VDMA_CSR0
);
324 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_START
);
325 spin_unlock_irqrestore(&global_dev
.reg_lock
, flags
);
327 * Now we just wait until the interrupt handler says
328 * we're done. Except that, actually, we need to wait a little
329 * longer: the interrupts seem to jump the gun a little and we
330 * get corrupted frames sometimes.
332 wait_for_completion_timeout(&viafb_dma_completion
, 1);
334 if ((viafb_mmio_read(VDMA_CSR0
)&VDMA_C_DONE
) == 0)
335 printk(KERN_ERR
"VIA DMA timeout!\n");
337 * Clean up and we're done.
339 viafb_mmio_write(VDMA_CSR0
, VDMA_C_DONE
);
340 viafb_mmio_write(VDMA_MR0
, 0); /* Reset int enable */
341 mutex_unlock(&viafb_dma_lock
);
342 dma_free_coherent(&global_dev
.pdev
->dev
,
343 nsg
*sizeof(struct viafb_vx855_dma_descr
), descrpages
,
347 EXPORT_SYMBOL_GPL(viafb_dma_copy_out_sg
);
348 #endif /* CONFIG_VIDEO_VIA_CAMERA */
350 /* ---------------------------------------------------------------------- */
352 * Figure out how big our framebuffer memory is. Kind of ugly,
353 * but evidently we can't trust the information found in the
354 * fbdev configuration area.
356 static u16 via_function3
[] = {
357 CLE266_FUNCTION3
, KM400_FUNCTION3
, CN400_FUNCTION3
, CN700_FUNCTION3
,
358 CX700_FUNCTION3
, KM800_FUNCTION3
, KM890_FUNCTION3
, P4M890_FUNCTION3
,
359 P4M900_FUNCTION3
, VX800_FUNCTION3
, VX855_FUNCTION3
, VX900_FUNCTION3
,
362 /* Get the BIOS-configured framebuffer size from PCI configuration space
363 * of function 3 in the respective chipset */
364 static int viafb_get_fb_size_from_pci(int chip_type
)
371 /* search for the "FUNCTION3" device in this chipset */
372 for (i
= 0; i
< ARRAY_SIZE(via_function3
); i
++) {
373 struct pci_dev
*pdev
;
375 pdev
= pci_get_device(PCI_VENDOR_ID_VIA
, via_function3
[i
],
380 DEBUG_MSG(KERN_INFO
"Device ID = %x\n", pdev
->device
);
382 switch (pdev
->device
) {
383 case CLE266_FUNCTION3
:
384 case KM400_FUNCTION3
:
387 case CN400_FUNCTION3
:
388 case CN700_FUNCTION3
:
389 case CX700_FUNCTION3
:
390 case KM800_FUNCTION3
:
391 case KM890_FUNCTION3
:
392 case P4M890_FUNCTION3
:
393 case P4M900_FUNCTION3
:
394 case VX800_FUNCTION3
:
395 case VX855_FUNCTION3
:
396 case VX900_FUNCTION3
:
397 /*case CN750_FUNCTION3: */
405 pci_read_config_dword(pdev
, offset
, &FBSize
);
410 printk(KERN_ERR
"cannot determine framebuffer size\n");
414 FBSize
= FBSize
& 0x00007000;
415 DEBUG_MSG(KERN_INFO
"FB Size = %x\n", FBSize
);
417 if (chip_type
< UNICHROME_CX700
) {
420 VideoMemSize
= (16 << 20); /*16M */
424 VideoMemSize
= (32 << 20); /*32M */
428 VideoMemSize
= (64 << 20); /*64M */
432 VideoMemSize
= (32 << 20); /*32M */
438 VideoMemSize
= (8 << 20); /*8M */
442 VideoMemSize
= (16 << 20); /*16M */
446 VideoMemSize
= (32 << 20); /*32M */
450 VideoMemSize
= (64 << 20); /*64M */
454 VideoMemSize
= (128 << 20); /*128M */
458 VideoMemSize
= (256 << 20); /*256M */
461 case 0x00007000: /* Only on VX855/875 */
462 VideoMemSize
= (512 << 20); /*512M */
466 VideoMemSize
= (32 << 20); /*32M */
476 * Figure out and map our MMIO regions.
478 static int via_pci_setup_mmio(struct viafb_dev
*vdev
)
482 * Hook up to the device registers. Note that we soldier
483 * on if it fails; the framebuffer can operate (without
484 * acceleration) without this region.
486 vdev
->engine_start
= pci_resource_start(vdev
->pdev
, 1);
487 vdev
->engine_len
= pci_resource_len(vdev
->pdev
, 1);
488 vdev
->engine_mmio
= ioremap_nocache(vdev
->engine_start
,
490 if (vdev
->engine_mmio
== NULL
)
491 dev_err(&vdev
->pdev
->dev
,
492 "Unable to map engine MMIO; operation will be "
493 "slow and crippled.\n");
495 * Map in framebuffer memory. For now, failure here is
496 * fatal. Unfortunately, in the absence of significant
497 * vmalloc space, failure here is also entirely plausible.
498 * Eventually we want to move away from mapping this
501 if (vdev
->chip_type
== UNICHROME_VX900
)
502 vdev
->fbmem_start
= pci_resource_start(vdev
->pdev
, 2);
504 vdev
->fbmem_start
= pci_resource_start(vdev
->pdev
, 0);
505 ret
= vdev
->fbmem_len
= viafb_get_fb_size_from_pci(vdev
->chip_type
);
509 /* try to map less memory on failure, 8 MB should be still enough */
510 for (; vdev
->fbmem_len
>= 8 << 20; vdev
->fbmem_len
/= 2) {
511 vdev
->fbmem
= ioremap_wc(vdev
->fbmem_start
, vdev
->fbmem_len
);
516 if (vdev
->fbmem
== NULL
) {
522 iounmap(vdev
->engine_mmio
);
526 static void via_pci_teardown_mmio(struct viafb_dev
*vdev
)
528 iounmap(vdev
->fbmem
);
529 iounmap(vdev
->engine_mmio
);
533 * Create our subsidiary devices.
535 static struct viafb_subdev_info
{
537 struct platform_device
*platdev
;
538 } viafb_subdevs
[] = {
540 .name
= "viafb-gpio",
545 #if IS_ENABLED(CONFIG_VIDEO_VIA_CAMERA)
547 .name
= "viafb-camera",
551 #define N_SUBDEVS ARRAY_SIZE(viafb_subdevs)
553 static int via_create_subdev(struct viafb_dev
*vdev
,
554 struct viafb_subdev_info
*info
)
558 info
->platdev
= platform_device_alloc(info
->name
, -1);
559 if (!info
->platdev
) {
560 dev_err(&vdev
->pdev
->dev
, "Unable to allocate pdev %s\n",
564 info
->platdev
->dev
.parent
= &vdev
->pdev
->dev
;
565 info
->platdev
->dev
.platform_data
= vdev
;
566 ret
= platform_device_add(info
->platdev
);
568 dev_err(&vdev
->pdev
->dev
, "Unable to add pdev %s\n",
570 platform_device_put(info
->platdev
);
571 info
->platdev
= NULL
;
576 static int via_setup_subdevs(struct viafb_dev
*vdev
)
581 * Ignore return values. Even if some of the devices
582 * fail to be created, we'll still be able to use some
585 for (i
= 0; i
< N_SUBDEVS
; i
++)
586 via_create_subdev(vdev
, viafb_subdevs
+ i
);
590 static void via_teardown_subdevs(void)
594 for (i
= 0; i
< N_SUBDEVS
; i
++)
595 if (viafb_subdevs
[i
].platdev
) {
596 viafb_subdevs
[i
].platdev
->dev
.platform_data
= NULL
;
597 platform_device_unregister(viafb_subdevs
[i
].platdev
);
602 * Power management functions
605 static LIST_HEAD(viafb_pm_hooks
);
606 static DEFINE_MUTEX(viafb_pm_hooks_lock
);
608 void viafb_pm_register(struct viafb_pm_hooks
*hooks
)
610 INIT_LIST_HEAD(&hooks
->list
);
612 mutex_lock(&viafb_pm_hooks_lock
);
613 list_add_tail(&hooks
->list
, &viafb_pm_hooks
);
614 mutex_unlock(&viafb_pm_hooks_lock
);
616 EXPORT_SYMBOL_GPL(viafb_pm_register
);
618 void viafb_pm_unregister(struct viafb_pm_hooks
*hooks
)
620 mutex_lock(&viafb_pm_hooks_lock
);
621 list_del(&hooks
->list
);
622 mutex_unlock(&viafb_pm_hooks_lock
);
624 EXPORT_SYMBOL_GPL(viafb_pm_unregister
);
626 static int via_suspend(struct pci_dev
*pdev
, pm_message_t state
)
628 struct viafb_pm_hooks
*hooks
;
630 if (state
.event
!= PM_EVENT_SUSPEND
)
633 * "I've occasionally hit a few drivers that caused suspend
634 * failures, and each and every time it was a driver bug, and
635 * the right thing to do was to just ignore the error and suspend
636 * anyway - returning an error code and trying to undo the suspend
637 * is not what anybody ever really wants, even if our model
639 * -- Linus Torvalds, Dec. 7, 2009
641 mutex_lock(&viafb_pm_hooks_lock
);
642 list_for_each_entry_reverse(hooks
, &viafb_pm_hooks
, list
)
643 hooks
->suspend(hooks
->private);
644 mutex_unlock(&viafb_pm_hooks_lock
);
646 pci_save_state(pdev
);
647 pci_disable_device(pdev
);
648 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
652 static int via_resume(struct pci_dev
*pdev
)
654 struct viafb_pm_hooks
*hooks
;
656 /* Get the bus side powered up */
657 pci_set_power_state(pdev
, PCI_D0
);
658 pci_restore_state(pdev
);
659 if (pci_enable_device(pdev
))
662 pci_set_master(pdev
);
664 /* Now bring back any subdevs */
665 mutex_lock(&viafb_pm_hooks_lock
);
666 list_for_each_entry(hooks
, &viafb_pm_hooks
, list
)
667 hooks
->resume(hooks
->private);
668 mutex_unlock(&viafb_pm_hooks_lock
);
672 #endif /* CONFIG_PM */
674 static int via_pci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
678 ret
= pci_enable_device(pdev
);
683 * Global device initialization.
685 memset(&global_dev
, 0, sizeof(global_dev
));
686 global_dev
.pdev
= pdev
;
687 global_dev
.chip_type
= ent
->driver_data
;
688 global_dev
.port_cfg
= adap_configs
;
689 if (machine_is_olpc())
690 global_dev
.port_cfg
= olpc_adap_configs
;
692 spin_lock_init(&global_dev
.reg_lock
);
693 ret
= via_pci_setup_mmio(&global_dev
);
697 * Set up interrupts and create our subdevices. Continue even if
701 via_setup_subdevs(&global_dev
);
703 * Set up the framebuffer device
705 ret
= via_fb_pci_probe(&global_dev
);
711 via_teardown_subdevs();
712 via_pci_teardown_mmio(&global_dev
);
714 pci_disable_device(pdev
);
718 static void via_pci_remove(struct pci_dev
*pdev
)
720 via_teardown_subdevs();
721 via_fb_pci_remove(pdev
);
722 via_pci_teardown_mmio(&global_dev
);
723 pci_disable_device(pdev
);
727 static const struct pci_device_id via_pci_table
[] = {
728 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CLE266_DID
),
729 .driver_data
= UNICHROME_CLE266
},
730 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K400_DID
),
731 .driver_data
= UNICHROME_K400
},
732 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K800_DID
),
733 .driver_data
= UNICHROME_K800
},
734 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_PM800_DID
),
735 .driver_data
= UNICHROME_PM800
},
736 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CN700_DID
),
737 .driver_data
= UNICHROME_CN700
},
738 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CX700_DID
),
739 .driver_data
= UNICHROME_CX700
},
740 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CN750_DID
),
741 .driver_data
= UNICHROME_CN750
},
742 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K8M890_DID
),
743 .driver_data
= UNICHROME_K8M890
},
744 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_P4M890_DID
),
745 .driver_data
= UNICHROME_P4M890
},
746 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_P4M900_DID
),
747 .driver_data
= UNICHROME_P4M900
},
748 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX800_DID
),
749 .driver_data
= UNICHROME_VX800
},
750 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX855_DID
),
751 .driver_data
= UNICHROME_VX855
},
752 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX900_DID
),
753 .driver_data
= UNICHROME_VX900
},
756 MODULE_DEVICE_TABLE(pci
, via_pci_table
);
758 static struct pci_driver via_driver
= {
760 .id_table
= via_pci_table
,
761 .probe
= via_pci_probe
,
762 .remove
= via_pci_remove
,
764 .suspend
= via_suspend
,
765 .resume
= via_resume
,
769 static int __init
via_core_init(void)
778 return pci_register_driver(&via_driver
);
781 static void __exit
via_core_exit(void)
783 pci_unregister_driver(&via_driver
);
789 module_init(via_core_init
);
790 module_exit(via_core_exit
);