1
2
3
4
5
6
7
8
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/device.h>
12#include <linux/list.h>
13#include <linux/pci.h>
14#include <linux/gpio.h>
15#include <linux/interrupt.h>
16#include <linux/platform_device.h>
17#include <linux/videodev2.h>
18#include <media/v4l2-device.h>
19#include <media/v4l2-ioctl.h>
20#include <media/v4l2-ctrls.h>
21#include <media/v4l2-image-sizes.h>
22#include <media/ov7670.h>
23#include <media/videobuf-dma-sg.h>
24#include <linux/delay.h>
25#include <linux/dma-mapping.h>
26#include <linux/pm_qos.h>
27#include <linux/via-core.h>
28#include <linux/via-gpio.h>
29#include <linux/via_i2c.h>
30#include <asm/olpc.h>
31
32#include "via-camera.h"
33
34MODULE_ALIAS("platform:viafb-camera");
35MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
36MODULE_DESCRIPTION("VIA framebuffer-based camera controller driver");
37MODULE_LICENSE("GPL");
38
39static bool flip_image;
40module_param(flip_image, bool, 0444);
41MODULE_PARM_DESC(flip_image,
42 "If set, the sensor will be instructed to flip the image "
43 "vertically.");
44
45static bool override_serial;
46module_param(override_serial, bool, 0444);
47MODULE_PARM_DESC(override_serial,
48 "The camera driver will normally refuse to load if "
49 "the XO 1.5 serial port is enabled. Set this option "
50 "to force-enable the camera.");
51
52
53
54
55enum viacam_opstate { S_IDLE = 0, S_RUNNING = 1 };
56
57struct via_camera {
58 struct v4l2_device v4l2_dev;
59 struct v4l2_ctrl_handler ctrl_handler;
60 struct video_device vdev;
61 struct v4l2_subdev *sensor;
62 struct platform_device *platdev;
63 struct viafb_dev *viadev;
64 struct mutex lock;
65 enum viacam_opstate opstate;
66 unsigned long flags;
67 struct pm_qos_request qos_request;
68
69
70
71 int power_gpio;
72 int reset_gpio;
73
74
75
76 void __iomem *mmio;
77 void __iomem *fbmem;
78 u32 fb_offset;
79
80
81
82
83
84 unsigned int cb_offsets[3];
85 u8 __iomem *cb_addrs[3];
86 int n_cap_bufs;
87 int next_buf;
88 struct videobuf_queue vb_queue;
89 struct list_head buffer_queue;
90
91
92
93 int users;
94 struct file *owner;
95
96
97
98
99
100
101
102 struct v4l2_pix_format sensor_format;
103 struct v4l2_pix_format user_format;
104 u32 mbus_code;
105};
106
107
108
109
110
111static struct via_camera *via_cam_info;
112
113
114
115
116#define CF_DMA_ACTIVE 0
117#define CF_CONFIG_NEEDED 1
118
119
120
121
122
123#define sensor_call(cam, optype, func, args...) \
124 v4l2_subdev_call(cam->sensor, optype, func, ##args)
125
126
127
128
129#define cam_err(cam, fmt, arg...) \
130 dev_err(&(cam)->platdev->dev, fmt, ##arg);
131#define cam_warn(cam, fmt, arg...) \
132 dev_warn(&(cam)->platdev->dev, fmt, ##arg);
133#define cam_dbg(cam, fmt, arg...) \
134 dev_dbg(&(cam)->platdev->dev, fmt, ##arg);
135
136
137
138
139
140
141
142static struct via_format {
143 __u8 *desc;
144 __u32 pixelformat;
145 int bpp;
146 u32 mbus_code;
147} via_formats[] = {
148 {
149 .desc = "YUYV 4:2:2",
150 .pixelformat = V4L2_PIX_FMT_YUYV,
151 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
152 .bpp = 2,
153 },
154
155
156
157
158};
159#define N_VIA_FMTS ARRAY_SIZE(via_formats)
160
161static struct via_format *via_find_format(u32 pixelformat)
162{
163 unsigned i;
164
165 for (i = 0; i < N_VIA_FMTS; i++)
166 if (via_formats[i].pixelformat == pixelformat)
167 return via_formats + i;
168
169 return via_formats;
170}
171
172
173
174
175
176
177
178static int via_sensor_power_setup(struct via_camera *cam)
179{
180 int ret;
181
182 cam->power_gpio = viafb_gpio_lookup("VGPIO3");
183 cam->reset_gpio = viafb_gpio_lookup("VGPIO2");
184 if (cam->power_gpio < 0 || cam->reset_gpio < 0) {
185 dev_err(&cam->platdev->dev, "Unable to find GPIO lines\n");
186 return -EINVAL;
187 }
188 ret = gpio_request(cam->power_gpio, "viafb-camera");
189 if (ret) {
190 dev_err(&cam->platdev->dev, "Unable to request power GPIO\n");
191 return ret;
192 }
193 ret = gpio_request(cam->reset_gpio, "viafb-camera");
194 if (ret) {
195 dev_err(&cam->platdev->dev, "Unable to request reset GPIO\n");
196 gpio_free(cam->power_gpio);
197 return ret;
198 }
199 gpio_direction_output(cam->power_gpio, 0);
200 gpio_direction_output(cam->reset_gpio, 0);
201 return 0;
202}
203
204
205
206
207static void via_sensor_power_up(struct via_camera *cam)
208{
209 gpio_set_value(cam->power_gpio, 1);
210 gpio_set_value(cam->reset_gpio, 0);
211 msleep(20);
212 gpio_set_value(cam->reset_gpio, 1);
213 msleep(20);
214}
215
216static void via_sensor_power_down(struct via_camera *cam)
217{
218 gpio_set_value(cam->power_gpio, 0);
219 gpio_set_value(cam->reset_gpio, 0);
220}
221
222
223static void via_sensor_power_release(struct via_camera *cam)
224{
225 via_sensor_power_down(cam);
226 gpio_free(cam->power_gpio);
227 gpio_free(cam->reset_gpio);
228}
229
230
231
232
233
234
235
236static int viacam_set_flip(struct via_camera *cam)
237{
238 struct v4l2_control ctrl;
239
240 memset(&ctrl, 0, sizeof(ctrl));
241 ctrl.id = V4L2_CID_VFLIP;
242 ctrl.value = flip_image;
243 return sensor_call(cam, core, s_ctrl, &ctrl);
244}
245
246
247
248
249
250static int viacam_configure_sensor(struct via_camera *cam)
251{
252 struct v4l2_mbus_framefmt mbus_fmt;
253 int ret;
254
255 v4l2_fill_mbus_format(&mbus_fmt, &cam->sensor_format, cam->mbus_code);
256 ret = sensor_call(cam, core, init, 0);
257 if (ret == 0)
258 ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt);
259
260
261
262 if (ret == 0)
263 ret = viacam_set_flip(cam);
264 return ret;
265}
266
267
268
269
270
271
272
273
274
275
276
277static inline void viacam_write_reg(struct via_camera *cam,
278 int reg, int value)
279{
280 iowrite32(value, cam->mmio + reg);
281}
282
283static inline int viacam_read_reg(struct via_camera *cam, int reg)
284{
285 return ioread32(cam->mmio + reg);
286}
287
288static inline void viacam_write_reg_mask(struct via_camera *cam,
289 int reg, int value, int mask)
290{
291 int tmp = viacam_read_reg(cam, reg);
292
293 tmp = (tmp & ~mask) | (value & mask);
294 viacam_write_reg(cam, reg, tmp);
295}
296
297
298
299
300
301static irqreturn_t viacam_quick_irq(int irq, void *data)
302{
303 struct via_camera *cam = data;
304 irqreturn_t ret = IRQ_NONE;
305 int icv;
306
307
308
309
310
311 spin_lock(&cam->viadev->reg_lock);
312 icv = viacam_read_reg(cam, VCR_INTCTRL);
313 if (icv & VCR_IC_EAV) {
314 icv |= VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL;
315 viacam_write_reg(cam, VCR_INTCTRL, icv);
316 ret = IRQ_WAKE_THREAD;
317 }
318 spin_unlock(&cam->viadev->reg_lock);
319 return ret;
320}
321
322
323
324
325static struct videobuf_buffer *viacam_next_buffer(struct via_camera *cam)
326{
327 unsigned long flags;
328 struct videobuf_buffer *buf = NULL;
329
330 spin_lock_irqsave(&cam->viadev->reg_lock, flags);
331 if (cam->opstate != S_RUNNING)
332 goto out;
333 if (list_empty(&cam->buffer_queue))
334 goto out;
335 buf = list_entry(cam->buffer_queue.next, struct videobuf_buffer, queue);
336 if (!waitqueue_active(&buf->done)) {
337 buf = NULL;
338 goto out;
339 }
340 list_del(&buf->queue);
341 buf->state = VIDEOBUF_ACTIVE;
342out:
343 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags);
344 return buf;
345}
346
347
348
349
350static irqreturn_t viacam_irq(int irq, void *data)
351{
352 int bufn;
353 struct videobuf_buffer *vb;
354 struct via_camera *cam = data;
355 struct videobuf_dmabuf *vdma;
356
357
358
359
360
361 vb = viacam_next_buffer(cam);
362 if (vb == NULL)
363 goto done;
364
365
366
367 bufn = (viacam_read_reg(cam, VCR_INTCTRL) & VCR_IC_ACTBUF) >> 3;
368 bufn -= 1;
369 if (bufn < 0)
370 bufn = cam->n_cap_bufs - 1;
371
372
373
374 vdma = videobuf_to_dma(vb);
375 viafb_dma_copy_out_sg(cam->cb_offsets[bufn], vdma->sglist, vdma->sglen);
376 vb->state = VIDEOBUF_DONE;
377 vb->size = cam->user_format.sizeimage;
378 wake_up(&vb->done);
379done:
380 return IRQ_HANDLED;
381}
382
383
384
385
386
387
388
389
390
391static void viacam_int_enable(struct via_camera *cam)
392{
393 viacam_write_reg(cam, VCR_INTCTRL,
394 VCR_IC_INTEN|VCR_IC_EAV|VCR_IC_EVBI|VCR_IC_FFULL);
395 viafb_irq_enable(VDE_I_C0AVEN);
396}
397
398static void viacam_int_disable(struct via_camera *cam)
399{
400 viafb_irq_disable(VDE_I_C0AVEN);
401 viacam_write_reg(cam, VCR_INTCTRL, 0);
402}
403
404
405
406
407
408
409
410
411
412static int viacam_ctlr_cbufs(struct via_camera *cam)
413{
414 int nbuf = cam->viadev->camera_fbmem_size/cam->sensor_format.sizeimage;
415 int i;
416 unsigned int offset;
417
418
419
420
421 if (nbuf >= 3) {
422 cam->n_cap_bufs = 3;
423 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_3BUFS,
424 VCR_CI_3BUFS);
425 } else if (nbuf == 2) {
426 cam->n_cap_bufs = 2;
427 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_3BUFS);
428 } else {
429 cam_warn(cam, "Insufficient frame buffer memory\n");
430 return -ENOMEM;
431 }
432
433
434
435 offset = cam->fb_offset;
436 for (i = 0; i < cam->n_cap_bufs; i++) {
437 cam->cb_offsets[i] = offset;
438 cam->cb_addrs[i] = cam->fbmem + offset;
439 viacam_write_reg(cam, VCR_VBUF1 + i*4, offset & VCR_VBUF_MASK);
440 offset += cam->sensor_format.sizeimage;
441 }
442 return 0;
443}
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462static void viacam_set_scale(struct via_camera *cam)
463{
464 unsigned int avscale;
465 int sf;
466
467 if (cam->user_format.width == VGA_WIDTH)
468 avscale = 0;
469 else {
470 sf = (cam->user_format.width*2048)/VGA_WIDTH;
471 avscale = VCR_AVS_HEN | sf;
472 }
473 if (cam->user_format.height < VGA_HEIGHT) {
474 sf = (1024*cam->user_format.height)/VGA_HEIGHT;
475 avscale |= VCR_AVS_VEN | (sf << 16);
476 }
477 viacam_write_reg(cam, VCR_AVSCALE, avscale);
478}
479
480
481
482
483
484static void viacam_ctlr_image(struct via_camera *cam)
485{
486 int cicreg;
487
488
489
490
491
492 viacam_write_reg(cam, VCR_CAPINTC, ~(VCR_CI_ENABLE|VCR_CI_CLKEN));
493
494
495
496
497 viacam_write_reg(cam, VCR_HORRANGE, 0x06200120);
498 viacam_write_reg(cam, VCR_VERTRANGE, 0x01de0000);
499 viacam_set_scale(cam);
500
501
502
503 viacam_write_reg(cam, VCR_MAXDATA,
504 (cam->sensor_format.height << 16) |
505 (cam->sensor_format.bytesperline >> 3));
506 viacam_write_reg(cam, VCR_MAXVBI, 0);
507 viacam_write_reg(cam, VCR_VSTRIDE,
508 cam->user_format.bytesperline & VCR_VS_STRIDE);
509
510
511
512
513
514
515
516 cicreg = VCR_CI_CLKEN |
517 0x08000000 |
518 VCR_CI_FLDINV |
519 VCR_CI_VREFINV |
520 VCR_CI_DIBOTH |
521 VCR_CI_CCIR601_8;
522 if (cam->n_cap_bufs == 3)
523 cicreg |= VCR_CI_3BUFS;
524
525
526
527 if (cam->user_format.pixelformat == V4L2_PIX_FMT_YUYV)
528 cicreg |= VCR_CI_YUYV;
529 else
530 cicreg |= VCR_CI_UYVY;
531 viacam_write_reg(cam, VCR_CAPINTC, cicreg);
532}
533
534
535static int viacam_config_controller(struct via_camera *cam)
536{
537 int ret;
538 unsigned long flags;
539
540 spin_lock_irqsave(&cam->viadev->reg_lock, flags);
541 ret = viacam_ctlr_cbufs(cam);
542 if (!ret)
543 viacam_ctlr_image(cam);
544 spin_unlock_irqrestore(&cam->viadev->reg_lock, flags);
545 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
546 return ret;
547}
548
549
550
551
552static void viacam_start_engine(struct via_camera *cam)
553{
554 spin_lock_irq(&cam->viadev->reg_lock);
555 cam->next_buf = 0;
556 viacam_write_reg_mask(cam, VCR_CAPINTC, VCR_CI_ENABLE, VCR_CI_ENABLE);
557 viacam_int_enable(cam);
558 (void) viacam_read_reg(cam, VCR_CAPINTC);
559 cam->opstate = S_RUNNING;
560 spin_unlock_irq(&cam->viadev->reg_lock);
561}
562
563
564static void viacam_stop_engine(struct via_camera *cam)
565{
566 spin_lock_irq(&cam->viadev->reg_lock);
567 viacam_int_disable(cam);
568 viacam_write_reg_mask(cam, VCR_CAPINTC, 0, VCR_CI_ENABLE);
569 (void) viacam_read_reg(cam, VCR_CAPINTC);
570 cam->opstate = S_IDLE;
571 spin_unlock_irq(&cam->viadev->reg_lock);
572}
573
574
575
576
577
578
579
580
581
582
583static int viacam_vb_buf_setup(struct videobuf_queue *q,
584 unsigned int *count, unsigned int *size)
585{
586 struct via_camera *cam = q->priv_data;
587
588 *size = cam->user_format.sizeimage;
589 if (*count == 0 || *count > 6)
590 *count = 6;
591 return 0;
592}
593
594
595
596
597static int viacam_vb_buf_prepare(struct videobuf_queue *q,
598 struct videobuf_buffer *vb, enum v4l2_field field)
599{
600 struct via_camera *cam = q->priv_data;
601
602 vb->size = cam->user_format.sizeimage;
603 vb->width = cam->user_format.width;
604 vb->height = cam->user_format.height;
605 vb->field = field;
606 if (vb->state == VIDEOBUF_NEEDS_INIT) {
607 int ret = videobuf_iolock(q, vb, NULL);
608 if (ret)
609 return ret;
610 }
611 vb->state = VIDEOBUF_PREPARED;
612 return 0;
613}
614
615
616
617
618
619
620static void viacam_vb_buf_queue(struct videobuf_queue *q,
621 struct videobuf_buffer *vb)
622{
623 struct via_camera *cam = q->priv_data;
624
625
626
627
628
629 vb->state = VIDEOBUF_QUEUED;
630 list_add_tail(&vb->queue, &cam->buffer_queue);
631}
632
633
634
635
636static void viacam_vb_buf_release(struct videobuf_queue *q,
637 struct videobuf_buffer *vb)
638{
639 struct via_camera *cam = q->priv_data;
640
641 videobuf_dma_unmap(&cam->platdev->dev, videobuf_to_dma(vb));
642 videobuf_dma_free(videobuf_to_dma(vb));
643 vb->state = VIDEOBUF_NEEDS_INIT;
644}
645
646static const struct videobuf_queue_ops viacam_vb_ops = {
647 .buf_setup = viacam_vb_buf_setup,
648 .buf_prepare = viacam_vb_buf_prepare,
649 .buf_queue = viacam_vb_buf_queue,
650 .buf_release = viacam_vb_buf_release,
651};
652
653
654
655
656static int viacam_open(struct file *filp)
657{
658 struct via_camera *cam = video_drvdata(filp);
659
660 filp->private_data = cam;
661
662
663
664
665 mutex_lock(&cam->lock);
666 if (cam->users == 0) {
667 int ret = viafb_request_dma();
668
669 if (ret) {
670 mutex_unlock(&cam->lock);
671 return ret;
672 }
673 via_sensor_power_up(cam);
674 set_bit(CF_CONFIG_NEEDED, &cam->flags);
675
676
677
678 videobuf_queue_sg_init(&cam->vb_queue, &viacam_vb_ops,
679 &cam->platdev->dev, &cam->viadev->reg_lock,
680 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
681 sizeof(struct videobuf_buffer), cam, NULL);
682 }
683 (cam->users)++;
684 mutex_unlock(&cam->lock);
685 return 0;
686}
687
688static int viacam_release(struct file *filp)
689{
690 struct via_camera *cam = video_drvdata(filp);
691
692 mutex_lock(&cam->lock);
693 (cam->users)--;
694
695
696
697
698 if (filp == cam->owner) {
699 videobuf_stop(&cam->vb_queue);
700
701
702
703
704
705
706 if (cam->opstate != S_IDLE)
707 viacam_stop_engine(cam);
708 cam->owner = NULL;
709 }
710
711
712
713 if (cam->users == 0) {
714 videobuf_mmap_free(&cam->vb_queue);
715 via_sensor_power_down(cam);
716 viafb_release_dma();
717 }
718 mutex_unlock(&cam->lock);
719 return 0;
720}
721
722
723
724
725static ssize_t viacam_read(struct file *filp, char __user *buffer,
726 size_t len, loff_t *pos)
727{
728 struct via_camera *cam = video_drvdata(filp);
729 int ret;
730
731 mutex_lock(&cam->lock);
732
733
734
735 if (cam->owner && cam->owner != filp) {
736 ret = -EBUSY;
737 goto out_unlock;
738 }
739 cam->owner = filp;
740
741
742
743 if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) {
744 ret = viacam_configure_sensor(cam);
745 if (!ret)
746 ret = viacam_config_controller(cam);
747 if (ret)
748 goto out_unlock;
749 }
750
751
752
753
754
755 INIT_LIST_HEAD(&cam->buffer_queue);
756 viacam_start_engine(cam);
757 ret = videobuf_read_stream(&cam->vb_queue, buffer, len, pos, 0,
758 filp->f_flags & O_NONBLOCK);
759 viacam_stop_engine(cam);
760
761
762out_unlock:
763 mutex_unlock(&cam->lock);
764 return ret;
765}
766
767
768static unsigned int viacam_poll(struct file *filp, struct poll_table_struct *pt)
769{
770 struct via_camera *cam = video_drvdata(filp);
771
772 return videobuf_poll_stream(filp, &cam->vb_queue, pt);
773}
774
775
776static int viacam_mmap(struct file *filp, struct vm_area_struct *vma)
777{
778 struct via_camera *cam = video_drvdata(filp);
779
780 return videobuf_mmap_mapper(&cam->vb_queue, vma);
781}
782
783
784
785static const struct v4l2_file_operations viacam_fops = {
786 .owner = THIS_MODULE,
787 .open = viacam_open,
788 .release = viacam_release,
789 .read = viacam_read,
790 .poll = viacam_poll,
791 .mmap = viacam_mmap,
792 .unlocked_ioctl = video_ioctl2,
793};
794
795
796
797
798
799
800
801
802
803static int viacam_enum_input(struct file *filp, void *priv,
804 struct v4l2_input *input)
805{
806 if (input->index != 0)
807 return -EINVAL;
808
809 input->type = V4L2_INPUT_TYPE_CAMERA;
810 input->std = V4L2_STD_ALL;
811 strcpy(input->name, "Camera");
812 return 0;
813}
814
815static int viacam_g_input(struct file *filp, void *priv, unsigned int *i)
816{
817 *i = 0;
818 return 0;
819}
820
821static int viacam_s_input(struct file *filp, void *priv, unsigned int i)
822{
823 if (i != 0)
824 return -EINVAL;
825 return 0;
826}
827
828static int viacam_s_std(struct file *filp, void *priv, v4l2_std_id std)
829{
830 return 0;
831}
832
833static int viacam_g_std(struct file *filp, void *priv, v4l2_std_id *std)
834{
835 *std = V4L2_STD_NTSC_M;
836 return 0;
837}
838
839
840
841
842
843static const struct v4l2_pix_format viacam_def_pix_format = {
844 .width = VGA_WIDTH,
845 .height = VGA_HEIGHT,
846 .pixelformat = V4L2_PIX_FMT_YUYV,
847 .field = V4L2_FIELD_NONE,
848 .bytesperline = VGA_WIDTH * 2,
849 .sizeimage = VGA_WIDTH * VGA_HEIGHT * 2,
850};
851
852static const u32 via_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
853
854static int viacam_enum_fmt_vid_cap(struct file *filp, void *priv,
855 struct v4l2_fmtdesc *fmt)
856{
857 if (fmt->index >= N_VIA_FMTS)
858 return -EINVAL;
859 strlcpy(fmt->description, via_formats[fmt->index].desc,
860 sizeof(fmt->description));
861 fmt->pixelformat = via_formats[fmt->index].pixelformat;
862 return 0;
863}
864
865
866
867
868
869static void viacam_fmt_pre(struct v4l2_pix_format *userfmt,
870 struct v4l2_pix_format *sensorfmt)
871{
872 *sensorfmt = *userfmt;
873 if (userfmt->width < QCIF_WIDTH || userfmt->height < QCIF_HEIGHT) {
874 userfmt->width = QCIF_WIDTH;
875 userfmt->height = QCIF_HEIGHT;
876 }
877 if (userfmt->width > VGA_WIDTH || userfmt->height > VGA_HEIGHT) {
878 userfmt->width = VGA_WIDTH;
879 userfmt->height = VGA_HEIGHT;
880 }
881 sensorfmt->width = VGA_WIDTH;
882 sensorfmt->height = VGA_HEIGHT;
883}
884
885static void viacam_fmt_post(struct v4l2_pix_format *userfmt,
886 struct v4l2_pix_format *sensorfmt)
887{
888 struct via_format *f = via_find_format(userfmt->pixelformat);
889
890 sensorfmt->bytesperline = sensorfmt->width * f->bpp;
891 sensorfmt->sizeimage = sensorfmt->height * sensorfmt->bytesperline;
892 userfmt->pixelformat = sensorfmt->pixelformat;
893 userfmt->field = sensorfmt->field;
894 userfmt->bytesperline = 2 * userfmt->width;
895 userfmt->sizeimage = userfmt->bytesperline * userfmt->height;
896}
897
898
899
900
901
902static int viacam_do_try_fmt(struct via_camera *cam,
903 struct v4l2_pix_format *upix, struct v4l2_pix_format *spix)
904{
905 int ret;
906 struct v4l2_mbus_framefmt mbus_fmt;
907 struct via_format *f = via_find_format(upix->pixelformat);
908
909 upix->pixelformat = f->pixelformat;
910 viacam_fmt_pre(upix, spix);
911 v4l2_fill_mbus_format(&mbus_fmt, spix, f->mbus_code);
912 ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
913 v4l2_fill_pix_format(spix, &mbus_fmt);
914 viacam_fmt_post(upix, spix);
915 return ret;
916}
917
918
919
920static int viacam_try_fmt_vid_cap(struct file *filp, void *priv,
921 struct v4l2_format *fmt)
922{
923 struct via_camera *cam = priv;
924 struct v4l2_format sfmt;
925 int ret;
926
927 mutex_lock(&cam->lock);
928 ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix);
929 mutex_unlock(&cam->lock);
930 return ret;
931}
932
933
934static int viacam_g_fmt_vid_cap(struct file *filp, void *priv,
935 struct v4l2_format *fmt)
936{
937 struct via_camera *cam = priv;
938
939 mutex_lock(&cam->lock);
940 fmt->fmt.pix = cam->user_format;
941 mutex_unlock(&cam->lock);
942 return 0;
943}
944
945static int viacam_s_fmt_vid_cap(struct file *filp, void *priv,
946 struct v4l2_format *fmt)
947{
948 struct via_camera *cam = priv;
949 int ret;
950 struct v4l2_format sfmt;
951 struct via_format *f = via_find_format(fmt->fmt.pix.pixelformat);
952
953
954
955
956
957 mutex_lock(&cam->lock);
958 if (cam->opstate != S_IDLE) {
959 ret = -EBUSY;
960 goto out;
961 }
962
963
964
965
966 ret = viacam_do_try_fmt(cam, &fmt->fmt.pix, &sfmt.fmt.pix);
967 if (ret)
968 goto out;
969
970
971
972 cam->user_format = fmt->fmt.pix;
973 cam->sensor_format = sfmt.fmt.pix;
974 cam->mbus_code = f->mbus_code;
975 ret = viacam_configure_sensor(cam);
976 if (!ret)
977 ret = viacam_config_controller(cam);
978out:
979 mutex_unlock(&cam->lock);
980 return ret;
981}
982
983static int viacam_querycap(struct file *filp, void *priv,
984 struct v4l2_capability *cap)
985{
986 strcpy(cap->driver, "via-camera");
987 strcpy(cap->card, "via-camera");
988 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
989 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
990 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
991 return 0;
992}
993
994
995
996
997static int viacam_reqbufs(struct file *filp, void *priv,
998 struct v4l2_requestbuffers *rb)
999{
1000 struct via_camera *cam = priv;
1001
1002 return videobuf_reqbufs(&cam->vb_queue, rb);
1003}
1004
1005static int viacam_querybuf(struct file *filp, void *priv,
1006 struct v4l2_buffer *buf)
1007{
1008 struct via_camera *cam = priv;
1009
1010 return videobuf_querybuf(&cam->vb_queue, buf);
1011}
1012
1013static int viacam_qbuf(struct file *filp, void *priv, struct v4l2_buffer *buf)
1014{
1015 struct via_camera *cam = priv;
1016
1017 return videobuf_qbuf(&cam->vb_queue, buf);
1018}
1019
1020static int viacam_dqbuf(struct file *filp, void *priv, struct v4l2_buffer *buf)
1021{
1022 struct via_camera *cam = priv;
1023
1024 return videobuf_dqbuf(&cam->vb_queue, buf, filp->f_flags & O_NONBLOCK);
1025}
1026
1027static int viacam_streamon(struct file *filp, void *priv, enum v4l2_buf_type t)
1028{
1029 struct via_camera *cam = priv;
1030 int ret = 0;
1031
1032 if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1033 return -EINVAL;
1034
1035 mutex_lock(&cam->lock);
1036 if (cam->opstate != S_IDLE) {
1037 ret = -EBUSY;
1038 goto out;
1039 }
1040
1041
1042
1043 if (cam->owner && cam->owner != filp) {
1044 ret = -EBUSY;
1045 goto out;
1046 }
1047 cam->owner = filp;
1048
1049
1050
1051 if (test_bit(CF_CONFIG_NEEDED, &cam->flags)) {
1052 ret = viacam_configure_sensor(cam);
1053 if (ret)
1054 goto out;
1055 ret = viacam_config_controller(cam);
1056 if (ret)
1057 goto out;
1058 }
1059
1060
1061
1062
1063
1064
1065 pm_qos_add_request(&cam->qos_request, PM_QOS_CPU_DMA_LATENCY, 50);
1066
1067
1068
1069 INIT_LIST_HEAD(&cam->buffer_queue);
1070 ret = videobuf_streamon(&cam->vb_queue);
1071 if (!ret)
1072 viacam_start_engine(cam);
1073out:
1074 mutex_unlock(&cam->lock);
1075 return ret;
1076}
1077
1078static int viacam_streamoff(struct file *filp, void *priv, enum v4l2_buf_type t)
1079{
1080 struct via_camera *cam = priv;
1081 int ret;
1082
1083 if (t != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1084 return -EINVAL;
1085 mutex_lock(&cam->lock);
1086 if (cam->opstate != S_RUNNING) {
1087 ret = -EINVAL;
1088 goto out;
1089 }
1090 pm_qos_remove_request(&cam->qos_request);
1091 viacam_stop_engine(cam);
1092
1093
1094
1095
1096
1097 ret = videobuf_streamoff(&cam->vb_queue);
1098 INIT_LIST_HEAD(&cam->buffer_queue);
1099out:
1100 mutex_unlock(&cam->lock);
1101 return ret;
1102}
1103
1104
1105
1106static int viacam_g_parm(struct file *filp, void *priv,
1107 struct v4l2_streamparm *parm)
1108{
1109 struct via_camera *cam = priv;
1110 int ret;
1111
1112 mutex_lock(&cam->lock);
1113 ret = sensor_call(cam, video, g_parm, parm);
1114 mutex_unlock(&cam->lock);
1115 parm->parm.capture.readbuffers = cam->n_cap_bufs;
1116 return ret;
1117}
1118
1119static int viacam_s_parm(struct file *filp, void *priv,
1120 struct v4l2_streamparm *parm)
1121{
1122 struct via_camera *cam = priv;
1123 int ret;
1124
1125 mutex_lock(&cam->lock);
1126 ret = sensor_call(cam, video, s_parm, parm);
1127 mutex_unlock(&cam->lock);
1128 parm->parm.capture.readbuffers = cam->n_cap_bufs;
1129 return ret;
1130}
1131
1132static int viacam_enum_framesizes(struct file *filp, void *priv,
1133 struct v4l2_frmsizeenum *sizes)
1134{
1135 if (sizes->index != 0)
1136 return -EINVAL;
1137 sizes->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
1138 sizes->stepwise.min_width = QCIF_WIDTH;
1139 sizes->stepwise.min_height = QCIF_HEIGHT;
1140 sizes->stepwise.max_width = VGA_WIDTH;
1141 sizes->stepwise.max_height = VGA_HEIGHT;
1142 sizes->stepwise.step_width = sizes->stepwise.step_height = 1;
1143 return 0;
1144}
1145
1146static int viacam_enum_frameintervals(struct file *filp, void *priv,
1147 struct v4l2_frmivalenum *interval)
1148{
1149 struct via_camera *cam = priv;
1150 struct v4l2_subdev_frame_interval_enum fie = {
1151 .index = interval->index,
1152 .code = cam->mbus_code,
1153 .width = cam->sensor_format.width,
1154 .height = cam->sensor_format.height,
1155 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1156 };
1157 int ret;
1158
1159 mutex_lock(&cam->lock);
1160 ret = sensor_call(cam, pad, enum_frame_interval, NULL, &fie);
1161 mutex_unlock(&cam->lock);
1162 if (ret)
1163 return ret;
1164 interval->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1165 interval->discrete = fie.interval;
1166 return 0;
1167}
1168
1169
1170
1171static const struct v4l2_ioctl_ops viacam_ioctl_ops = {
1172 .vidioc_enum_input = viacam_enum_input,
1173 .vidioc_g_input = viacam_g_input,
1174 .vidioc_s_input = viacam_s_input,
1175 .vidioc_s_std = viacam_s_std,
1176 .vidioc_g_std = viacam_g_std,
1177 .vidioc_enum_fmt_vid_cap = viacam_enum_fmt_vid_cap,
1178 .vidioc_try_fmt_vid_cap = viacam_try_fmt_vid_cap,
1179 .vidioc_g_fmt_vid_cap = viacam_g_fmt_vid_cap,
1180 .vidioc_s_fmt_vid_cap = viacam_s_fmt_vid_cap,
1181 .vidioc_querycap = viacam_querycap,
1182 .vidioc_reqbufs = viacam_reqbufs,
1183 .vidioc_querybuf = viacam_querybuf,
1184 .vidioc_qbuf = viacam_qbuf,
1185 .vidioc_dqbuf = viacam_dqbuf,
1186 .vidioc_streamon = viacam_streamon,
1187 .vidioc_streamoff = viacam_streamoff,
1188 .vidioc_g_parm = viacam_g_parm,
1189 .vidioc_s_parm = viacam_s_parm,
1190 .vidioc_enum_framesizes = viacam_enum_framesizes,
1191 .vidioc_enum_frameintervals = viacam_enum_frameintervals,
1192};
1193
1194
1195
1196
1197
1198
1199#ifdef CONFIG_PM
1200
1201static int viacam_suspend(void *priv)
1202{
1203 struct via_camera *cam = priv;
1204 enum viacam_opstate state = cam->opstate;
1205
1206 if (cam->opstate != S_IDLE) {
1207 viacam_stop_engine(cam);
1208 cam->opstate = state;
1209 }
1210
1211 return 0;
1212}
1213
1214static int viacam_resume(void *priv)
1215{
1216 struct via_camera *cam = priv;
1217 int ret = 0;
1218
1219
1220
1221
1222 via_write_reg_mask(VIASR, 0x78, 0, 0x80);
1223 via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0);
1224 viacam_int_disable(cam);
1225 set_bit(CF_CONFIG_NEEDED, &cam->flags);
1226
1227
1228
1229 if (cam->users > 0)
1230 via_sensor_power_up(cam);
1231 else
1232 via_sensor_power_down(cam);
1233
1234
1235
1236 if (cam->opstate != S_IDLE) {
1237 mutex_lock(&cam->lock);
1238 ret = viacam_configure_sensor(cam);
1239 if (!ret)
1240 ret = viacam_config_controller(cam);
1241 mutex_unlock(&cam->lock);
1242 if (!ret)
1243 viacam_start_engine(cam);
1244 }
1245
1246 return ret;
1247}
1248
1249static struct viafb_pm_hooks viacam_pm_hooks = {
1250 .suspend = viacam_suspend,
1251 .resume = viacam_resume
1252};
1253
1254#endif
1255
1256
1257
1258
1259
1260static struct video_device viacam_v4l_template = {
1261 .name = "via-camera",
1262 .minor = -1,
1263 .tvnorms = V4L2_STD_NTSC_M,
1264 .fops = &viacam_fops,
1265 .ioctl_ops = &viacam_ioctl_ops,
1266 .release = video_device_release_empty,
1267};
1268
1269
1270
1271
1272
1273
1274
1275#define VIACAM_SERIAL_DEVFN 0x88
1276#define VIACAM_SERIAL_CREG 0x46
1277#define VIACAM_SERIAL_BIT 0x40
1278
1279static bool viacam_serial_is_enabled(void)
1280{
1281 struct pci_bus *pbus = pci_find_bus(0, 0);
1282 u8 cbyte;
1283
1284 if (!pbus)
1285 return false;
1286 pci_bus_read_config_byte(pbus, VIACAM_SERIAL_DEVFN,
1287 VIACAM_SERIAL_CREG, &cbyte);
1288 if ((cbyte & VIACAM_SERIAL_BIT) == 0)
1289 return false;
1290 if (!override_serial) {
1291 printk(KERN_NOTICE "Via camera: serial port is enabled, " \
1292 "refusing to load.\n");
1293 printk(KERN_NOTICE "Specify override_serial=1 to force " \
1294 "module loading.\n");
1295 return true;
1296 }
1297 printk(KERN_NOTICE "Via camera: overriding serial port\n");
1298 pci_bus_write_config_byte(pbus, VIACAM_SERIAL_DEVFN,
1299 VIACAM_SERIAL_CREG, cbyte & ~VIACAM_SERIAL_BIT);
1300 return false;
1301}
1302
1303static struct ov7670_config sensor_cfg = {
1304
1305 .clock_speed = 90,
1306};
1307
1308static int viacam_probe(struct platform_device *pdev)
1309{
1310 int ret;
1311 struct i2c_adapter *sensor_adapter;
1312 struct viafb_dev *viadev = pdev->dev.platform_data;
1313 struct i2c_board_info ov7670_info = {
1314 .type = "ov7670",
1315 .addr = 0x42 >> 1,
1316 .platform_data = &sensor_cfg,
1317 };
1318
1319
1320
1321
1322
1323
1324
1325 struct via_camera *cam;
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335 if (viadev->camera_fbmem_size < (VGA_HEIGHT*VGA_WIDTH*4)) {
1336 printk(KERN_ERR "viacam: insufficient FB memory reserved\n");
1337 return -ENOMEM;
1338 }
1339 if (viadev->engine_mmio == NULL) {
1340 printk(KERN_ERR "viacam: No I/O memory, so no pictures\n");
1341 return -ENOMEM;
1342 }
1343
1344 if (machine_is_olpc() && viacam_serial_is_enabled())
1345 return -EBUSY;
1346
1347
1348
1349
1350 cam = kzalloc (sizeof(struct via_camera), GFP_KERNEL);
1351 if (cam == NULL)
1352 return -ENOMEM;
1353 via_cam_info = cam;
1354 cam->platdev = pdev;
1355 cam->viadev = viadev;
1356 cam->users = 0;
1357 cam->owner = NULL;
1358 cam->opstate = S_IDLE;
1359 cam->user_format = cam->sensor_format = viacam_def_pix_format;
1360 mutex_init(&cam->lock);
1361 INIT_LIST_HEAD(&cam->buffer_queue);
1362 cam->mmio = viadev->engine_mmio;
1363 cam->fbmem = viadev->fbmem;
1364 cam->fb_offset = viadev->camera_fbmem_offset;
1365 cam->flags = 1 << CF_CONFIG_NEEDED;
1366 cam->mbus_code = via_def_mbus_code;
1367
1368
1369
1370 ret = v4l2_device_register(&pdev->dev, &cam->v4l2_dev);
1371 if (ret) {
1372 dev_err(&pdev->dev, "Unable to register v4l2 device\n");
1373 goto out_free;
1374 }
1375 ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
1376 if (ret)
1377 goto out_unregister;
1378 cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
1379
1380
1381
1382 pdev->dev.dma_mask = &viadev->pdev->dma_mask;
1383 dma_set_mask(&pdev->dev, 0xffffffff);
1384
1385
1386
1387
1388 via_write_reg_mask(VIASR, 0x78, 0, 0x80);
1389 via_write_reg_mask(VIASR, 0x1e, 0xc0, 0xc0);
1390
1391
1392
1393 ret = via_sensor_power_setup(cam);
1394 if (ret)
1395 goto out_ctrl_hdl_free;
1396 via_sensor_power_up(cam);
1397
1398
1399
1400
1401
1402 sensor_adapter = viafb_find_i2c_adapter(VIA_PORT_31);
1403 cam->sensor = v4l2_i2c_new_subdev_board(&cam->v4l2_dev, sensor_adapter,
1404 &ov7670_info, NULL);
1405 if (cam->sensor == NULL) {
1406 dev_err(&pdev->dev, "Unable to find the sensor!\n");
1407 ret = -ENODEV;
1408 goto out_power_down;
1409 }
1410
1411
1412
1413 viacam_int_disable(cam);
1414 ret = request_threaded_irq(viadev->pdev->irq, viacam_quick_irq,
1415 viacam_irq, IRQF_SHARED, "via-camera", cam);
1416 if (ret)
1417 goto out_power_down;
1418
1419
1420
1421 cam->vdev = viacam_v4l_template;
1422 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1423 ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1424 if (ret)
1425 goto out_irq;
1426 video_set_drvdata(&cam->vdev, cam);
1427
1428#ifdef CONFIG_PM
1429
1430
1431
1432 viacam_pm_hooks.private = cam;
1433 viafb_pm_register(&viacam_pm_hooks);
1434#endif
1435
1436
1437 via_sensor_power_down(cam);
1438 return 0;
1439
1440out_irq:
1441 free_irq(viadev->pdev->irq, cam);
1442out_power_down:
1443 via_sensor_power_release(cam);
1444out_ctrl_hdl_free:
1445 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1446out_unregister:
1447 v4l2_device_unregister(&cam->v4l2_dev);
1448out_free:
1449 kfree(cam);
1450 return ret;
1451}
1452
1453static int viacam_remove(struct platform_device *pdev)
1454{
1455 struct via_camera *cam = via_cam_info;
1456 struct viafb_dev *viadev = pdev->dev.platform_data;
1457
1458 video_unregister_device(&cam->vdev);
1459 v4l2_device_unregister(&cam->v4l2_dev);
1460 free_irq(viadev->pdev->irq, cam);
1461 via_sensor_power_release(cam);
1462 v4l2_ctrl_handler_free(&cam->ctrl_handler);
1463 kfree(cam);
1464 via_cam_info = NULL;
1465 return 0;
1466}
1467
1468static struct platform_driver viacam_driver = {
1469 .driver = {
1470 .name = "viafb-camera",
1471 },
1472 .probe = viacam_probe,
1473 .remove = viacam_remove,
1474};
1475
1476module_platform_driver(viacam_driver);
1477