1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 1998-2009 VIA Technologies, Inc. All Rights Reserved.
4 * Copyright 2001-2008 S3 Graphics, Inc. All Rights Reserved.
5 * Copyright 2009 Jonathan Corbet <corbet@lwn.net>
9 * Core code for the Via multifunction framebuffer device.
11 #include <linux/via-core.h>
12 #include <linux/via_i2c.h>
13 #include <linux/via-gpio.h>
16 #include <linux/module.h>
17 #include <linux/interrupt.h>
18 #include <linux/platform_device.h>
19 #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
);
225 * Do a scatter/gather DMA copy from FB memory. You must have done
226 * a successful call to viafb_request_dma() first.
228 int viafb_dma_copy_out_sg(unsigned int offset
, struct scatterlist
*sg
, int nsg
)
230 struct viafb_vx855_dma_descr
*descr
;
232 dma_addr_t descr_handle
;
235 struct scatterlist
*sgentry
;
239 * Get a place to put the descriptors.
241 descrpages
= dma_alloc_coherent(&global_dev
.pdev
->dev
,
242 nsg
*sizeof(struct viafb_vx855_dma_descr
),
243 &descr_handle
, GFP_KERNEL
);
244 if (descrpages
== NULL
) {
245 dev_err(&global_dev
.pdev
->dev
, "Unable to get descr page.\n");
248 mutex_lock(&viafb_dma_lock
);
253 nextdesc
= descr_handle
+ sizeof(struct viafb_vx855_dma_descr
);
254 for_each_sg(sg
, sgentry
, nsg
, i
) {
255 dma_addr_t paddr
= sg_dma_address(sgentry
);
256 descr
->addr_low
= paddr
& 0xfffffff0;
257 descr
->addr_high
= ((u64
) paddr
>> 32) & 0x0fff;
258 descr
->fb_offset
= offset
;
259 descr
->seg_size
= sg_dma_len(sgentry
) >> 4;
260 descr
->tile_mode
= 0;
261 descr
->next_desc_low
= (nextdesc
&0xfffffff0) | VIAFB_DMA_MAGIC
;
262 descr
->next_desc_high
= ((u64
) nextdesc
>> 32) & 0x0fff;
263 descr
->pad
= 0xffffffff; /* VIA driver does this */
264 offset
+= sg_dma_len(sgentry
);
265 nextdesc
+= sizeof(struct viafb_vx855_dma_descr
);
268 descr
[-1].next_desc_low
= VIAFB_DMA_FINAL_SEGMENT
|VIAFB_DMA_MAGIC
;
270 * Program the engine.
272 spin_lock_irqsave(&global_dev
.reg_lock
, flags
);
273 init_completion(&viafb_dma_completion
);
274 viafb_mmio_write(VDMA_DQWCR0
, 0);
275 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_DONE
);
276 viafb_mmio_write(VDMA_MR0
, VDMA_MR_TDIE
| VDMA_MR_CHAIN
);
277 viafb_mmio_write(VDMA_DPRL0
, descr_handle
| VIAFB_DMA_MAGIC
);
278 viafb_mmio_write(VDMA_DPRH0
,
279 (((u64
)descr_handle
>> 32) & 0x0fff) | 0xf0000);
280 (void) viafb_mmio_read(VDMA_CSR0
);
281 viafb_mmio_write(VDMA_CSR0
, VDMA_C_ENABLE
|VDMA_C_START
);
282 spin_unlock_irqrestore(&global_dev
.reg_lock
, flags
);
284 * Now we just wait until the interrupt handler says
285 * we're done. Except that, actually, we need to wait a little
286 * longer: the interrupts seem to jump the gun a little and we
287 * get corrupted frames sometimes.
289 wait_for_completion_timeout(&viafb_dma_completion
, 1);
291 if ((viafb_mmio_read(VDMA_CSR0
)&VDMA_C_DONE
) == 0)
292 printk(KERN_ERR
"VIA DMA timeout!\n");
294 * Clean up and we're done.
296 viafb_mmio_write(VDMA_CSR0
, VDMA_C_DONE
);
297 viafb_mmio_write(VDMA_MR0
, 0); /* Reset int enable */
298 mutex_unlock(&viafb_dma_lock
);
299 dma_free_coherent(&global_dev
.pdev
->dev
,
300 nsg
*sizeof(struct viafb_vx855_dma_descr
), descrpages
,
304 EXPORT_SYMBOL_GPL(viafb_dma_copy_out_sg
);
305 #endif /* CONFIG_VIDEO_VIA_CAMERA */
307 /* ---------------------------------------------------------------------- */
309 * Figure out how big our framebuffer memory is. Kind of ugly,
310 * but evidently we can't trust the information found in the
311 * fbdev configuration area.
313 static u16 via_function3
[] = {
314 CLE266_FUNCTION3
, KM400_FUNCTION3
, CN400_FUNCTION3
, CN700_FUNCTION3
,
315 CX700_FUNCTION3
, KM800_FUNCTION3
, KM890_FUNCTION3
, P4M890_FUNCTION3
,
316 P4M900_FUNCTION3
, VX800_FUNCTION3
, VX855_FUNCTION3
, VX900_FUNCTION3
,
319 /* Get the BIOS-configured framebuffer size from PCI configuration space
320 * of function 3 in the respective chipset */
321 static int viafb_get_fb_size_from_pci(int chip_type
)
328 /* search for the "FUNCTION3" device in this chipset */
329 for (i
= 0; i
< ARRAY_SIZE(via_function3
); i
++) {
330 struct pci_dev
*pdev
;
332 pdev
= pci_get_device(PCI_VENDOR_ID_VIA
, via_function3
[i
],
337 DEBUG_MSG(KERN_INFO
"Device ID = %x\n", pdev
->device
);
339 switch (pdev
->device
) {
340 case CLE266_FUNCTION3
:
341 case KM400_FUNCTION3
:
344 case CN400_FUNCTION3
:
345 case CN700_FUNCTION3
:
346 case CX700_FUNCTION3
:
347 case KM800_FUNCTION3
:
348 case KM890_FUNCTION3
:
349 case P4M890_FUNCTION3
:
350 case P4M900_FUNCTION3
:
351 case VX800_FUNCTION3
:
352 case VX855_FUNCTION3
:
353 case VX900_FUNCTION3
:
354 /*case CN750_FUNCTION3: */
362 pci_read_config_dword(pdev
, offset
, &FBSize
);
367 printk(KERN_ERR
"cannot determine framebuffer size\n");
371 FBSize
= FBSize
& 0x00007000;
372 DEBUG_MSG(KERN_INFO
"FB Size = %x\n", FBSize
);
374 if (chip_type
< UNICHROME_CX700
) {
377 VideoMemSize
= (16 << 20); /*16M */
381 VideoMemSize
= (32 << 20); /*32M */
385 VideoMemSize
= (64 << 20); /*64M */
389 VideoMemSize
= (32 << 20); /*32M */
395 VideoMemSize
= (8 << 20); /*8M */
399 VideoMemSize
= (16 << 20); /*16M */
403 VideoMemSize
= (32 << 20); /*32M */
407 VideoMemSize
= (64 << 20); /*64M */
411 VideoMemSize
= (128 << 20); /*128M */
415 VideoMemSize
= (256 << 20); /*256M */
418 case 0x00007000: /* Only on VX855/875 */
419 VideoMemSize
= (512 << 20); /*512M */
423 VideoMemSize
= (32 << 20); /*32M */
433 * Figure out and map our MMIO regions.
435 static int via_pci_setup_mmio(struct viafb_dev
*vdev
)
439 * Hook up to the device registers. Note that we soldier
440 * on if it fails; the framebuffer can operate (without
441 * acceleration) without this region.
443 vdev
->engine_start
= pci_resource_start(vdev
->pdev
, 1);
444 vdev
->engine_len
= pci_resource_len(vdev
->pdev
, 1);
445 vdev
->engine_mmio
= ioremap(vdev
->engine_start
,
447 if (vdev
->engine_mmio
== NULL
)
448 dev_err(&vdev
->pdev
->dev
,
449 "Unable to map engine MMIO; operation will be "
450 "slow and crippled.\n");
452 * Map in framebuffer memory. For now, failure here is
453 * fatal. Unfortunately, in the absence of significant
454 * vmalloc space, failure here is also entirely plausible.
455 * Eventually we want to move away from mapping this
458 if (vdev
->chip_type
== UNICHROME_VX900
)
459 vdev
->fbmem_start
= pci_resource_start(vdev
->pdev
, 2);
461 vdev
->fbmem_start
= pci_resource_start(vdev
->pdev
, 0);
462 ret
= vdev
->fbmem_len
= viafb_get_fb_size_from_pci(vdev
->chip_type
);
466 /* try to map less memory on failure, 8 MB should be still enough */
467 for (; vdev
->fbmem_len
>= 8 << 20; vdev
->fbmem_len
/= 2) {
468 vdev
->fbmem
= ioremap_wc(vdev
->fbmem_start
, vdev
->fbmem_len
);
473 if (vdev
->fbmem
== NULL
) {
479 iounmap(vdev
->engine_mmio
);
483 static void via_pci_teardown_mmio(struct viafb_dev
*vdev
)
485 iounmap(vdev
->fbmem
);
486 iounmap(vdev
->engine_mmio
);
490 * Create our subsidiary devices.
492 static struct viafb_subdev_info
{
494 struct platform_device
*platdev
;
495 } viafb_subdevs
[] = {
497 .name
= "viafb-gpio",
502 #if IS_ENABLED(CONFIG_VIDEO_VIA_CAMERA)
504 .name
= "viafb-camera",
508 #define N_SUBDEVS ARRAY_SIZE(viafb_subdevs)
510 static int via_create_subdev(struct viafb_dev
*vdev
,
511 struct viafb_subdev_info
*info
)
515 info
->platdev
= platform_device_alloc(info
->name
, -1);
516 if (!info
->platdev
) {
517 dev_err(&vdev
->pdev
->dev
, "Unable to allocate pdev %s\n",
521 info
->platdev
->dev
.parent
= &vdev
->pdev
->dev
;
522 info
->platdev
->dev
.platform_data
= vdev
;
523 ret
= platform_device_add(info
->platdev
);
525 dev_err(&vdev
->pdev
->dev
, "Unable to add pdev %s\n",
527 platform_device_put(info
->platdev
);
528 info
->platdev
= NULL
;
533 static int via_setup_subdevs(struct viafb_dev
*vdev
)
538 * Ignore return values. Even if some of the devices
539 * fail to be created, we'll still be able to use some
542 for (i
= 0; i
< N_SUBDEVS
; i
++)
543 via_create_subdev(vdev
, viafb_subdevs
+ i
);
547 static void via_teardown_subdevs(void)
551 for (i
= 0; i
< N_SUBDEVS
; i
++)
552 if (viafb_subdevs
[i
].platdev
) {
553 viafb_subdevs
[i
].platdev
->dev
.platform_data
= NULL
;
554 platform_device_unregister(viafb_subdevs
[i
].platdev
);
559 * Power management functions
561 static __maybe_unused
LIST_HEAD(viafb_pm_hooks
);
562 static __maybe_unused
DEFINE_MUTEX(viafb_pm_hooks_lock
);
564 void viafb_pm_register(struct viafb_pm_hooks
*hooks
)
566 INIT_LIST_HEAD(&hooks
->list
);
568 mutex_lock(&viafb_pm_hooks_lock
);
569 list_add_tail(&hooks
->list
, &viafb_pm_hooks
);
570 mutex_unlock(&viafb_pm_hooks_lock
);
572 EXPORT_SYMBOL_GPL(viafb_pm_register
);
574 void viafb_pm_unregister(struct viafb_pm_hooks
*hooks
)
576 mutex_lock(&viafb_pm_hooks_lock
);
577 list_del(&hooks
->list
);
578 mutex_unlock(&viafb_pm_hooks_lock
);
580 EXPORT_SYMBOL_GPL(viafb_pm_unregister
);
582 static int __maybe_unused
via_suspend(struct device
*dev
)
584 struct viafb_pm_hooks
*hooks
;
587 * "I've occasionally hit a few drivers that caused suspend
588 * failures, and each and every time it was a driver bug, and
589 * the right thing to do was to just ignore the error and suspend
590 * anyway - returning an error code and trying to undo the suspend
591 * is not what anybody ever really wants, even if our model
593 * -- Linus Torvalds, Dec. 7, 2009
595 mutex_lock(&viafb_pm_hooks_lock
);
596 list_for_each_entry_reverse(hooks
, &viafb_pm_hooks
, list
)
597 hooks
->suspend(hooks
->private);
598 mutex_unlock(&viafb_pm_hooks_lock
);
603 static int __maybe_unused
via_resume(struct device
*dev
)
605 struct viafb_pm_hooks
*hooks
;
607 /* Now bring back any subdevs */
608 mutex_lock(&viafb_pm_hooks_lock
);
609 list_for_each_entry(hooks
, &viafb_pm_hooks
, list
)
610 hooks
->resume(hooks
->private);
611 mutex_unlock(&viafb_pm_hooks_lock
);
616 static int via_pci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
620 ret
= pci_enable_device(pdev
);
625 * Global device initialization.
627 memset(&global_dev
, 0, sizeof(global_dev
));
628 global_dev
.pdev
= pdev
;
629 global_dev
.chip_type
= ent
->driver_data
;
630 global_dev
.port_cfg
= adap_configs
;
631 if (machine_is_olpc())
632 global_dev
.port_cfg
= olpc_adap_configs
;
634 spin_lock_init(&global_dev
.reg_lock
);
635 ret
= via_pci_setup_mmio(&global_dev
);
639 * Set up interrupts and create our subdevices. Continue even if
643 via_setup_subdevs(&global_dev
);
645 * Set up the framebuffer device
647 ret
= via_fb_pci_probe(&global_dev
);
653 via_teardown_subdevs();
654 via_pci_teardown_mmio(&global_dev
);
656 pci_disable_device(pdev
);
660 static void via_pci_remove(struct pci_dev
*pdev
)
662 via_teardown_subdevs();
663 via_fb_pci_remove(pdev
);
664 via_pci_teardown_mmio(&global_dev
);
665 pci_disable_device(pdev
);
669 static const struct pci_device_id via_pci_table
[] = {
670 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CLE266_DID
),
671 .driver_data
= UNICHROME_CLE266
},
672 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K400_DID
),
673 .driver_data
= UNICHROME_K400
},
674 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K800_DID
),
675 .driver_data
= UNICHROME_K800
},
676 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_PM800_DID
),
677 .driver_data
= UNICHROME_PM800
},
678 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CN700_DID
),
679 .driver_data
= UNICHROME_CN700
},
680 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CX700_DID
),
681 .driver_data
= UNICHROME_CX700
},
682 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_CN750_DID
),
683 .driver_data
= UNICHROME_CN750
},
684 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_K8M890_DID
),
685 .driver_data
= UNICHROME_K8M890
},
686 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_P4M890_DID
),
687 .driver_data
= UNICHROME_P4M890
},
688 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_P4M900_DID
),
689 .driver_data
= UNICHROME_P4M900
},
690 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX800_DID
),
691 .driver_data
= UNICHROME_VX800
},
692 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX855_DID
),
693 .driver_data
= UNICHROME_VX855
},
694 { PCI_DEVICE(PCI_VENDOR_ID_VIA
, UNICHROME_VX900_DID
),
695 .driver_data
= UNICHROME_VX900
},
698 MODULE_DEVICE_TABLE(pci
, via_pci_table
);
700 static const struct dev_pm_ops via_pm_ops
= {
701 #ifdef CONFIG_PM_SLEEP
702 .suspend
= via_suspend
,
703 .resume
= via_resume
,
707 .restore
= via_resume
,
711 static struct pci_driver via_driver
= {
713 .id_table
= via_pci_table
,
714 .probe
= via_pci_probe
,
715 .remove
= via_pci_remove
,
716 .driver
.pm
= &via_pm_ops
,
719 static int __init
via_core_init(void)
728 return pci_register_driver(&via_driver
);
731 static void __exit
via_core_exit(void)
733 pci_unregister_driver(&via_driver
);
739 module_init(via_core_init
);
740 module_exit(via_core_exit
);