1
2
3
4
5
6
7
8
9
10#include <linux/clk.h>
11#include <linux/io.h>
12#include <linux/mm.h>
13#include <linux/module.h>
14#include <linux/platform_device.h>
15#include <linux/pm.h>
16#include <linux/slab.h>
17
18#include <drm/drmP.h>
19#include <drm/drm_crtc_helper.h>
20#include <drm/drm_gem_cma_helper.h>
21#include <drm/drm_probe_helper.h>
22
23#include "shmob_drm_drv.h"
24#include "shmob_drm_kms.h"
25#include "shmob_drm_plane.h"
26#include "shmob_drm_regs.h"
27
28
29
30
31
32static int shmob_drm_init_interface(struct shmob_drm_device *sdev)
33{
34 static const u32 ldmt1r[] = {
35 [SHMOB_DRM_IFACE_RGB8] = LDMT1R_MIFTYP_RGB8,
36 [SHMOB_DRM_IFACE_RGB9] = LDMT1R_MIFTYP_RGB9,
37 [SHMOB_DRM_IFACE_RGB12A] = LDMT1R_MIFTYP_RGB12A,
38 [SHMOB_DRM_IFACE_RGB12B] = LDMT1R_MIFTYP_RGB12B,
39 [SHMOB_DRM_IFACE_RGB16] = LDMT1R_MIFTYP_RGB16,
40 [SHMOB_DRM_IFACE_RGB18] = LDMT1R_MIFTYP_RGB18,
41 [SHMOB_DRM_IFACE_RGB24] = LDMT1R_MIFTYP_RGB24,
42 [SHMOB_DRM_IFACE_YUV422] = LDMT1R_MIFTYP_YCBCR,
43 [SHMOB_DRM_IFACE_SYS8A] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS8A,
44 [SHMOB_DRM_IFACE_SYS8B] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS8B,
45 [SHMOB_DRM_IFACE_SYS8C] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS8C,
46 [SHMOB_DRM_IFACE_SYS8D] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS8D,
47 [SHMOB_DRM_IFACE_SYS9] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS9,
48 [SHMOB_DRM_IFACE_SYS12] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS12,
49 [SHMOB_DRM_IFACE_SYS16A] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS16A,
50 [SHMOB_DRM_IFACE_SYS16B] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS16B,
51 [SHMOB_DRM_IFACE_SYS16C] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS16C,
52 [SHMOB_DRM_IFACE_SYS18] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS18,
53 [SHMOB_DRM_IFACE_SYS24] = LDMT1R_IFM | LDMT1R_MIFTYP_SYS24,
54 };
55
56 if (sdev->pdata->iface.interface >= ARRAY_SIZE(ldmt1r)) {
57 dev_err(sdev->dev, "invalid interface type %u\n",
58 sdev->pdata->iface.interface);
59 return -EINVAL;
60 }
61
62 sdev->ldmt1r = ldmt1r[sdev->pdata->iface.interface];
63 return 0;
64}
65
66static int shmob_drm_setup_clocks(struct shmob_drm_device *sdev,
67 enum shmob_drm_clk_source clksrc)
68{
69 struct clk *clk;
70 char *clkname;
71
72 switch (clksrc) {
73 case SHMOB_DRM_CLK_BUS:
74 clkname = "bus_clk";
75 sdev->lddckr = LDDCKR_ICKSEL_BUS;
76 break;
77 case SHMOB_DRM_CLK_PERIPHERAL:
78 clkname = "peripheral_clk";
79 sdev->lddckr = LDDCKR_ICKSEL_MIPI;
80 break;
81 case SHMOB_DRM_CLK_EXTERNAL:
82 clkname = NULL;
83 sdev->lddckr = LDDCKR_ICKSEL_HDMI;
84 break;
85 default:
86 return -EINVAL;
87 }
88
89 clk = devm_clk_get(sdev->dev, clkname);
90 if (IS_ERR(clk)) {
91 dev_err(sdev->dev, "cannot get dot clock %s\n", clkname);
92 return PTR_ERR(clk);
93 }
94
95 sdev->clock = clk;
96 return 0;
97}
98
99
100
101
102
103static irqreturn_t shmob_drm_irq(int irq, void *arg)
104{
105 struct drm_device *dev = arg;
106 struct shmob_drm_device *sdev = dev->dev_private;
107 unsigned long flags;
108 u32 status;
109
110
111
112
113
114 spin_lock_irqsave(&sdev->irq_lock, flags);
115 status = lcdc_read(sdev, LDINTR);
116 lcdc_write(sdev, LDINTR, status ^ LDINTR_STATUS_MASK);
117 spin_unlock_irqrestore(&sdev->irq_lock, flags);
118
119 if (status & LDINTR_VES) {
120 drm_handle_vblank(dev, 0);
121 shmob_drm_crtc_finish_page_flip(&sdev->crtc);
122 }
123
124 return IRQ_HANDLED;
125}
126
127DEFINE_DRM_GEM_CMA_FOPS(shmob_drm_fops);
128
129static struct drm_driver shmob_drm_driver = {
130 .driver_features = DRIVER_GEM | DRIVER_MODESET
131 | DRIVER_PRIME,
132 .irq_handler = shmob_drm_irq,
133 .gem_free_object_unlocked = drm_gem_cma_free_object,
134 .gem_vm_ops = &drm_gem_cma_vm_ops,
135 .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
136 .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
137 .gem_prime_import = drm_gem_prime_import,
138 .gem_prime_export = drm_gem_prime_export,
139 .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
140 .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
141 .gem_prime_vmap = drm_gem_cma_prime_vmap,
142 .gem_prime_vunmap = drm_gem_cma_prime_vunmap,
143 .gem_prime_mmap = drm_gem_cma_prime_mmap,
144 .dumb_create = drm_gem_cma_dumb_create,
145 .fops = &shmob_drm_fops,
146 .name = "shmob-drm",
147 .desc = "Renesas SH Mobile DRM",
148 .date = "20120424",
149 .major = 1,
150 .minor = 0,
151};
152
153
154
155
156
157#ifdef CONFIG_PM_SLEEP
158static int shmob_drm_pm_suspend(struct device *dev)
159{
160 struct shmob_drm_device *sdev = dev_get_drvdata(dev);
161
162 drm_kms_helper_poll_disable(sdev->ddev);
163 shmob_drm_crtc_suspend(&sdev->crtc);
164
165 return 0;
166}
167
168static int shmob_drm_pm_resume(struct device *dev)
169{
170 struct shmob_drm_device *sdev = dev_get_drvdata(dev);
171
172 drm_modeset_lock_all(sdev->ddev);
173 shmob_drm_crtc_resume(&sdev->crtc);
174 drm_modeset_unlock_all(sdev->ddev);
175
176 drm_kms_helper_poll_enable(sdev->ddev);
177 return 0;
178}
179#endif
180
181static const struct dev_pm_ops shmob_drm_pm_ops = {
182 SET_SYSTEM_SLEEP_PM_OPS(shmob_drm_pm_suspend, shmob_drm_pm_resume)
183};
184
185
186
187
188
189static int shmob_drm_remove(struct platform_device *pdev)
190{
191 struct shmob_drm_device *sdev = platform_get_drvdata(pdev);
192 struct drm_device *ddev = sdev->ddev;
193
194 drm_dev_unregister(ddev);
195 drm_kms_helper_poll_fini(ddev);
196 drm_mode_config_cleanup(ddev);
197 drm_irq_uninstall(ddev);
198 drm_dev_put(ddev);
199
200 return 0;
201}
202
203static int shmob_drm_probe(struct platform_device *pdev)
204{
205 struct shmob_drm_platform_data *pdata = pdev->dev.platform_data;
206 struct shmob_drm_device *sdev;
207 struct drm_device *ddev;
208 struct resource *res;
209 unsigned int i;
210 int ret;
211
212 if (pdata == NULL) {
213 dev_err(&pdev->dev, "no platform data\n");
214 return -EINVAL;
215 }
216
217
218
219
220
221 sdev = devm_kzalloc(&pdev->dev, sizeof(*sdev), GFP_KERNEL);
222 if (sdev == NULL)
223 return -ENOMEM;
224
225 sdev->dev = &pdev->dev;
226 sdev->pdata = pdata;
227 spin_lock_init(&sdev->irq_lock);
228
229 platform_set_drvdata(pdev, sdev);
230
231 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
232 sdev->mmio = devm_ioremap_resource(&pdev->dev, res);
233 if (IS_ERR(sdev->mmio))
234 return PTR_ERR(sdev->mmio);
235
236 ret = shmob_drm_setup_clocks(sdev, pdata->clk_source);
237 if (ret < 0)
238 return ret;
239
240 ret = shmob_drm_init_interface(sdev);
241 if (ret < 0)
242 return ret;
243
244
245 ddev = drm_dev_alloc(&shmob_drm_driver, &pdev->dev);
246 if (IS_ERR(ddev))
247 return PTR_ERR(ddev);
248
249 sdev->ddev = ddev;
250 ddev->dev_private = sdev;
251
252 ret = shmob_drm_modeset_init(sdev);
253 if (ret < 0) {
254 dev_err(&pdev->dev, "failed to initialize mode setting\n");
255 goto err_free_drm_dev;
256 }
257
258 for (i = 0; i < 4; ++i) {
259 ret = shmob_drm_plane_create(sdev, i);
260 if (ret < 0) {
261 dev_err(&pdev->dev, "failed to create plane %u\n", i);
262 goto err_modeset_cleanup;
263 }
264 }
265
266 ret = drm_vblank_init(ddev, 1);
267 if (ret < 0) {
268 dev_err(&pdev->dev, "failed to initialize vblank\n");
269 goto err_modeset_cleanup;
270 }
271
272 ret = drm_irq_install(ddev, platform_get_irq(pdev, 0));
273 if (ret < 0) {
274 dev_err(&pdev->dev, "failed to install IRQ handler\n");
275 goto err_modeset_cleanup;
276 }
277
278
279
280
281
282 ret = drm_dev_register(ddev, 0);
283 if (ret < 0)
284 goto err_irq_uninstall;
285
286 return 0;
287
288err_irq_uninstall:
289 drm_irq_uninstall(ddev);
290err_modeset_cleanup:
291 drm_kms_helper_poll_fini(ddev);
292 drm_mode_config_cleanup(ddev);
293err_free_drm_dev:
294 drm_dev_put(ddev);
295
296 return ret;
297}
298
299static struct platform_driver shmob_drm_platform_driver = {
300 .probe = shmob_drm_probe,
301 .remove = shmob_drm_remove,
302 .driver = {
303 .name = "shmob-drm",
304 .pm = &shmob_drm_pm_ops,
305 },
306};
307
308module_platform_driver(shmob_drm_platform_driver);
309
310MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
311MODULE_DESCRIPTION("Renesas SH Mobile DRM Driver");
312MODULE_LICENSE("GPL");
313
