Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6] / drivers / media / video / sh_mobile_ceu_camera.c
1 /*
2  * V4L2 Driver for SuperH Mobile CEU interface
3  *
4  * Copyright (C) 2008 Magnus Damm
5  *
6  * Based on V4L2 Driver for PXA camera host - "pxa_camera.c",
7  *
8  * Copyright (C) 2006, Sascha Hauer, Pengutronix
9  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  */
16
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/io.h>
20 #include <linux/delay.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/errno.h>
23 #include <linux/fs.h>
24 #include <linux/interrupt.h>
25 #include <linux/kernel.h>
26 #include <linux/mm.h>
27 #include <linux/moduleparam.h>
28 #include <linux/time.h>
29 #include <linux/version.h>
30 #include <linux/device.h>
31 #include <linux/platform_device.h>
32 #include <linux/mutex.h>
33 #include <linux/videodev2.h>
34 #include <linux/clk.h>
35
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-dev.h>
38 #include <media/soc_camera.h>
39 #include <media/sh_mobile_ceu.h>
40 #include <media/videobuf-dma-contig.h>
41
42 /* register offsets for sh7722 / sh7723 */
43
44 #define CAPSR  0x00 /* Capture start register */
45 #define CAPCR  0x04 /* Capture control register */
46 #define CAMCR  0x08 /* Capture interface control register */
47 #define CMCYR  0x0c /* Capture interface cycle  register */
48 #define CAMOR  0x10 /* Capture interface offset register */
49 #define CAPWR  0x14 /* Capture interface width register */
50 #define CAIFR  0x18 /* Capture interface input format register */
51 #define CSTCR  0x20 /* Camera strobe control register (<= sh7722) */
52 #define CSECR  0x24 /* Camera strobe emission count register (<= sh7722) */
53 #define CRCNTR 0x28 /* CEU register control register */
54 #define CRCMPR 0x2c /* CEU register forcible control register */
55 #define CFLCR  0x30 /* Capture filter control register */
56 #define CFSZR  0x34 /* Capture filter size clip register */
57 #define CDWDR  0x38 /* Capture destination width register */
58 #define CDAYR  0x3c /* Capture data address Y register */
59 #define CDACR  0x40 /* Capture data address C register */
60 #define CDBYR  0x44 /* Capture data bottom-field address Y register */
61 #define CDBCR  0x48 /* Capture data bottom-field address C register */
62 #define CBDSR  0x4c /* Capture bundle destination size register */
63 #define CFWCR  0x5c /* Firewall operation control register */
64 #define CLFCR  0x60 /* Capture low-pass filter control register */
65 #define CDOCR  0x64 /* Capture data output control register */
66 #define CDDCR  0x68 /* Capture data complexity level register */
67 #define CDDAR  0x6c /* Capture data complexity level address register */
68 #define CEIER  0x70 /* Capture event interrupt enable register */
69 #define CETCR  0x74 /* Capture event flag clear register */
70 #define CSTSR  0x7c /* Capture status register */
71 #define CSRTR  0x80 /* Capture software reset register */
72 #define CDSSR  0x84 /* Capture data size register */
73 #define CDAYR2 0x90 /* Capture data address Y register 2 */
74 #define CDACR2 0x94 /* Capture data address C register 2 */
75 #define CDBYR2 0x98 /* Capture data bottom-field address Y register 2 */
76 #define CDBCR2 0x9c /* Capture data bottom-field address C register 2 */
77
78 static DEFINE_MUTEX(camera_lock);
79
80 /* per video frame buffer */
81 struct sh_mobile_ceu_buffer {
82         struct videobuf_buffer vb; /* v4l buffer must be first */
83         const struct soc_camera_data_format *fmt;
84 };
85
86 struct sh_mobile_ceu_dev {
87         struct device *dev;
88         struct soc_camera_host ici;
89         struct soc_camera_device *icd;
90
91         unsigned int irq;
92         void __iomem *base;
93         struct clk *clk;
94         unsigned long video_limit;
95
96         /* lock used to protect videobuf */
97         spinlock_t lock;
98         struct list_head capture;
99         struct videobuf_buffer *active;
100
101         struct sh_mobile_ceu_info *pdata;
102 };
103
104 static void ceu_write(struct sh_mobile_ceu_dev *priv,
105                       unsigned long reg_offs, unsigned long data)
106 {
107         iowrite32(data, priv->base + reg_offs);
108 }
109
110 static unsigned long ceu_read(struct sh_mobile_ceu_dev *priv,
111                               unsigned long reg_offs)
112 {
113         return ioread32(priv->base + reg_offs);
114 }
115
116 /*
117  *  Videobuf operations
118  */
119 static int sh_mobile_ceu_videobuf_setup(struct videobuf_queue *vq,
120                                         unsigned int *count,
121                                         unsigned int *size)
122 {
123         struct soc_camera_device *icd = vq->priv_data;
124         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
125         struct sh_mobile_ceu_dev *pcdev = ici->priv;
126         int bytes_per_pixel = (icd->current_fmt->depth + 7) >> 3;
127
128         *size = PAGE_ALIGN(icd->width * icd->height * bytes_per_pixel);
129
130         if (0 == *count)
131                 *count = 2;
132
133         if (pcdev->video_limit) {
134                 while (*size * *count > pcdev->video_limit)
135                         (*count)--;
136         }
137
138         dev_dbg(&icd->dev, "count=%d, size=%d\n", *count, *size);
139
140         return 0;
141 }
142
143 static void free_buffer(struct videobuf_queue *vq,
144                         struct sh_mobile_ceu_buffer *buf)
145 {
146         struct soc_camera_device *icd = vq->priv_data;
147
148         dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
149                 &buf->vb, buf->vb.baddr, buf->vb.bsize);
150
151         if (in_interrupt())
152                 BUG();
153
154         videobuf_dma_contig_free(vq, &buf->vb);
155         dev_dbg(&icd->dev, "%s freed\n", __func__);
156         buf->vb.state = VIDEOBUF_NEEDS_INIT;
157 }
158
159 static void sh_mobile_ceu_capture(struct sh_mobile_ceu_dev *pcdev)
160 {
161         ceu_write(pcdev, CEIER, ceu_read(pcdev, CEIER) & ~1);
162         ceu_write(pcdev, CETCR, ~ceu_read(pcdev, CETCR) & 0x0317f313);
163         ceu_write(pcdev, CEIER, ceu_read(pcdev, CEIER) | 1);
164
165         ceu_write(pcdev, CAPCR, ceu_read(pcdev, CAPCR) & ~0x10000);
166
167         ceu_write(pcdev, CETCR, 0x0317f313 ^ 0x10);
168
169         if (pcdev->active) {
170                 pcdev->active->state = VIDEOBUF_ACTIVE;
171                 ceu_write(pcdev, CDAYR, videobuf_to_dma_contig(pcdev->active));
172                 ceu_write(pcdev, CAPSR, 0x1); /* start capture */
173         }
174 }
175
176 static int sh_mobile_ceu_videobuf_prepare(struct videobuf_queue *vq,
177                                           struct videobuf_buffer *vb,
178                                           enum v4l2_field field)
179 {
180         struct soc_camera_device *icd = vq->priv_data;
181         struct sh_mobile_ceu_buffer *buf;
182         int ret;
183
184         buf = container_of(vb, struct sh_mobile_ceu_buffer, vb);
185
186         dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
187                 vb, vb->baddr, vb->bsize);
188
189         /* Added list head initialization on alloc */
190         WARN_ON(!list_empty(&vb->queue));
191
192 #ifdef DEBUG
193         /* This can be useful if you want to see if we actually fill
194          * the buffer with something */
195         memset((void *)vb->baddr, 0xaa, vb->bsize);
196 #endif
197
198         BUG_ON(NULL == icd->current_fmt);
199
200         if (buf->fmt    != icd->current_fmt ||
201             vb->width   != icd->width ||
202             vb->height  != icd->height ||
203             vb->field   != field) {
204                 buf->fmt        = icd->current_fmt;
205                 vb->width       = icd->width;
206                 vb->height      = icd->height;
207                 vb->field       = field;
208                 vb->state       = VIDEOBUF_NEEDS_INIT;
209         }
210
211         vb->size = vb->width * vb->height * ((buf->fmt->depth + 7) >> 3);
212         if (0 != vb->baddr && vb->bsize < vb->size) {
213                 ret = -EINVAL;
214                 goto out;
215         }
216
217         if (vb->state == VIDEOBUF_NEEDS_INIT) {
218                 ret = videobuf_iolock(vq, vb, NULL);
219                 if (ret)
220                         goto fail;
221                 vb->state = VIDEOBUF_PREPARED;
222         }
223
224         return 0;
225 fail:
226         free_buffer(vq, buf);
227 out:
228         return ret;
229 }
230
231 static void sh_mobile_ceu_videobuf_queue(struct videobuf_queue *vq,
232                                          struct videobuf_buffer *vb)
233 {
234         struct soc_camera_device *icd = vq->priv_data;
235         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
236         struct sh_mobile_ceu_dev *pcdev = ici->priv;
237         unsigned long flags;
238
239         dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %zd\n", __func__,
240                 vb, vb->baddr, vb->bsize);
241
242         vb->state = VIDEOBUF_QUEUED;
243         spin_lock_irqsave(&pcdev->lock, flags);
244         list_add_tail(&vb->queue, &pcdev->capture);
245
246         if (!pcdev->active) {
247                 pcdev->active = vb;
248                 sh_mobile_ceu_capture(pcdev);
249         }
250
251         spin_unlock_irqrestore(&pcdev->lock, flags);
252 }
253
254 static void sh_mobile_ceu_videobuf_release(struct videobuf_queue *vq,
255                                            struct videobuf_buffer *vb)
256 {
257         free_buffer(vq, container_of(vb, struct sh_mobile_ceu_buffer, vb));
258 }
259
260 static struct videobuf_queue_ops sh_mobile_ceu_videobuf_ops = {
261         .buf_setup      = sh_mobile_ceu_videobuf_setup,
262         .buf_prepare    = sh_mobile_ceu_videobuf_prepare,
263         .buf_queue      = sh_mobile_ceu_videobuf_queue,
264         .buf_release    = sh_mobile_ceu_videobuf_release,
265 };
266
267 static irqreturn_t sh_mobile_ceu_irq(int irq, void *data)
268 {
269         struct sh_mobile_ceu_dev *pcdev = data;
270         struct videobuf_buffer *vb;
271         unsigned long flags;
272
273         spin_lock_irqsave(&pcdev->lock, flags);
274
275         vb = pcdev->active;
276         list_del_init(&vb->queue);
277
278         if (!list_empty(&pcdev->capture))
279                 pcdev->active = list_entry(pcdev->capture.next,
280                                            struct videobuf_buffer, queue);
281         else
282                 pcdev->active = NULL;
283
284         sh_mobile_ceu_capture(pcdev);
285
286         vb->state = VIDEOBUF_DONE;
287         do_gettimeofday(&vb->ts);
288         vb->field_count++;
289         wake_up(&vb->done);
290         spin_unlock_irqrestore(&pcdev->lock, flags);
291
292         return IRQ_HANDLED;
293 }
294
295 static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
296 {
297         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
298         struct sh_mobile_ceu_dev *pcdev = ici->priv;
299         int ret = -EBUSY;
300
301         mutex_lock(&camera_lock);
302
303         if (pcdev->icd)
304                 goto err;
305
306         dev_info(&icd->dev,
307                  "SuperH Mobile CEU driver attached to camera %d\n",
308                  icd->devnum);
309
310         ret = icd->ops->init(icd);
311         if (ret)
312                 goto err;
313
314         clk_enable(pcdev->clk);
315
316         ceu_write(pcdev, CAPSR, 1 << 16); /* reset */
317         while (ceu_read(pcdev, CSTSR) & 1)
318                 msleep(1);
319
320         pcdev->icd = icd;
321 err:
322         mutex_unlock(&camera_lock);
323
324         return ret;
325 }
326
327 static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
328 {
329         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
330         struct sh_mobile_ceu_dev *pcdev = ici->priv;
331         unsigned long flags;
332
333         BUG_ON(icd != pcdev->icd);
334
335         /* disable capture, disable interrupts */
336         ceu_write(pcdev, CEIER, 0);
337         ceu_write(pcdev, CAPSR, 1 << 16); /* reset */
338
339         /* make sure active buffer is canceled */
340         spin_lock_irqsave(&pcdev->lock, flags);
341         if (pcdev->active) {
342                 list_del(&pcdev->active->queue);
343                 pcdev->active->state = VIDEOBUF_ERROR;
344                 wake_up_all(&pcdev->active->done);
345                 pcdev->active = NULL;
346         }
347         spin_unlock_irqrestore(&pcdev->lock, flags);
348
349         clk_disable(pcdev->clk);
350
351         icd->ops->release(icd);
352
353         dev_info(&icd->dev,
354                  "SuperH Mobile CEU driver detached from camera %d\n",
355                  icd->devnum);
356
357         pcdev->icd = NULL;
358 }
359
360 static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
361                                        __u32 pixfmt)
362 {
363         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
364         struct sh_mobile_ceu_dev *pcdev = ici->priv;
365         int ret, buswidth, width, cfszr_width, cdwdr_width;
366         unsigned long camera_flags, common_flags, value;
367
368         camera_flags = icd->ops->query_bus_param(icd);
369         common_flags = soc_camera_bus_param_compatible(camera_flags,
370                                                        pcdev->pdata->flags);
371         if (!common_flags)
372                 return -EINVAL;
373
374         ret = icd->ops->set_bus_param(icd, common_flags);
375         if (ret < 0)
376                 return ret;
377
378         switch (common_flags & SOCAM_DATAWIDTH_MASK) {
379         case SOCAM_DATAWIDTH_8:
380                 buswidth = 8;
381                 break;
382         case SOCAM_DATAWIDTH_16:
383                 buswidth = 16;
384                 break;
385         default:
386                 return -EINVAL;
387         }
388
389         ceu_write(pcdev, CRCNTR, 0);
390         ceu_write(pcdev, CRCMPR, 0);
391
392         value = 0x00000010;
393         value |= (common_flags & SOCAM_VSYNC_ACTIVE_LOW) ? (1 << 1) : 0;
394         value |= (common_flags & SOCAM_HSYNC_ACTIVE_LOW) ? (1 << 0) : 0;
395         value |= (buswidth == 16) ? (1 << 12) : 0;
396         ceu_write(pcdev, CAMCR, value);
397
398         ceu_write(pcdev, CAPCR, 0x00300000);
399         ceu_write(pcdev, CAIFR, 0);
400
401         mdelay(1);
402
403         width = icd->width * (icd->current_fmt->depth / 8);
404         width = (buswidth == 16) ? width / 2 : width;
405         cfszr_width = (buswidth == 8) ? width / 2 : width;
406         cdwdr_width = (buswidth == 16) ? width * 2 : width;
407
408         ceu_write(pcdev, CAMOR, 0);
409         ceu_write(pcdev, CAPWR, (icd->height << 16) | width);
410         ceu_write(pcdev, CFLCR, 0); /* data fetch mode - no scaling */
411         ceu_write(pcdev, CFSZR, (icd->height << 16) | cfszr_width);
412         ceu_write(pcdev, CLFCR, 0); /* data fetch mode - no lowpass filter */
413
414         /* A few words about byte order (observed in Big Endian mode)
415          *
416          * In data fetch mode bytes are received in chunks of 8 bytes.
417          * D0, D1, D2, D3, D4, D5, D6, D7 (D0 received first)
418          *
419          * The data is however by default written to memory in reverse order:
420          * D7, D6, D5, D4, D3, D2, D1, D0 (D7 written to lowest byte)
421          *
422          * The lowest three bits of CDOCR allows us to do swapping,
423          * using 7 we swap the data bytes to match the incoming order:
424          * D0, D1, D2, D3, D4, D5, D6, D7
425          */
426         ceu_write(pcdev, CDOCR, 0x00000017);
427
428         ceu_write(pcdev, CDWDR, cdwdr_width);
429         ceu_write(pcdev, CFWCR, 0); /* keep "datafetch firewall" disabled */
430
431         /* not in bundle mode: skip CBDSR, CDAYR2, CDACR2, CDBYR2, CDBCR2 */
432         /* in data fetch mode: no need for CDACR, CDBYR, CDBCR */
433
434         return 0;
435 }
436
437 static int sh_mobile_ceu_try_bus_param(struct soc_camera_device *icd,
438                                        __u32 pixfmt)
439 {
440         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
441         struct sh_mobile_ceu_dev *pcdev = ici->priv;
442         unsigned long camera_flags, common_flags;
443
444         camera_flags = icd->ops->query_bus_param(icd);
445         common_flags = soc_camera_bus_param_compatible(camera_flags,
446                                                        pcdev->pdata->flags);
447         if (!common_flags)
448                 return -EINVAL;
449
450         return 0;
451 }
452
453 static int sh_mobile_ceu_set_fmt_cap(struct soc_camera_device *icd,
454                                      __u32 pixfmt, struct v4l2_rect *rect)
455 {
456         return icd->ops->set_fmt_cap(icd, pixfmt, rect);
457 }
458
459 static int sh_mobile_ceu_try_fmt_cap(struct soc_camera_device *icd,
460                                      struct v4l2_format *f)
461 {
462         /* FIXME: calculate using depth and bus width */
463
464         if (f->fmt.pix.height < 4)
465                 f->fmt.pix.height = 4;
466         if (f->fmt.pix.height > 1920)
467                 f->fmt.pix.height = 1920;
468         if (f->fmt.pix.width < 2)
469                 f->fmt.pix.width = 2;
470         if (f->fmt.pix.width > 2560)
471                 f->fmt.pix.width = 2560;
472         f->fmt.pix.width &= ~0x01;
473         f->fmt.pix.height &= ~0x03;
474
475         /* limit to sensor capabilities */
476         return icd->ops->try_fmt_cap(icd, f);
477 }
478
479 static int sh_mobile_ceu_reqbufs(struct soc_camera_file *icf,
480                                  struct v4l2_requestbuffers *p)
481 {
482         int i;
483
484         /* This is for locking debugging only. I removed spinlocks and now I
485          * check whether .prepare is ever called on a linked buffer, or whether
486          * a dma IRQ can occur for an in-work or unlinked buffer. Until now
487          * it hadn't triggered */
488         for (i = 0; i < p->count; i++) {
489                 struct sh_mobile_ceu_buffer *buf;
490
491                 buf = container_of(icf->vb_vidq.bufs[i],
492                                    struct sh_mobile_ceu_buffer, vb);
493                 INIT_LIST_HEAD(&buf->vb.queue);
494         }
495
496         return 0;
497 }
498
499 static unsigned int sh_mobile_ceu_poll(struct file *file, poll_table *pt)
500 {
501         struct soc_camera_file *icf = file->private_data;
502         struct sh_mobile_ceu_buffer *buf;
503
504         buf = list_entry(icf->vb_vidq.stream.next,
505                          struct sh_mobile_ceu_buffer, vb.stream);
506
507         poll_wait(file, &buf->vb.done, pt);
508
509         if (buf->vb.state == VIDEOBUF_DONE ||
510             buf->vb.state == VIDEOBUF_ERROR)
511                 return POLLIN|POLLRDNORM;
512
513         return 0;
514 }
515
516 static int sh_mobile_ceu_querycap(struct soc_camera_host *ici,
517                                   struct v4l2_capability *cap)
518 {
519         strlcpy(cap->card, "SuperH_Mobile_CEU", sizeof(cap->card));
520         cap->version = KERNEL_VERSION(0, 0, 5);
521         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
522         return 0;
523 }
524
525 static void sh_mobile_ceu_init_videobuf(struct videobuf_queue *q,
526                                         struct soc_camera_device *icd)
527 {
528         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
529         struct sh_mobile_ceu_dev *pcdev = ici->priv;
530
531         videobuf_queue_dma_contig_init(q,
532                                        &sh_mobile_ceu_videobuf_ops,
533                                        &ici->dev, &pcdev->lock,
534                                        V4L2_BUF_TYPE_VIDEO_CAPTURE,
535                                        V4L2_FIELD_NONE,
536                                        sizeof(struct sh_mobile_ceu_buffer),
537                                        icd);
538 }
539
540 static struct soc_camera_host_ops sh_mobile_ceu_host_ops = {
541         .owner          = THIS_MODULE,
542         .add            = sh_mobile_ceu_add_device,
543         .remove         = sh_mobile_ceu_remove_device,
544         .set_fmt_cap    = sh_mobile_ceu_set_fmt_cap,
545         .try_fmt_cap    = sh_mobile_ceu_try_fmt_cap,
546         .reqbufs        = sh_mobile_ceu_reqbufs,
547         .poll           = sh_mobile_ceu_poll,
548         .querycap       = sh_mobile_ceu_querycap,
549         .try_bus_param  = sh_mobile_ceu_try_bus_param,
550         .set_bus_param  = sh_mobile_ceu_set_bus_param,
551         .init_videobuf  = sh_mobile_ceu_init_videobuf,
552 };
553
554 static int sh_mobile_ceu_probe(struct platform_device *pdev)
555 {
556         struct sh_mobile_ceu_dev *pcdev;
557         struct resource *res;
558         void __iomem *base;
559         char clk_name[8];
560         unsigned int irq;
561         int err = 0;
562
563         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
564         irq = platform_get_irq(pdev, 0);
565         if (!res || !irq) {
566                 dev_err(&pdev->dev, "Not enough CEU platform resources.\n");
567                 err = -ENODEV;
568                 goto exit;
569         }
570
571         pcdev = kzalloc(sizeof(*pcdev), GFP_KERNEL);
572         if (!pcdev) {
573                 dev_err(&pdev->dev, "Could not allocate pcdev\n");
574                 err = -ENOMEM;
575                 goto exit;
576         }
577
578         platform_set_drvdata(pdev, pcdev);
579         INIT_LIST_HEAD(&pcdev->capture);
580         spin_lock_init(&pcdev->lock);
581
582         pcdev->pdata = pdev->dev.platform_data;
583         if (!pcdev->pdata) {
584                 err = -EINVAL;
585                 dev_err(&pdev->dev, "CEU platform data not set.\n");
586                 goto exit_kfree;
587         }
588
589         base = ioremap_nocache(res->start, res->end - res->start + 1);
590         if (!base) {
591                 err = -ENXIO;
592                 dev_err(&pdev->dev, "Unable to ioremap CEU registers.\n");
593                 goto exit_kfree;
594         }
595
596         pcdev->irq = irq;
597         pcdev->base = base;
598         pcdev->video_limit = 0; /* only enabled if second resource exists */
599         pcdev->dev = &pdev->dev;
600
601         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
602         if (res) {
603                 err = dma_declare_coherent_memory(&pdev->dev, res->start,
604                                                   res->start,
605                                                   (res->end - res->start) + 1,
606                                                   DMA_MEMORY_MAP |
607                                                   DMA_MEMORY_EXCLUSIVE);
608                 if (!err) {
609                         dev_err(&pdev->dev, "Unable to declare CEU memory.\n");
610                         err = -ENXIO;
611                         goto exit_iounmap;
612                 }
613
614                 pcdev->video_limit = (res->end - res->start) + 1;
615         }
616
617         /* request irq */
618         err = request_irq(pcdev->irq, sh_mobile_ceu_irq, IRQF_DISABLED,
619                           pdev->dev.bus_id, pcdev);
620         if (err) {
621                 dev_err(&pdev->dev, "Unable to register CEU interrupt.\n");
622                 goto exit_release_mem;
623         }
624
625         snprintf(clk_name, sizeof(clk_name), "ceu%d", pdev->id);
626         pcdev->clk = clk_get(&pdev->dev, clk_name);
627         if (IS_ERR(pcdev->clk)) {
628                 dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
629                 err = PTR_ERR(pcdev->clk);
630                 goto exit_free_irq;
631         }
632
633         pcdev->ici.priv = pcdev;
634         pcdev->ici.dev.parent = &pdev->dev;
635         pcdev->ici.nr = pdev->id;
636         pcdev->ici.drv_name = pdev->dev.bus_id,
637         pcdev->ici.ops = &sh_mobile_ceu_host_ops,
638
639         err = soc_camera_host_register(&pcdev->ici);
640         if (err)
641                 goto exit_free_clk;
642
643         return 0;
644
645 exit_free_clk:
646         clk_put(pcdev->clk);
647 exit_free_irq:
648         free_irq(pcdev->irq, pcdev);
649 exit_release_mem:
650         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
651                 dma_release_declared_memory(&pdev->dev);
652 exit_iounmap:
653         iounmap(base);
654 exit_kfree:
655         kfree(pcdev);
656 exit:
657         return err;
658 }
659
660 static int sh_mobile_ceu_remove(struct platform_device *pdev)
661 {
662         struct sh_mobile_ceu_dev *pcdev = platform_get_drvdata(pdev);
663
664         soc_camera_host_unregister(&pcdev->ici);
665         clk_put(pcdev->clk);
666         free_irq(pcdev->irq, pcdev);
667         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
668                 dma_release_declared_memory(&pdev->dev);
669         iounmap(pcdev->base);
670         kfree(pcdev);
671         return 0;
672 }
673
674 static struct platform_driver sh_mobile_ceu_driver = {
675         .driver         = {
676                 .name   = "sh_mobile_ceu",
677         },
678         .probe          = sh_mobile_ceu_probe,
679         .remove         = sh_mobile_ceu_remove,
680 };
681
682 static int __init sh_mobile_ceu_init(void)
683 {
684         return platform_driver_register(&sh_mobile_ceu_driver);
685 }
686
687 static void __exit sh_mobile_ceu_exit(void)
688 {
689         platform_driver_unregister(&sh_mobile_ceu_driver);
690 }
691
692 module_init(sh_mobile_ceu_init);
693 module_exit(sh_mobile_ceu_exit);
694
695 MODULE_DESCRIPTION("SuperH Mobile CEU driver");
696 MODULE_AUTHOR("Magnus Damm");
697 MODULE_LICENSE("GPL");