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