]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/media/platform/vsp1/vsp1_drv.c
Merge remote-tracking branch 'hwmon-staging/hwmon-next'
[karo-tx-linux.git] / drivers / media / platform / vsp1 / vsp1_drv.c
1 /*
2  * vsp1_drv.c  --  R-Car VSP1 Driver
3  *
4  * Copyright (C) 2013-2015 Renesas Electronics Corporation
5  *
6  * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  */
13
14 #include <linux/clk.h>
15 #include <linux/delay.h>
16 #include <linux/device.h>
17 #include <linux/interrupt.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/platform_device.h>
21 #include <linux/videodev2.h>
22
23 #include "vsp1.h"
24 #include "vsp1_bru.h"
25 #include "vsp1_hsit.h"
26 #include "vsp1_lif.h"
27 #include "vsp1_lut.h"
28 #include "vsp1_rwpf.h"
29 #include "vsp1_sru.h"
30 #include "vsp1_uds.h"
31
32 /* -----------------------------------------------------------------------------
33  * Interrupt Handling
34  */
35
36 static irqreturn_t vsp1_irq_handler(int irq, void *data)
37 {
38         u32 mask = VI6_WFP_IRQ_STA_DFE | VI6_WFP_IRQ_STA_FRE;
39         struct vsp1_device *vsp1 = data;
40         irqreturn_t ret = IRQ_NONE;
41         unsigned int i;
42
43         for (i = 0; i < vsp1->pdata.wpf_count; ++i) {
44                 struct vsp1_rwpf *wpf = vsp1->wpf[i];
45                 struct vsp1_pipeline *pipe;
46                 u32 status;
47
48                 if (wpf == NULL)
49                         continue;
50
51                 pipe = to_vsp1_pipeline(&wpf->entity.subdev.entity);
52                 status = vsp1_read(vsp1, VI6_WPF_IRQ_STA(i));
53                 vsp1_write(vsp1, VI6_WPF_IRQ_STA(i), ~status & mask);
54
55                 if (status & VI6_WFP_IRQ_STA_FRE) {
56                         vsp1_pipeline_frame_end(pipe);
57                         ret = IRQ_HANDLED;
58                 }
59         }
60
61         return ret;
62 }
63
64 /* -----------------------------------------------------------------------------
65  * Entities
66  */
67
68 /*
69  * vsp1_create_links - Create links from all sources to the given sink
70  *
71  * This function creates media links from all valid sources to the given sink
72  * pad. Links that would be invalid according to the VSP1 hardware capabilities
73  * are skipped. Those include all links
74  *
75  * - from a UDS to a UDS (UDS entities can't be chained)
76  * - from an entity to itself (no loops are allowed)
77  */
78 static int vsp1_create_links(struct vsp1_device *vsp1, struct vsp1_entity *sink)
79 {
80         struct media_entity *entity = &sink->subdev.entity;
81         struct vsp1_entity *source;
82         unsigned int pad;
83         int ret;
84
85         list_for_each_entry(source, &vsp1->entities, list_dev) {
86                 u32 flags;
87
88                 if (source->type == sink->type)
89                         continue;
90
91                 if (source->type == VSP1_ENTITY_LIF ||
92                     source->type == VSP1_ENTITY_WPF)
93                         continue;
94
95                 flags = source->type == VSP1_ENTITY_RPF &&
96                         sink->type == VSP1_ENTITY_WPF &&
97                         source->index == sink->index
98                       ? MEDIA_LNK_FL_ENABLED : 0;
99
100                 for (pad = 0; pad < entity->num_pads; ++pad) {
101                         if (!(entity->pads[pad].flags & MEDIA_PAD_FL_SINK))
102                                 continue;
103
104                         ret = media_create_pad_link(&source->subdev.entity,
105                                                        source->source_pad,
106                                                        entity, pad, flags);
107                         if (ret < 0)
108                                 return ret;
109
110                         if (flags & MEDIA_LNK_FL_ENABLED)
111                                 source->sink = entity;
112                 }
113         }
114
115         return 0;
116 }
117
118 static void vsp1_destroy_entities(struct vsp1_device *vsp1)
119 {
120         struct vsp1_entity *entity;
121         struct vsp1_entity *next;
122
123         list_for_each_entry_safe(entity, next, &vsp1->entities, list_dev) {
124                 list_del(&entity->list_dev);
125                 vsp1_entity_destroy(entity);
126         }
127
128         v4l2_device_unregister(&vsp1->v4l2_dev);
129         media_device_unregister(&vsp1->media_dev);
130         media_device_cleanup(&vsp1->media_dev);
131 }
132
133 static int vsp1_create_entities(struct vsp1_device *vsp1)
134 {
135         struct media_device *mdev = &vsp1->media_dev;
136         struct v4l2_device *vdev = &vsp1->v4l2_dev;
137         struct vsp1_entity *entity;
138         unsigned int i;
139         int ret;
140
141         mdev->dev = vsp1->dev;
142         strlcpy(mdev->model, "VSP1", sizeof(mdev->model));
143         snprintf(mdev->bus_info, sizeof(mdev->bus_info), "platform:%s",
144                  dev_name(mdev->dev));
145         media_device_init(mdev);
146
147         vdev->mdev = mdev;
148         ret = v4l2_device_register(vsp1->dev, vdev);
149         if (ret < 0) {
150                 dev_err(vsp1->dev, "V4L2 device registration failed (%d)\n",
151                         ret);
152                 goto done;
153         }
154
155         /* Instantiate all the entities. */
156         vsp1->bru = vsp1_bru_create(vsp1);
157         if (IS_ERR(vsp1->bru)) {
158                 ret = PTR_ERR(vsp1->bru);
159                 goto done;
160         }
161
162         list_add_tail(&vsp1->bru->entity.list_dev, &vsp1->entities);
163
164         vsp1->hsi = vsp1_hsit_create(vsp1, true);
165         if (IS_ERR(vsp1->hsi)) {
166                 ret = PTR_ERR(vsp1->hsi);
167                 goto done;
168         }
169
170         list_add_tail(&vsp1->hsi->entity.list_dev, &vsp1->entities);
171
172         vsp1->hst = vsp1_hsit_create(vsp1, false);
173         if (IS_ERR(vsp1->hst)) {
174                 ret = PTR_ERR(vsp1->hst);
175                 goto done;
176         }
177
178         list_add_tail(&vsp1->hst->entity.list_dev, &vsp1->entities);
179
180         if (vsp1->pdata.features & VSP1_HAS_LIF) {
181                 vsp1->lif = vsp1_lif_create(vsp1);
182                 if (IS_ERR(vsp1->lif)) {
183                         ret = PTR_ERR(vsp1->lif);
184                         goto done;
185                 }
186
187                 list_add_tail(&vsp1->lif->entity.list_dev, &vsp1->entities);
188         }
189
190         if (vsp1->pdata.features & VSP1_HAS_LUT) {
191                 vsp1->lut = vsp1_lut_create(vsp1);
192                 if (IS_ERR(vsp1->lut)) {
193                         ret = PTR_ERR(vsp1->lut);
194                         goto done;
195                 }
196
197                 list_add_tail(&vsp1->lut->entity.list_dev, &vsp1->entities);
198         }
199
200         for (i = 0; i < vsp1->pdata.rpf_count; ++i) {
201                 struct vsp1_rwpf *rpf;
202
203                 rpf = vsp1_rpf_create(vsp1, i);
204                 if (IS_ERR(rpf)) {
205                         ret = PTR_ERR(rpf);
206                         goto done;
207                 }
208
209                 vsp1->rpf[i] = rpf;
210                 list_add_tail(&rpf->entity.list_dev, &vsp1->entities);
211         }
212
213         if (vsp1->pdata.features & VSP1_HAS_SRU) {
214                 vsp1->sru = vsp1_sru_create(vsp1);
215                 if (IS_ERR(vsp1->sru)) {
216                         ret = PTR_ERR(vsp1->sru);
217                         goto done;
218                 }
219
220                 list_add_tail(&vsp1->sru->entity.list_dev, &vsp1->entities);
221         }
222
223         for (i = 0; i < vsp1->pdata.uds_count; ++i) {
224                 struct vsp1_uds *uds;
225
226                 uds = vsp1_uds_create(vsp1, i);
227                 if (IS_ERR(uds)) {
228                         ret = PTR_ERR(uds);
229                         goto done;
230                 }
231
232                 vsp1->uds[i] = uds;
233                 list_add_tail(&uds->entity.list_dev, &vsp1->entities);
234         }
235
236         for (i = 0; i < vsp1->pdata.wpf_count; ++i) {
237                 struct vsp1_rwpf *wpf;
238
239                 wpf = vsp1_wpf_create(vsp1, i);
240                 if (IS_ERR(wpf)) {
241                         ret = PTR_ERR(wpf);
242                         goto done;
243                 }
244
245                 vsp1->wpf[i] = wpf;
246                 list_add_tail(&wpf->entity.list_dev, &vsp1->entities);
247         }
248
249         /* Register all subdevs. */
250         list_for_each_entry(entity, &vsp1->entities, list_dev) {
251                 ret = v4l2_device_register_subdev(&vsp1->v4l2_dev,
252                                                   &entity->subdev);
253                 if (ret < 0)
254                         goto done;
255         }
256
257         /* Create links. */
258         list_for_each_entry(entity, &vsp1->entities, list_dev) {
259                 if (entity->type == VSP1_ENTITY_WPF) {
260                         ret = vsp1_wpf_create_links(vsp1, entity);
261                         if (ret < 0)
262                                 goto done;
263                 } else if (entity->type == VSP1_ENTITY_RPF) {
264                         ret = vsp1_rpf_create_links(vsp1, entity);
265                         if (ret < 0)
266                                 goto done;
267                 }
268
269                 if (entity->type != VSP1_ENTITY_LIF &&
270                     entity->type != VSP1_ENTITY_RPF) {
271                         ret = vsp1_create_links(vsp1, entity);
272                         if (ret < 0)
273                                 goto done;
274                 }
275         }
276
277         if (vsp1->pdata.features & VSP1_HAS_LIF) {
278                 ret = media_create_pad_link(
279                         &vsp1->wpf[0]->entity.subdev.entity, RWPF_PAD_SOURCE,
280                         &vsp1->lif->entity.subdev.entity, LIF_PAD_SINK, 0);
281                 if (ret < 0)
282                         return ret;
283         }
284
285         ret = v4l2_device_register_subdev_nodes(&vsp1->v4l2_dev);
286         if (ret < 0)
287                 goto done;
288
289         ret = media_device_register(mdev);
290
291 done:
292         if (ret < 0)
293                 vsp1_destroy_entities(vsp1);
294
295         return ret;
296 }
297
298 static int vsp1_device_init(struct vsp1_device *vsp1)
299 {
300         unsigned int i;
301         u32 status;
302
303         /* Reset any channel that might be running. */
304         status = vsp1_read(vsp1, VI6_STATUS);
305
306         for (i = 0; i < vsp1->pdata.wpf_count; ++i) {
307                 unsigned int timeout;
308
309                 if (!(status & VI6_STATUS_SYS_ACT(i)))
310                         continue;
311
312                 vsp1_write(vsp1, VI6_SRESET, VI6_SRESET_SRTS(i));
313                 for (timeout = 10; timeout > 0; --timeout) {
314                         status = vsp1_read(vsp1, VI6_STATUS);
315                         if (!(status & VI6_STATUS_SYS_ACT(i)))
316                                 break;
317
318                         usleep_range(1000, 2000);
319                 }
320
321                 if (!timeout) {
322                         dev_err(vsp1->dev, "failed to reset wpf.%u\n", i);
323                         return -ETIMEDOUT;
324                 }
325         }
326
327         vsp1_write(vsp1, VI6_CLK_DCSWT, (8 << VI6_CLK_DCSWT_CSTPW_SHIFT) |
328                    (8 << VI6_CLK_DCSWT_CSTRW_SHIFT));
329
330         for (i = 0; i < vsp1->pdata.rpf_count; ++i)
331                 vsp1_write(vsp1, VI6_DPR_RPF_ROUTE(i), VI6_DPR_NODE_UNUSED);
332
333         for (i = 0; i < vsp1->pdata.uds_count; ++i)
334                 vsp1_write(vsp1, VI6_DPR_UDS_ROUTE(i), VI6_DPR_NODE_UNUSED);
335
336         vsp1_write(vsp1, VI6_DPR_SRU_ROUTE, VI6_DPR_NODE_UNUSED);
337         vsp1_write(vsp1, VI6_DPR_LUT_ROUTE, VI6_DPR_NODE_UNUSED);
338         vsp1_write(vsp1, VI6_DPR_CLU_ROUTE, VI6_DPR_NODE_UNUSED);
339         vsp1_write(vsp1, VI6_DPR_HST_ROUTE, VI6_DPR_NODE_UNUSED);
340         vsp1_write(vsp1, VI6_DPR_HSI_ROUTE, VI6_DPR_NODE_UNUSED);
341         vsp1_write(vsp1, VI6_DPR_BRU_ROUTE, VI6_DPR_NODE_UNUSED);
342
343         vsp1_write(vsp1, VI6_DPR_HGO_SMPPT, (7 << VI6_DPR_SMPPT_TGW_SHIFT) |
344                    (VI6_DPR_NODE_UNUSED << VI6_DPR_SMPPT_PT_SHIFT));
345         vsp1_write(vsp1, VI6_DPR_HGT_SMPPT, (7 << VI6_DPR_SMPPT_TGW_SHIFT) |
346                    (VI6_DPR_NODE_UNUSED << VI6_DPR_SMPPT_PT_SHIFT));
347
348         return 0;
349 }
350
351 /*
352  * vsp1_device_get - Acquire the VSP1 device
353  *
354  * Increment the VSP1 reference count and initialize the device if the first
355  * reference is taken.
356  *
357  * Return 0 on success or a negative error code otherwise.
358  */
359 int vsp1_device_get(struct vsp1_device *vsp1)
360 {
361         int ret = 0;
362
363         mutex_lock(&vsp1->lock);
364         if (vsp1->ref_count > 0)
365                 goto done;
366
367         ret = clk_prepare_enable(vsp1->clock);
368         if (ret < 0)
369                 goto done;
370
371         ret = vsp1_device_init(vsp1);
372         if (ret < 0) {
373                 clk_disable_unprepare(vsp1->clock);
374                 goto done;
375         }
376
377 done:
378         if (!ret)
379                 vsp1->ref_count++;
380
381         mutex_unlock(&vsp1->lock);
382         return ret;
383 }
384
385 /*
386  * vsp1_device_put - Release the VSP1 device
387  *
388  * Decrement the VSP1 reference count and cleanup the device if the last
389  * reference is released.
390  */
391 void vsp1_device_put(struct vsp1_device *vsp1)
392 {
393         mutex_lock(&vsp1->lock);
394
395         if (--vsp1->ref_count == 0)
396                 clk_disable_unprepare(vsp1->clock);
397
398         mutex_unlock(&vsp1->lock);
399 }
400
401 /* -----------------------------------------------------------------------------
402  * Power Management
403  */
404
405 #ifdef CONFIG_PM_SLEEP
406 static int vsp1_pm_suspend(struct device *dev)
407 {
408         struct vsp1_device *vsp1 = dev_get_drvdata(dev);
409
410         WARN_ON(mutex_is_locked(&vsp1->lock));
411
412         if (vsp1->ref_count == 0)
413                 return 0;
414
415         vsp1_pipelines_suspend(vsp1);
416
417         clk_disable_unprepare(vsp1->clock);
418
419         return 0;
420 }
421
422 static int vsp1_pm_resume(struct device *dev)
423 {
424         struct vsp1_device *vsp1 = dev_get_drvdata(dev);
425
426         WARN_ON(mutex_is_locked(&vsp1->lock));
427
428         if (vsp1->ref_count == 0)
429                 return 0;
430
431         clk_prepare_enable(vsp1->clock);
432
433         vsp1_pipelines_resume(vsp1);
434
435         return 0;
436 }
437 #endif
438
439 static const struct dev_pm_ops vsp1_pm_ops = {
440         SET_SYSTEM_SLEEP_PM_OPS(vsp1_pm_suspend, vsp1_pm_resume)
441 };
442
443 /* -----------------------------------------------------------------------------
444  * Platform Driver
445  */
446
447 static int vsp1_parse_dt(struct vsp1_device *vsp1)
448 {
449         struct device_node *np = vsp1->dev->of_node;
450         struct vsp1_platform_data *pdata = &vsp1->pdata;
451
452         if (of_property_read_bool(np, "renesas,has-lif"))
453                 pdata->features |= VSP1_HAS_LIF;
454         if (of_property_read_bool(np, "renesas,has-lut"))
455                 pdata->features |= VSP1_HAS_LUT;
456         if (of_property_read_bool(np, "renesas,has-sru"))
457                 pdata->features |= VSP1_HAS_SRU;
458
459         of_property_read_u32(np, "renesas,#rpf", &pdata->rpf_count);
460         of_property_read_u32(np, "renesas,#uds", &pdata->uds_count);
461         of_property_read_u32(np, "renesas,#wpf", &pdata->wpf_count);
462
463         if (pdata->rpf_count <= 0 || pdata->rpf_count > VSP1_MAX_RPF) {
464                 dev_err(vsp1->dev, "invalid number of RPF (%u)\n",
465                         pdata->rpf_count);
466                 return -EINVAL;
467         }
468
469         if (pdata->uds_count <= 0 || pdata->uds_count > VSP1_MAX_UDS) {
470                 dev_err(vsp1->dev, "invalid number of UDS (%u)\n",
471                         pdata->uds_count);
472                 return -EINVAL;
473         }
474
475         if (pdata->wpf_count <= 0 || pdata->wpf_count > VSP1_MAX_WPF) {
476                 dev_err(vsp1->dev, "invalid number of WPF (%u)\n",
477                         pdata->wpf_count);
478                 return -EINVAL;
479         }
480
481         return 0;
482 }
483
484 static int vsp1_probe(struct platform_device *pdev)
485 {
486         struct vsp1_device *vsp1;
487         struct resource *irq;
488         struct resource *io;
489         int ret;
490
491         vsp1 = devm_kzalloc(&pdev->dev, sizeof(*vsp1), GFP_KERNEL);
492         if (vsp1 == NULL)
493                 return -ENOMEM;
494
495         vsp1->dev = &pdev->dev;
496         mutex_init(&vsp1->lock);
497         INIT_LIST_HEAD(&vsp1->entities);
498
499         ret = vsp1_parse_dt(vsp1);
500         if (ret < 0)
501                 return ret;
502
503         /* I/O, IRQ and clock resources */
504         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
505         vsp1->mmio = devm_ioremap_resource(&pdev->dev, io);
506         if (IS_ERR(vsp1->mmio))
507                 return PTR_ERR(vsp1->mmio);
508
509         vsp1->clock = devm_clk_get(&pdev->dev, NULL);
510         if (IS_ERR(vsp1->clock)) {
511                 dev_err(&pdev->dev, "failed to get clock\n");
512                 return PTR_ERR(vsp1->clock);
513         }
514
515         irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
516         if (!irq) {
517                 dev_err(&pdev->dev, "missing IRQ\n");
518                 return -EINVAL;
519         }
520
521         ret = devm_request_irq(&pdev->dev, irq->start, vsp1_irq_handler,
522                               IRQF_SHARED, dev_name(&pdev->dev), vsp1);
523         if (ret < 0) {
524                 dev_err(&pdev->dev, "failed to request IRQ\n");
525                 return ret;
526         }
527
528         /* Instanciate entities */
529         ret = vsp1_create_entities(vsp1);
530         if (ret < 0) {
531                 dev_err(&pdev->dev, "failed to create entities\n");
532                 return ret;
533         }
534
535         platform_set_drvdata(pdev, vsp1);
536
537         return 0;
538 }
539
540 static int vsp1_remove(struct platform_device *pdev)
541 {
542         struct vsp1_device *vsp1 = platform_get_drvdata(pdev);
543
544         vsp1_destroy_entities(vsp1);
545
546         return 0;
547 }
548
549 static const struct of_device_id vsp1_of_match[] = {
550         { .compatible = "renesas,vsp1" },
551         { },
552 };
553
554 static struct platform_driver vsp1_platform_driver = {
555         .probe          = vsp1_probe,
556         .remove         = vsp1_remove,
557         .driver         = {
558                 .name   = "vsp1",
559                 .pm     = &vsp1_pm_ops,
560                 .of_match_table = vsp1_of_match,
561         },
562 };
563
564 module_platform_driver(vsp1_platform_driver);
565
566 MODULE_ALIAS("vsp1");
567 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
568 MODULE_DESCRIPTION("Renesas VSP1 Driver");
569 MODULE_LICENSE("GPL");