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>
20 * The default port config.
22 static struct via_port_cfg adap_configs
[] = {
23 [VIA_PORT_26
] = { VIA_PORT_I2C
, VIA_MODE_OFF
, 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 },
32 * We currently only support one viafb device (will there ever be
33 * more than one?), so just declare it globally here.
35 static struct viafb_dev global_dev
;
39 * Basic register access; spinlock required.
41 static inline void viafb_mmio_write(int reg
, u32 v
)
43 iowrite32(v
, global_dev
.engine_mmio
+ reg
);
46 static inline int viafb_mmio_read(int reg
)
48 return ioread32(global_dev
.engine_mmio
+ reg
);
51 /* ---------------------------------------------------------------------- */
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.
63 * Which interrupts are enabled now?
65 static u32 viafb_enabled_ints
;
67 static void __devinit
viafb_int_init(void)
69 viafb_enabled_ints
= 0;
71 viafb_mmio_write(VDE_INTERRUPT
, 0);
75 * Allow subdevs to ask for specific interrupts to be enabled. These
76 * functions must be called with reg_lock held
78 void viafb_irq_enable(u32 mask
)
80 viafb_enabled_ints
|= mask
;
81 viafb_mmio_write(VDE_INTERRUPT
, viafb_enabled_ints
| VDE_I_ENABLE
);
83 EXPORT_SYMBOL_GPL(viafb_irq_enable
);
85 void viafb_irq_disable(u32 mask
)
87 viafb_enabled_ints
&= ~mask
;
88 if (viafb_enabled_ints
== 0)
89 viafb_mmio_write(VDE_INTERRUPT
, 0); /* Disable entirely */
91 viafb_mmio_write(VDE_INTERRUPT
,
92 viafb_enabled_ints
| VDE_I_ENABLE
);
94 EXPORT_SYMBOL_GPL(viafb_irq_disable
);
96 /* ---------------------------------------------------------------------- */
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
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.
109 static int viafb_dma_users
;
110 static DECLARE_COMPLETION(viafb_dma_completion
);
112 * This mutex protects viafb_dma_users and our global interrupt
113 * registration state; it also serializes access to the DMA
116 static DEFINE_MUTEX(viafb_dma_lock
);
119 * The VX855 DMA descriptor (used for s/g transfers) looks
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 */
130 u32 pad
; /* Fill out to 64 bytes */
134 * Flags added to the "next descriptor low" pointers
136 #define VIAFB_DMA_MAGIC 0x01 /* ??? Just has to be there */
137 #define VIAFB_DMA_FINAL_SEGMENT 0x02 /* Final segment */
140 * The completion IRQ handler.
142 static irqreturn_t
viafb_dma_irq(int irq
, void *data
)
145 irqreturn_t ret
= IRQ_NONE
;
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
);
154 spin_unlock(&global_dev
.reg_lock
);
159 * Indicate a need for DMA functionality.
161 int viafb_request_dma(void)
166 * Only VX855 is supported currently.
168 if (global_dev
.chip_type
!= UNICHROME_VX855
)
171 * Note the new user and set up our interrupt handler
174 mutex_lock(&viafb_dma_lock
);
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
);
182 viafb_irq_enable(VDE_I_DMA0TDEN
);
184 mutex_unlock(&viafb_dma_lock
);
187 EXPORT_SYMBOL_GPL(viafb_request_dma
);
189 void viafb_release_dma(void)
191 mutex_lock(&viafb_dma_lock
);
193 if (viafb_dma_users
== 0) {
194 viafb_irq_disable(VDE_I_DMA0TDEN
);
195 free_irq(global_dev
.pdev
->irq
, &viafb_dma_users
);
197 mutex_unlock(&viafb_dma_lock
);
199 EXPORT_SYMBOL_GPL(viafb_release_dma
);
204 * Do a scatter/gather DMA copy from FB memory. You must have done
205 * a successful call to viafb_request_dma() first.
207 int viafb_dma_copy_out_sg(unsigned int offset
, struct scatterlist
*sg
, int nsg
)
209 struct viafb_vx855_dma_descr
*descr
;
211 dma_addr_t descr_handle
;
214 struct scatterlist
*sgentry
;
218 * Get a place to put the descriptors.
220 descrpages
= dma_alloc_coherent(&global_dev
.pdev
->dev
,
221 nsg
*sizeof(struct viafb_vx855_dma_descr
),
222 &descr_handle
, GFP_KERNEL
);
223 if (descrpages
== NULL
) {
224 dev_err(&global_dev
.pdev
->dev
, "Unable to get descr page.\n");
227 mutex_lock(&viafb_dma_lock
);
232 nextdesc
= descr_handle
+ sizeof(struct viafb_vx855_dma_descr
);
233 for_each_sg(sg
, sgentry
, nsg
, i
) {
234 dma_addr_t paddr
= sg_dma_address(sgentry
);
235 descr
->addr_low
= paddr
& 0xfffffff0;
236 descr
->addr_high
= ((u64
) paddr
>> 32) & 0x0fff;
237 descr
->fb_offset
= offset
;
238 descr
->seg_size
= sg_dma_len(sgentry
) >> 4;
239 descr
->tile_mode
= 0;
240 descr
->next_desc_low
= (nextdesc
&0xfffffff0) | VIAFB_DMA_MAGIC
;
241 descr
->next_desc_high
= ((u64
) nextdesc
>> 32) & 0x0fff;
242 descr
->pad
= 0xffffffff; /* VIA driver does this */
243 offset
+= sg_dma_len(sgentry
);
244 nextdesc
+= sizeof(struct viafb_vx855_dma_descr
);
247 descr
[-1].next_desc_low
= VIAFB_DMA_FINAL_SEGMENT
|VIAFB_DMA_MAGIC
;
249 * Program the engine.
251 spin_lock_irqsave(&global_dev
.reg_lock
, flags
);
252 init_completion(&viafb_dma_completion
);
253 viafb_mmio_write(VDMA_DQWCR0
, 0);
254 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_DONE
);
255 viafb_mmio_write(VDMA_MR0
, VDMA_MR_TDIE
| VDMA_MR_CHAIN
);
256 viafb_mmio_write(VDMA_DPRL0
, descr_handle
| VIAFB_DMA_MAGIC
);
257 viafb_mmio_write(VDMA_DPRH0
,
258 (((u64
)descr_handle
>> 32) & 0x0fff) | 0xf0000);
259 (void) viafb_mmio_read(VDMA_CSR0
);
260 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_START
);
261 spin_unlock_irqrestore(&global_dev
.reg_lock
, flags
);
263 * Now we just wait until the interrupt handler says
264 * we're done. Except that, actually, we need to wait a little
265 * longer: the interrupts seem to jump the gun a little and we
266 * get corrupted frames sometimes.
268 wait_for_completion_timeout(&viafb_dma_completion
, 1);
270 if ((viafb_mmio_read(VDMA_CSR0
)&VDMA_C_DONE
) == 0)
271 printk(KERN_ERR
"VIA DMA timeout!\n");
273 * Clean up and we're done.
275 viafb_mmio_write(VDMA_CSR0
, VDMA_C_DONE
);
276 viafb_mmio_write(VDMA_MR0
, 0); /* Reset int enable */
277 mutex_unlock(&viafb_dma_lock
);
278 dma_free_coherent(&global_dev
.pdev
->dev
,
279 nsg
*sizeof(struct viafb_vx855_dma_descr
), descrpages
,
283 EXPORT_SYMBOL_GPL(viafb_dma_copy_out_sg
);
286 /* ---------------------------------------------------------------------- */
288 * Figure out how big our framebuffer memory is. Kind of ugly,
289 * but evidently we can't trust the information found in the
290 * fbdev configuration area.
292 static u16 via_function3
[] = {
293 CLE266_FUNCTION3
, KM400_FUNCTION3
, CN400_FUNCTION3
, CN700_FUNCTION3
,
294 CX700_FUNCTION3
, KM800_FUNCTION3
, KM890_FUNCTION3
, P4M890_FUNCTION3
,
295 P4M900_FUNCTION3
, VX800_FUNCTION3
, VX855_FUNCTION3
,
298 /* Get the BIOS-configured framebuffer size from PCI configuration space
299 * of function 3 in the respective chipset */
300 static int viafb_get_fb_size_from_pci(int chip_type
)
307 /* search for the "FUNCTION3" device in this chipset */
308 for (i
= 0; i
< ARRAY_SIZE(via_function3
); i
++) {
309 struct pci_dev
*pdev
;
311 pdev
= pci_get_device(PCI_VENDOR_ID_VIA
, via_function3
[i
],
316 DEBUG_MSG(KERN_INFO
"Device ID = %x\n", pdev
->device
);
318 switch (pdev
->device
) {
319 case CLE266_FUNCTION3
:
320 case KM400_FUNCTION3
:
323 case CN400_FUNCTION3
:
324 case CN700_FUNCTION3
:
325 case CX700_FUNCTION3
:
326 case KM800_FUNCTION3
:
327 case KM890_FUNCTION3
:
328 case P4M890_FUNCTION3
:
329 case P4M900_FUNCTION3
:
330 case VX800_FUNCTION3
:
331 case VX855_FUNCTION3
:
332 /*case CN750_FUNCTION3: */
340 pci_read_config_dword(pdev
, offset
, &FBSize
);
345 printk(KERN_ERR
"cannot determine framebuffer size\n");
349 FBSize
= FBSize
& 0x00007000;
350 DEBUG_MSG(KERN_INFO
"FB Size = %x\n", FBSize
);
352 if (chip_type
< UNICHROME_CX700
) {
355 VideoMemSize
= (16 << 20); /*16M */
359 VideoMemSize
= (32 << 20); /*32M */
363 VideoMemSize
= (64 << 20); /*64M */
367 VideoMemSize
= (32 << 20); /*32M */
373 VideoMemSize
= (8 << 20); /*8M */
377 VideoMemSize
= (16 << 20); /*16M */
381 VideoMemSize
= (32 << 20); /*32M */
385 VideoMemSize
= (64 << 20); /*64M */
389 VideoMemSize
= (128 << 20); /*128M */
393 VideoMemSize
= (256 << 20); /*256M */
396 case 0x00007000: /* Only on VX855/875 */
397 VideoMemSize
= (512 << 20); /*512M */
401 VideoMemSize
= (32 << 20); /*32M */
411 * Figure out and map our MMIO regions.
413 static int __devinit
via_pci_setup_mmio(struct viafb_dev
*vdev
)
417 * Hook up to the device registers. Note that we soldier
418 * on if it fails; the framebuffer can operate (without
419 * acceleration) without this region.
421 vdev
->engine_start
= pci_resource_start(vdev
->pdev
, 1);
422 vdev
->engine_len
= pci_resource_len(vdev
->pdev
, 1);
423 vdev
->engine_mmio
= ioremap_nocache(vdev
->engine_start
,
425 if (vdev
->engine_mmio
== NULL
)
426 dev_err(&vdev
->pdev
->dev
,
427 "Unable to map engine MMIO; operation will be "
428 "slow and crippled.\n");
430 * Map in framebuffer memory. For now, failure here is
431 * fatal. Unfortunately, in the absence of significant
432 * vmalloc space, failure here is also entirely plausible.
433 * Eventually we want to move away from mapping this
436 vdev
->fbmem_start
= pci_resource_start(vdev
->pdev
, 0);
437 ret
= vdev
->fbmem_len
= viafb_get_fb_size_from_pci(vdev
->chip_type
);
440 vdev
->fbmem
= ioremap_nocache(vdev
->fbmem_start
, vdev
->fbmem_len
);
441 if (vdev
->fbmem
== NULL
) {
447 iounmap(vdev
->engine_mmio
);
451 static void via_pci_teardown_mmio(struct viafb_dev
*vdev
)
453 iounmap(vdev
->fbmem
);
454 iounmap(vdev
->engine_mmio
);
458 * Create our subsidiary devices.
460 static struct viafb_subdev_info
{
462 struct platform_device
*platdev
;
463 } viafb_subdevs
[] = {
465 .name
= "viafb-gpio",
471 #define N_SUBDEVS ARRAY_SIZE(viafb_subdevs)
473 static int __devinit
via_create_subdev(struct viafb_dev
*vdev
,
474 struct viafb_subdev_info
*info
)
478 info
->platdev
= platform_device_alloc(info
->name
, -1);
479 if (!info
->platdev
) {
480 dev_err(&vdev
->pdev
->dev
, "Unable to allocate pdev %s\n",
484 info
->platdev
->dev
.parent
= &vdev
->pdev
->dev
;
485 info
->platdev
->dev
.platform_data
= vdev
;
486 ret
= platform_device_add(info
->platdev
);
488 dev_err(&vdev
->pdev
->dev
, "Unable to add pdev %s\n",
490 platform_device_put(info
->platdev
);
491 info
->platdev
= NULL
;
496 static int __devinit
via_setup_subdevs(struct viafb_dev
*vdev
)
501 * Ignore return values. Even if some of the devices
502 * fail to be created, we'll still be able to use some
505 for (i
= 0; i
< N_SUBDEVS
; i
++)
506 via_create_subdev(vdev
, viafb_subdevs
+ i
);
510 static void via_teardown_subdevs(void)
514 for (i
= 0; i
< N_SUBDEVS
; i
++)
515 if (viafb_subdevs
[i
].platdev
) {
516 viafb_subdevs
[i
].platdev
->dev
.platform_data
= NULL
;
517 platform_device_unregister(viafb_subdevs
[i
].platdev
);
522 static int __devinit
via_pci_probe(struct pci_dev
*pdev
,
523 const struct pci_device_id
*ent
)
527 ret
= pci_enable_device(pdev
);
531 * Global device initialization.
533 memset(&global_dev
, 0, sizeof(global_dev
));
534 global_dev
.pdev
= pdev
;
535 global_dev
.chip_type
= ent
->driver_data
;
536 global_dev
.port_cfg
= adap_configs
;
537 spin_lock_init(&global_dev
.reg_lock
);
538 ret
= via_pci_setup_mmio(&global_dev
);
542 * Set up interrupts and create our subdevices. Continue even if
546 via_setup_subdevs(&global_dev
);
548 * Set up the framebuffer device
550 ret
= via_fb_pci_probe(&global_dev
);
556 via_teardown_subdevs();
557 via_pci_teardown_mmio(&global_dev
);
559 pci_disable_device(pdev
);
563 static void __devexit
via_pci_remove(struct pci_dev
*pdev
)
565 via_teardown_subdevs();
566 via_fb_pci_remove(pdev
);
567 via_pci_teardown_mmio(&global_dev
);
568 pci_disable_device(pdev
);
572 static struct pci_device_id via_pci_table
[] __devinitdata
= {
573 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CLE266_DID
),
574 .driver_data
= UNICHROME_CLE266
},
575 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K400_DID
),
576 .driver_data
= UNICHROME_K400
},
577 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K800_DID
),
578 .driver_data
= UNICHROME_K800
},
579 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_PM800_DID
),
580 .driver_data
= UNICHROME_PM800
},
581 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CN700_DID
),
582 .driver_data
= UNICHROME_CN700
},
583 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CX700_DID
),
584 .driver_data
= UNICHROME_CX700
},
585 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CN750_DID
),
586 .driver_data
= UNICHROME_CN750
},
587 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K8M890_DID
),
588 .driver_data
= UNICHROME_K8M890
},
589 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_P4M890_DID
),
590 .driver_data
= UNICHROME_P4M890
},
591 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_P4M900_DID
),
592 .driver_data
= UNICHROME_P4M900
},
593 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX800_DID
),
594 .driver_data
= UNICHROME_VX800
},
595 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX855_DID
),
596 .driver_data
= UNICHROME_VX855
},
599 MODULE_DEVICE_TABLE(pci
, via_pci_table
);
601 static struct pci_driver via_driver
= {
603 .id_table
= via_pci_table
,
604 .probe
= via_pci_probe
,
605 .remove
= __devexit_p(via_pci_remove
),
608 static int __init
via_core_init(void)
617 return pci_register_driver(&via_driver
);
620 static void __exit
via_core_exit(void)
622 pci_unregister_driver(&via_driver
);
628 module_init(via_core_init
);
629 module_exit(via_core_exit
);