1 /* Hisilicon Hibmc SoC drm driver
3 * Based on the bochs drm driver.
5 * Copyright (c) 2016 Huawei Limited.
8 * Rongrong Zou <zourongrong@huawei.com>
9 * Rongrong Zou <zourongrong@gmail.com>
10 * Jianhua Li <lijianhua@huawei.com>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
19 #include <linux/console.h>
20 #include <linux/module.h>
22 #include <drm/drm_atomic_helper.h>
23 #include <drm/drm_crtc_helper.h>
25 #include "hibmc_drm_drv.h"
26 #include "hibmc_drm_regs.h"
28 static const struct file_operations hibmc_fops
= {
31 .release
= drm_release
,
32 .unlocked_ioctl
= drm_ioctl
,
33 .compat_ioctl
= drm_compat_ioctl
,
40 irqreturn_t
hibmc_drm_interrupt(int irq
, void *arg
)
42 struct drm_device
*dev
= (struct drm_device
*)arg
;
43 struct hibmc_drm_private
*priv
=
44 (struct hibmc_drm_private
*)dev
->dev_private
;
47 status
= readl(priv
->mmio
+ HIBMC_RAW_INTERRUPT
);
49 if (status
& HIBMC_RAW_INTERRUPT_VBLANK(1)) {
50 writel(HIBMC_RAW_INTERRUPT_VBLANK(1),
51 priv
->mmio
+ HIBMC_RAW_INTERRUPT
);
52 drm_handle_vblank(dev
, 0);
58 static struct drm_driver hibmc_driver
= {
59 .driver_features
= DRIVER_GEM
| DRIVER_MODESET
|
60 DRIVER_ATOMIC
| DRIVER_HAVE_IRQ
,
64 .desc
= "hibmc drm driver",
67 .gem_free_object_unlocked
= hibmc_gem_free_object
,
68 .dumb_create
= hibmc_dumb_create
,
69 .dumb_map_offset
= hibmc_dumb_mmap_offset
,
70 .dumb_destroy
= drm_gem_dumb_destroy
,
71 .irq_handler
= hibmc_drm_interrupt
,
72 .set_busid
= drm_pci_set_busid
,
75 static int __maybe_unused
hibmc_pm_suspend(struct device
*dev
)
77 struct pci_dev
*pdev
= to_pci_dev(dev
);
78 struct drm_device
*drm_dev
= pci_get_drvdata(pdev
);
79 struct hibmc_drm_private
*priv
= drm_dev
->dev_private
;
81 drm_kms_helper_poll_disable(drm_dev
);
82 priv
->suspend_state
= drm_atomic_helper_suspend(drm_dev
);
83 if (IS_ERR(priv
->suspend_state
)) {
84 DRM_ERROR("drm_atomic_helper_suspend failed: %ld\n",
85 PTR_ERR(priv
->suspend_state
));
86 drm_kms_helper_poll_enable(drm_dev
);
87 return PTR_ERR(priv
->suspend_state
);
93 static int __maybe_unused
hibmc_pm_resume(struct device
*dev
)
95 struct pci_dev
*pdev
= to_pci_dev(dev
);
96 struct drm_device
*drm_dev
= pci_get_drvdata(pdev
);
97 struct hibmc_drm_private
*priv
= drm_dev
->dev_private
;
99 drm_atomic_helper_resume(drm_dev
, priv
->suspend_state
);
100 drm_kms_helper_poll_enable(drm_dev
);
105 static const struct dev_pm_ops hibmc_pm_ops
= {
106 SET_SYSTEM_SLEEP_PM_OPS(hibmc_pm_suspend
,
110 static int hibmc_kms_init(struct hibmc_drm_private
*priv
)
114 drm_mode_config_init(priv
->dev
);
115 priv
->mode_config_initialized
= true;
117 priv
->dev
->mode_config
.min_width
= 0;
118 priv
->dev
->mode_config
.min_height
= 0;
119 priv
->dev
->mode_config
.max_width
= 1920;
120 priv
->dev
->mode_config
.max_height
= 1440;
122 priv
->dev
->mode_config
.fb_base
= priv
->fb_base
;
123 priv
->dev
->mode_config
.preferred_depth
= 24;
124 priv
->dev
->mode_config
.prefer_shadow
= 0;
126 priv
->dev
->mode_config
.funcs
= (void *)&hibmc_mode_funcs
;
128 ret
= hibmc_de_init(priv
);
130 DRM_ERROR("failed to init de: %d\n", ret
);
134 ret
= hibmc_vdac_init(priv
);
136 DRM_ERROR("failed to init vdac: %d\n", ret
);
143 static void hibmc_kms_fini(struct hibmc_drm_private
*priv
)
145 if (priv
->mode_config_initialized
) {
146 drm_mode_config_cleanup(priv
->dev
);
147 priv
->mode_config_initialized
= false;
152 * It can operate in one of three modes: 0, 1 or Sleep.
154 void hibmc_set_power_mode(struct hibmc_drm_private
*priv
,
155 unsigned int power_mode
)
157 unsigned int control_value
= 0;
158 void __iomem
*mmio
= priv
->mmio
;
159 unsigned int input
= 1;
161 if (power_mode
> HIBMC_PW_MODE_CTL_MODE_SLEEP
)
164 if (power_mode
== HIBMC_PW_MODE_CTL_MODE_SLEEP
)
167 control_value
= readl(mmio
+ HIBMC_POWER_MODE_CTRL
);
168 control_value
&= ~(HIBMC_PW_MODE_CTL_MODE_MASK
|
169 HIBMC_PW_MODE_CTL_OSC_INPUT_MASK
);
170 control_value
|= HIBMC_FIELD(HIBMC_PW_MODE_CTL_MODE
, power_mode
);
171 control_value
|= HIBMC_FIELD(HIBMC_PW_MODE_CTL_OSC_INPUT
, input
);
172 writel(control_value
, mmio
+ HIBMC_POWER_MODE_CTRL
);
175 void hibmc_set_current_gate(struct hibmc_drm_private
*priv
, unsigned int gate
)
177 unsigned int gate_reg
;
179 void __iomem
*mmio
= priv
->mmio
;
181 /* Get current power mode. */
182 mode
= (readl(mmio
+ HIBMC_POWER_MODE_CTRL
) &
183 HIBMC_PW_MODE_CTL_MODE_MASK
) >> HIBMC_PW_MODE_CTL_MODE_SHIFT
;
186 case HIBMC_PW_MODE_CTL_MODE_MODE0
:
187 gate_reg
= HIBMC_MODE0_GATE
;
190 case HIBMC_PW_MODE_CTL_MODE_MODE1
:
191 gate_reg
= HIBMC_MODE1_GATE
;
195 gate_reg
= HIBMC_MODE0_GATE
;
198 writel(gate
, mmio
+ gate_reg
);
201 static void hibmc_hw_config(struct hibmc_drm_private
*priv
)
205 /* On hardware reset, power mode 0 is default. */
206 hibmc_set_power_mode(priv
, HIBMC_PW_MODE_CTL_MODE_MODE0
);
208 /* Enable display power gate & LOCALMEM power gate*/
209 reg
= readl(priv
->mmio
+ HIBMC_CURRENT_GATE
);
210 reg
&= ~HIBMC_CURR_GATE_DISPLAY_MASK
;
211 reg
&= ~HIBMC_CURR_GATE_LOCALMEM_MASK
;
212 reg
|= HIBMC_CURR_GATE_DISPLAY(1);
213 reg
|= HIBMC_CURR_GATE_LOCALMEM(1);
215 hibmc_set_current_gate(priv
, reg
);
218 * Reset the memory controller. If the memory controller
219 * is not reset in chip,the system might hang when sw accesses
220 * the memory.The memory should be resetted after
221 * changing the MXCLK.
223 reg
= readl(priv
->mmio
+ HIBMC_MISC_CTRL
);
224 reg
&= ~HIBMC_MSCCTL_LOCALMEM_RESET_MASK
;
225 reg
|= HIBMC_MSCCTL_LOCALMEM_RESET(0);
226 writel(reg
, priv
->mmio
+ HIBMC_MISC_CTRL
);
228 reg
&= ~HIBMC_MSCCTL_LOCALMEM_RESET_MASK
;
229 reg
|= HIBMC_MSCCTL_LOCALMEM_RESET(1);
231 writel(reg
, priv
->mmio
+ HIBMC_MISC_CTRL
);
234 static int hibmc_hw_map(struct hibmc_drm_private
*priv
)
236 struct drm_device
*dev
= priv
->dev
;
237 struct pci_dev
*pdev
= dev
->pdev
;
238 resource_size_t addr
, size
, ioaddr
, iosize
;
240 ioaddr
= pci_resource_start(pdev
, 1);
241 iosize
= pci_resource_len(pdev
, 1);
242 priv
->mmio
= devm_ioremap_nocache(dev
->dev
, ioaddr
, iosize
);
244 DRM_ERROR("Cannot map mmio region\n");
248 addr
= pci_resource_start(pdev
, 0);
249 size
= pci_resource_len(pdev
, 0);
250 priv
->fb_map
= devm_ioremap(dev
->dev
, addr
, size
);
252 DRM_ERROR("Cannot map framebuffer\n");
255 priv
->fb_base
= addr
;
256 priv
->fb_size
= size
;
261 static int hibmc_hw_init(struct hibmc_drm_private
*priv
)
265 ret
= hibmc_hw_map(priv
);
269 hibmc_hw_config(priv
);
274 static int hibmc_unload(struct drm_device
*dev
)
276 struct hibmc_drm_private
*priv
= dev
->dev_private
;
278 hibmc_fbdev_fini(priv
);
280 if (dev
->irq_enabled
)
281 drm_irq_uninstall(dev
);
282 if (priv
->msi_enabled
)
283 pci_disable_msi(dev
->pdev
);
284 drm_vblank_cleanup(dev
);
286 hibmc_kms_fini(priv
);
288 dev
->dev_private
= NULL
;
292 static int hibmc_load(struct drm_device
*dev
)
294 struct hibmc_drm_private
*priv
;
297 priv
= devm_kzalloc(dev
->dev
, sizeof(*priv
), GFP_KERNEL
);
299 DRM_ERROR("no memory to allocate for hibmc_drm_private\n");
302 dev
->dev_private
= priv
;
305 ret
= hibmc_hw_init(priv
);
309 ret
= hibmc_mm_init(priv
);
313 ret
= hibmc_kms_init(priv
);
317 ret
= drm_vblank_init(dev
, dev
->mode_config
.num_crtc
);
319 DRM_ERROR("failed to initialize vblank: %d\n", ret
);
323 priv
->msi_enabled
= 0;
324 ret
= pci_enable_msi(dev
->pdev
);
326 DRM_WARN("enabling MSI failed: %d\n", ret
);
328 priv
->msi_enabled
= 1;
329 ret
= drm_irq_install(dev
, dev
->pdev
->irq
);
331 DRM_WARN("install irq failed: %d\n", ret
);
334 /* reset all the states of crtc/plane/encoder/connector */
335 drm_mode_config_reset(dev
);
337 ret
= hibmc_fbdev_init(priv
);
339 DRM_ERROR("failed to initialize fbdev: %d\n", ret
);
347 DRM_ERROR("failed to initialize drm driver: %d\n", ret
);
351 static int hibmc_pci_probe(struct pci_dev
*pdev
,
352 const struct pci_device_id
*ent
)
354 struct drm_device
*dev
;
357 dev
= drm_dev_alloc(&hibmc_driver
, &pdev
->dev
);
359 DRM_ERROR("failed to allocate drm_device\n");
364 pci_set_drvdata(pdev
, dev
);
366 ret
= pci_enable_device(pdev
);
368 DRM_ERROR("failed to enable pci device: %d\n", ret
);
372 ret
= hibmc_load(dev
);
374 DRM_ERROR("failed to load hibmc: %d\n", ret
);
378 ret
= drm_dev_register(dev
, 0);
380 DRM_ERROR("failed to register drv for userspace access: %d\n",
389 pci_disable_device(pdev
);
396 static void hibmc_pci_remove(struct pci_dev
*pdev
)
398 struct drm_device
*dev
= pci_get_drvdata(pdev
);
400 drm_dev_unregister(dev
);
405 static struct pci_device_id hibmc_pci_table
[] = {
406 {0x19e5, 0x1711, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
410 static struct pci_driver hibmc_pci_driver
= {
412 .id_table
= hibmc_pci_table
,
413 .probe
= hibmc_pci_probe
,
414 .remove
= hibmc_pci_remove
,
415 .driver
.pm
= &hibmc_pm_ops
,
418 static int __init
hibmc_init(void)
420 return pci_register_driver(&hibmc_pci_driver
);
423 static void __exit
hibmc_exit(void)
425 return pci_unregister_driver(&hibmc_pci_driver
);
428 module_init(hibmc_init
);
429 module_exit(hibmc_exit
);
431 MODULE_DEVICE_TABLE(pci
, hibmc_pci_table
);
432 MODULE_AUTHOR("RongrongZou <zourongrong@huawei.com>");
433 MODULE_DESCRIPTION("DRM Driver for Hisilicon Hibmc");
434 MODULE_LICENSE("GPL v2");