Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/jk/spufs into...
[linux-2.6] / drivers / media / video / cafe_ccic.c
1 /*
2  * A driver for the CMOS camera controller in the Marvell 88ALP01 "cafe"
3  * multifunction chip.  Currently works with the Omnivision OV7670
4  * sensor.
5  *
6  * The data sheet for this device can be found at:
7  *    http://www.marvell.com/products/pcconn/88ALP01.jsp
8  *
9  * Copyright 2006 One Laptop Per Child Association, Inc.
10  * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
11  *
12  * Written by Jonathan Corbet, corbet@lwn.net.
13  *
14  * This file may be distributed under the terms of the GNU General
15  * Public License, version 2.
16  */
17
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/fs.h>
22 #include <linux/mm.h>
23 #include <linux/pci.h>
24 #include <linux/i2c.h>
25 #include <linux/interrupt.h>
26 #include <linux/spinlock.h>
27 #include <linux/videodev2.h>
28 #include <media/v4l2-common.h>
29 #include <media/v4l2-ioctl.h>
30 #include <media/v4l2-chip-ident.h>
31 #include <linux/device.h>
32 #include <linux/wait.h>
33 #include <linux/list.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/delay.h>
36 #include <linux/debugfs.h>
37 #include <linux/jiffies.h>
38 #include <linux/vmalloc.h>
39
40 #include <asm/uaccess.h>
41 #include <asm/io.h>
42
43 #include "cafe_ccic-regs.h"
44
45 #define CAFE_VERSION 0x000002
46
47
48 /*
49  * Parameters.
50  */
51 MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
52 MODULE_DESCRIPTION("Marvell 88ALP01 CMOS Camera Controller driver");
53 MODULE_LICENSE("GPL");
54 MODULE_SUPPORTED_DEVICE("Video");
55
56 /*
57  * Internal DMA buffer management.  Since the controller cannot do S/G I/O,
58  * we must have physically contiguous buffers to bring frames into.
59  * These parameters control how many buffers we use, whether we
60  * allocate them at load time (better chance of success, but nails down
61  * memory) or when somebody tries to use the camera (riskier), and,
62  * for load-time allocation, how big they should be.
63  *
64  * The controller can cycle through three buffers.  We could use
65  * more by flipping pointers around, but it probably makes little
66  * sense.
67  */
68
69 #define MAX_DMA_BUFS 3
70 static int alloc_bufs_at_read;
71 module_param(alloc_bufs_at_read, bool, 0444);
72 MODULE_PARM_DESC(alloc_bufs_at_read,
73                 "Non-zero value causes DMA buffers to be allocated when the "
74                 "video capture device is read, rather than at module load "
75                 "time.  This saves memory, but decreases the chances of "
76                 "successfully getting those buffers.");
77
78 static int n_dma_bufs = 3;
79 module_param(n_dma_bufs, uint, 0644);
80 MODULE_PARM_DESC(n_dma_bufs,
81                 "The number of DMA buffers to allocate.  Can be either two "
82                 "(saves memory, makes timing tighter) or three.");
83
84 static int dma_buf_size = VGA_WIDTH * VGA_HEIGHT * 2;  /* Worst case */
85 module_param(dma_buf_size, uint, 0444);
86 MODULE_PARM_DESC(dma_buf_size,
87                 "The size of the allocated DMA buffers.  If actual operating "
88                 "parameters require larger buffers, an attempt to reallocate "
89                 "will be made.");
90
91 static int min_buffers = 1;
92 module_param(min_buffers, uint, 0644);
93 MODULE_PARM_DESC(min_buffers,
94                 "The minimum number of streaming I/O buffers we are willing "
95                 "to work with.");
96
97 static int max_buffers = 10;
98 module_param(max_buffers, uint, 0644);
99 MODULE_PARM_DESC(max_buffers,
100                 "The maximum number of streaming I/O buffers an application "
101                 "will be allowed to allocate.  These buffers are big and live "
102                 "in vmalloc space.");
103
104 static int flip;
105 module_param(flip, bool, 0444);
106 MODULE_PARM_DESC(flip,
107                 "If set, the sensor will be instructed to flip the image "
108                 "vertically.");
109
110
111 enum cafe_state {
112         S_NOTREADY,     /* Not yet initialized */
113         S_IDLE,         /* Just hanging around */
114         S_FLAKED,       /* Some sort of problem */
115         S_SINGLEREAD,   /* In read() */
116         S_SPECREAD,     /* Speculative read (for future read()) */
117         S_STREAMING     /* Streaming data */
118 };
119
120 /*
121  * Tracking of streaming I/O buffers.
122  */
123 struct cafe_sio_buffer {
124         struct list_head list;
125         struct v4l2_buffer v4lbuf;
126         char *buffer;   /* Where it lives in kernel space */
127         int mapcount;
128         struct cafe_camera *cam;
129 };
130
131 /*
132  * A description of one of our devices.
133  * Locking: controlled by s_mutex.  Certain fields, however, require
134  *          the dev_lock spinlock; they are marked as such by comments.
135  *          dev_lock is also required for access to device registers.
136  */
137 struct cafe_camera
138 {
139         enum cafe_state state;
140         unsigned long flags;            /* Buffer status, mainly (dev_lock) */
141         int users;                      /* How many open FDs */
142         struct file *owner;             /* Who has data access (v4l2) */
143
144         /*
145          * Subsystem structures.
146          */
147         struct pci_dev *pdev;
148         struct video_device v4ldev;
149         struct i2c_adapter i2c_adapter;
150         struct i2c_client *sensor;
151
152         unsigned char __iomem *regs;
153         struct list_head dev_list;      /* link to other devices */
154
155         /* DMA buffers */
156         unsigned int nbufs;             /* How many are alloc'd */
157         int next_buf;                   /* Next to consume (dev_lock) */
158         unsigned int dma_buf_size;      /* allocated size */
159         void *dma_bufs[MAX_DMA_BUFS];   /* Internal buffer addresses */
160         dma_addr_t dma_handles[MAX_DMA_BUFS]; /* Buffer bus addresses */
161         unsigned int specframes;        /* Unconsumed spec frames (dev_lock) */
162         unsigned int sequence;          /* Frame sequence number */
163         unsigned int buf_seq[MAX_DMA_BUFS]; /* Sequence for individual buffers */
164
165         /* Streaming buffers */
166         unsigned int n_sbufs;           /* How many we have */
167         struct cafe_sio_buffer *sb_bufs; /* The array of housekeeping structs */
168         struct list_head sb_avail;      /* Available for data (we own) (dev_lock) */
169         struct list_head sb_full;       /* With data (user space owns) (dev_lock) */
170         struct tasklet_struct s_tasklet;
171
172         /* Current operating parameters */
173         u32 sensor_type;                /* Currently ov7670 only */
174         struct v4l2_pix_format pix_format;
175
176         /* Locks */
177         struct mutex s_mutex; /* Access to this structure */
178         spinlock_t dev_lock;  /* Access to device */
179
180         /* Misc */
181         wait_queue_head_t smbus_wait;   /* Waiting on i2c events */
182         wait_queue_head_t iowait;       /* Waiting on frame data */
183 #ifdef CONFIG_VIDEO_ADV_DEBUG
184         struct dentry *dfs_regs;
185         struct dentry *dfs_cam_regs;
186 #endif
187 };
188
189 /*
190  * Status flags.  Always manipulated with bit operations.
191  */
192 #define CF_BUF0_VALID    0      /* Buffers valid - first three */
193 #define CF_BUF1_VALID    1
194 #define CF_BUF2_VALID    2
195 #define CF_DMA_ACTIVE    3      /* A frame is incoming */
196 #define CF_CONFIG_NEEDED 4      /* Must configure hardware */
197
198
199
200 /*
201  * Start over with DMA buffers - dev_lock needed.
202  */
203 static void cafe_reset_buffers(struct cafe_camera *cam)
204 {
205         int i;
206
207         cam->next_buf = -1;
208         for (i = 0; i < cam->nbufs; i++)
209                 clear_bit(i, &cam->flags);
210         cam->specframes = 0;
211 }
212
213 static inline int cafe_needs_config(struct cafe_camera *cam)
214 {
215         return test_bit(CF_CONFIG_NEEDED, &cam->flags);
216 }
217
218 static void cafe_set_config_needed(struct cafe_camera *cam, int needed)
219 {
220         if (needed)
221                 set_bit(CF_CONFIG_NEEDED, &cam->flags);
222         else
223                 clear_bit(CF_CONFIG_NEEDED, &cam->flags);
224 }
225
226
227
228
229 /*
230  * Debugging and related.
231  */
232 #define cam_err(cam, fmt, arg...) \
233         dev_err(&(cam)->pdev->dev, fmt, ##arg);
234 #define cam_warn(cam, fmt, arg...) \
235         dev_warn(&(cam)->pdev->dev, fmt, ##arg);
236 #define cam_dbg(cam, fmt, arg...) \
237         dev_dbg(&(cam)->pdev->dev, fmt, ##arg);
238
239
240 /* ---------------------------------------------------------------------*/
241 /*
242  * We keep a simple list of known devices to search at open time.
243  */
244 static LIST_HEAD(cafe_dev_list);
245 static DEFINE_MUTEX(cafe_dev_list_lock);
246
247 static void cafe_add_dev(struct cafe_camera *cam)
248 {
249         mutex_lock(&cafe_dev_list_lock);
250         list_add_tail(&cam->dev_list, &cafe_dev_list);
251         mutex_unlock(&cafe_dev_list_lock);
252 }
253
254 static void cafe_remove_dev(struct cafe_camera *cam)
255 {
256         mutex_lock(&cafe_dev_list_lock);
257         list_del(&cam->dev_list);
258         mutex_unlock(&cafe_dev_list_lock);
259 }
260
261 static struct cafe_camera *cafe_find_dev(int minor)
262 {
263         struct cafe_camera *cam;
264
265         mutex_lock(&cafe_dev_list_lock);
266         list_for_each_entry(cam, &cafe_dev_list, dev_list) {
267                 if (cam->v4ldev.minor == minor)
268                         goto done;
269         }
270         cam = NULL;
271   done:
272         mutex_unlock(&cafe_dev_list_lock);
273         return cam;
274 }
275
276
277 static struct cafe_camera *cafe_find_by_pdev(struct pci_dev *pdev)
278 {
279         struct cafe_camera *cam;
280
281         mutex_lock(&cafe_dev_list_lock);
282         list_for_each_entry(cam, &cafe_dev_list, dev_list) {
283                 if (cam->pdev == pdev)
284                         goto done;
285         }
286         cam = NULL;
287   done:
288         mutex_unlock(&cafe_dev_list_lock);
289         return cam;
290 }
291
292
293 /* ------------------------------------------------------------------------ */
294 /*
295  * Device register I/O
296  */
297 static inline void cafe_reg_write(struct cafe_camera *cam, unsigned int reg,
298                 unsigned int val)
299 {
300         iowrite32(val, cam->regs + reg);
301 }
302
303 static inline unsigned int cafe_reg_read(struct cafe_camera *cam,
304                 unsigned int reg)
305 {
306         return ioread32(cam->regs + reg);
307 }
308
309
310 static inline void cafe_reg_write_mask(struct cafe_camera *cam, unsigned int reg,
311                 unsigned int val, unsigned int mask)
312 {
313         unsigned int v = cafe_reg_read(cam, reg);
314
315         v = (v & ~mask) | (val & mask);
316         cafe_reg_write(cam, reg, v);
317 }
318
319 static inline void cafe_reg_clear_bit(struct cafe_camera *cam,
320                 unsigned int reg, unsigned int val)
321 {
322         cafe_reg_write_mask(cam, reg, 0, val);
323 }
324
325 static inline void cafe_reg_set_bit(struct cafe_camera *cam,
326                 unsigned int reg, unsigned int val)
327 {
328         cafe_reg_write_mask(cam, reg, val, val);
329 }
330
331
332
333 /* -------------------------------------------------------------------- */
334 /*
335  * The I2C/SMBUS interface to the camera itself starts here.  The
336  * controller handles SMBUS itself, presenting a relatively simple register
337  * interface; all we have to do is to tell it where to route the data.
338  */
339 #define CAFE_SMBUS_TIMEOUT (HZ)  /* generous */
340
341 static int cafe_smbus_write_done(struct cafe_camera *cam)
342 {
343         unsigned long flags;
344         int c1;
345
346         /*
347          * We must delay after the interrupt, or the controller gets confused
348          * and never does give us good status.  Fortunately, we don't do this
349          * often.
350          */
351         udelay(20);
352         spin_lock_irqsave(&cam->dev_lock, flags);
353         c1 = cafe_reg_read(cam, REG_TWSIC1);
354         spin_unlock_irqrestore(&cam->dev_lock, flags);
355         return (c1 & (TWSIC1_WSTAT|TWSIC1_ERROR)) != TWSIC1_WSTAT;
356 }
357
358 static int cafe_smbus_write_data(struct cafe_camera *cam,
359                 u16 addr, u8 command, u8 value)
360 {
361         unsigned int rval;
362         unsigned long flags;
363         DEFINE_WAIT(the_wait);
364
365         spin_lock_irqsave(&cam->dev_lock, flags);
366         rval = TWSIC0_EN | ((addr << TWSIC0_SID_SHIFT) & TWSIC0_SID);
367         rval |= TWSIC0_OVMAGIC;  /* Make OV sensors work */
368         /*
369          * Marvell sez set clkdiv to all 1's for now.
370          */
371         rval |= TWSIC0_CLKDIV;
372         cafe_reg_write(cam, REG_TWSIC0, rval);
373         (void) cafe_reg_read(cam, REG_TWSIC1); /* force write */
374         rval = value | ((command << TWSIC1_ADDR_SHIFT) & TWSIC1_ADDR);
375         cafe_reg_write(cam, REG_TWSIC1, rval);
376         spin_unlock_irqrestore(&cam->dev_lock, flags);
377
378         /*
379          * Time to wait for the write to complete.  THIS IS A RACY
380          * WAY TO DO IT, but the sad fact is that reading the TWSIC1
381          * register too quickly after starting the operation sends
382          * the device into a place that may be kinder and better, but
383          * which is absolutely useless for controlling the sensor.  In
384          * practice we have plenty of time to get into our sleep state
385          * before the interrupt hits, and the worst case is that we
386          * time out and then see that things completed, so this seems
387          * the best way for now.
388          */
389         do {
390                 prepare_to_wait(&cam->smbus_wait, &the_wait,
391                                 TASK_UNINTERRUPTIBLE);
392                 schedule_timeout(1); /* even 1 jiffy is too long */
393                 finish_wait(&cam->smbus_wait, &the_wait);
394         } while (!cafe_smbus_write_done(cam));
395
396 #ifdef IF_THE_CAFE_HARDWARE_WORKED_RIGHT
397         wait_event_timeout(cam->smbus_wait, cafe_smbus_write_done(cam),
398                         CAFE_SMBUS_TIMEOUT);
399 #endif
400         spin_lock_irqsave(&cam->dev_lock, flags);
401         rval = cafe_reg_read(cam, REG_TWSIC1);
402         spin_unlock_irqrestore(&cam->dev_lock, flags);
403
404         if (rval & TWSIC1_WSTAT) {
405                 cam_err(cam, "SMBUS write (%02x/%02x/%02x) timed out\n", addr,
406                                 command, value);
407                 return -EIO;
408         }
409         if (rval & TWSIC1_ERROR) {
410                 cam_err(cam, "SMBUS write (%02x/%02x/%02x) error\n", addr,
411                                 command, value);
412                 return -EIO;
413         }
414         return 0;
415 }
416
417
418
419 static int cafe_smbus_read_done(struct cafe_camera *cam)
420 {
421         unsigned long flags;
422         int c1;
423
424         /*
425          * We must delay after the interrupt, or the controller gets confused
426          * and never does give us good status.  Fortunately, we don't do this
427          * often.
428          */
429         udelay(20);
430         spin_lock_irqsave(&cam->dev_lock, flags);
431         c1 = cafe_reg_read(cam, REG_TWSIC1);
432         spin_unlock_irqrestore(&cam->dev_lock, flags);
433         return c1 & (TWSIC1_RVALID|TWSIC1_ERROR);
434 }
435
436
437
438 static int cafe_smbus_read_data(struct cafe_camera *cam,
439                 u16 addr, u8 command, u8 *value)
440 {
441         unsigned int rval;
442         unsigned long flags;
443
444         spin_lock_irqsave(&cam->dev_lock, flags);
445         rval = TWSIC0_EN | ((addr << TWSIC0_SID_SHIFT) & TWSIC0_SID);
446         rval |= TWSIC0_OVMAGIC; /* Make OV sensors work */
447         /*
448          * Marvel sez set clkdiv to all 1's for now.
449          */
450         rval |= TWSIC0_CLKDIV;
451         cafe_reg_write(cam, REG_TWSIC0, rval);
452         (void) cafe_reg_read(cam, REG_TWSIC1); /* force write */
453         rval = TWSIC1_READ | ((command << TWSIC1_ADDR_SHIFT) & TWSIC1_ADDR);
454         cafe_reg_write(cam, REG_TWSIC1, rval);
455         spin_unlock_irqrestore(&cam->dev_lock, flags);
456
457         wait_event_timeout(cam->smbus_wait,
458                         cafe_smbus_read_done(cam), CAFE_SMBUS_TIMEOUT);
459         spin_lock_irqsave(&cam->dev_lock, flags);
460         rval = cafe_reg_read(cam, REG_TWSIC1);
461         spin_unlock_irqrestore(&cam->dev_lock, flags);
462
463         if (rval & TWSIC1_ERROR) {
464                 cam_err(cam, "SMBUS read (%02x/%02x) error\n", addr, command);
465                 return -EIO;
466         }
467         if (! (rval & TWSIC1_RVALID)) {
468                 cam_err(cam, "SMBUS read (%02x/%02x) timed out\n", addr,
469                                 command);
470                 return -EIO;
471         }
472         *value = rval & 0xff;
473         return 0;
474 }
475
476 /*
477  * Perform a transfer over SMBUS.  This thing is called under
478  * the i2c bus lock, so we shouldn't race with ourselves...
479  */
480 static int cafe_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
481                 unsigned short flags, char rw, u8 command,
482                 int size, union i2c_smbus_data *data)
483 {
484         struct cafe_camera *cam = i2c_get_adapdata(adapter);
485         int ret = -EINVAL;
486
487         /*
488          * Refuse to talk to anything but OV cam chips.  We should
489          * never even see an attempt to do so, but one never knows.
490          */
491         if (cam->sensor && addr != cam->sensor->addr) {
492                 cam_err(cam, "funky smbus addr %d\n", addr);
493                 return -EINVAL;
494         }
495         /*
496          * This interface would appear to only do byte data ops.  OK
497          * it can do word too, but the cam chip has no use for that.
498          */
499         if (size != I2C_SMBUS_BYTE_DATA) {
500                 cam_err(cam, "funky xfer size %d\n", size);
501                 return -EINVAL;
502         }
503
504         if (rw == I2C_SMBUS_WRITE)
505                 ret = cafe_smbus_write_data(cam, addr, command, data->byte);
506         else if (rw == I2C_SMBUS_READ)
507                 ret = cafe_smbus_read_data(cam, addr, command, &data->byte);
508         return ret;
509 }
510
511
512 static void cafe_smbus_enable_irq(struct cafe_camera *cam)
513 {
514         unsigned long flags;
515
516         spin_lock_irqsave(&cam->dev_lock, flags);
517         cafe_reg_set_bit(cam, REG_IRQMASK, TWSIIRQS);
518         spin_unlock_irqrestore(&cam->dev_lock, flags);
519 }
520
521 static u32 cafe_smbus_func(struct i2c_adapter *adapter)
522 {
523         return I2C_FUNC_SMBUS_READ_BYTE_DATA  |
524                I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
525 }
526
527 static struct i2c_algorithm cafe_smbus_algo = {
528         .smbus_xfer = cafe_smbus_xfer,
529         .functionality = cafe_smbus_func
530 };
531
532 /* Somebody is on the bus */
533 static int cafe_cam_init(struct cafe_camera *cam);
534 static void cafe_ctlr_stop_dma(struct cafe_camera *cam);
535 static void cafe_ctlr_power_down(struct cafe_camera *cam);
536
537 static int cafe_smbus_attach(struct i2c_client *client)
538 {
539         struct cafe_camera *cam = i2c_get_adapdata(client->adapter);
540
541         /*
542          * Don't talk to chips we don't recognize.
543          */
544         if (client->driver->id == I2C_DRIVERID_OV7670) {
545                 cam->sensor = client;
546                 return cafe_cam_init(cam);
547         }
548         return -EINVAL;
549 }
550
551 static int cafe_smbus_detach(struct i2c_client *client)
552 {
553         struct cafe_camera *cam = i2c_get_adapdata(client->adapter);
554
555         if (cam->sensor == client) {
556                 cafe_ctlr_stop_dma(cam);
557                 cafe_ctlr_power_down(cam);
558                 cam_err(cam, "lost the sensor!\n");
559                 cam->sensor = NULL;  /* Bummer, no camera */
560                 cam->state = S_NOTREADY;
561         }
562         return 0;
563 }
564
565 static int cafe_smbus_setup(struct cafe_camera *cam)
566 {
567         struct i2c_adapter *adap = &cam->i2c_adapter;
568         int ret;
569
570         cafe_smbus_enable_irq(cam);
571         adap->id = I2C_HW_SMBUS_CAFE;
572         adap->class = I2C_CLASS_CAM_DIGITAL;
573         adap->owner = THIS_MODULE;
574         adap->client_register = cafe_smbus_attach;
575         adap->client_unregister = cafe_smbus_detach;
576         adap->algo = &cafe_smbus_algo;
577         strcpy(adap->name, "cafe_ccic");
578         adap->dev.parent = &cam->pdev->dev;
579         i2c_set_adapdata(adap, cam);
580         ret = i2c_add_adapter(adap);
581         if (ret)
582                 printk(KERN_ERR "Unable to register cafe i2c adapter\n");
583         return ret;
584 }
585
586 static void cafe_smbus_shutdown(struct cafe_camera *cam)
587 {
588         i2c_del_adapter(&cam->i2c_adapter);
589 }
590
591
592 /* ------------------------------------------------------------------- */
593 /*
594  * Deal with the controller.
595  */
596
597 /*
598  * Do everything we think we need to have the interface operating
599  * according to the desired format.
600  */
601 static void cafe_ctlr_dma(struct cafe_camera *cam)
602 {
603         /*
604          * Store the first two Y buffers (we aren't supporting
605          * planar formats for now, so no UV bufs).  Then either
606          * set the third if it exists, or tell the controller
607          * to just use two.
608          */
609         cafe_reg_write(cam, REG_Y0BAR, cam->dma_handles[0]);
610         cafe_reg_write(cam, REG_Y1BAR, cam->dma_handles[1]);
611         if (cam->nbufs > 2) {
612                 cafe_reg_write(cam, REG_Y2BAR, cam->dma_handles[2]);
613                 cafe_reg_clear_bit(cam, REG_CTRL1, C1_TWOBUFS);
614         }
615         else
616                 cafe_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
617         cafe_reg_write(cam, REG_UBAR, 0); /* 32 bits only for now */
618 }
619
620 static void cafe_ctlr_image(struct cafe_camera *cam)
621 {
622         int imgsz;
623         struct v4l2_pix_format *fmt = &cam->pix_format;
624
625         imgsz = ((fmt->height << IMGSZ_V_SHIFT) & IMGSZ_V_MASK) |
626                 (fmt->bytesperline & IMGSZ_H_MASK);
627         cafe_reg_write(cam, REG_IMGSIZE, imgsz);
628         cafe_reg_write(cam, REG_IMGOFFSET, 0);
629         /* YPITCH just drops the last two bits */
630         cafe_reg_write_mask(cam, REG_IMGPITCH, fmt->bytesperline,
631                         IMGP_YP_MASK);
632         /*
633          * Tell the controller about the image format we are using.
634          */
635         switch (cam->pix_format.pixelformat) {
636         case V4L2_PIX_FMT_YUYV:
637             cafe_reg_write_mask(cam, REG_CTRL0,
638                             C0_DF_YUV|C0_YUV_PACKED|C0_YUVE_YUYV,
639                             C0_DF_MASK);
640             break;
641
642         case V4L2_PIX_FMT_RGB444:
643             cafe_reg_write_mask(cam, REG_CTRL0,
644                             C0_DF_RGB|C0_RGBF_444|C0_RGB4_XRGB,
645                             C0_DF_MASK);
646                 /* Alpha value? */
647             break;
648
649         case V4L2_PIX_FMT_RGB565:
650             cafe_reg_write_mask(cam, REG_CTRL0,
651                             C0_DF_RGB|C0_RGBF_565|C0_RGB5_BGGR,
652                             C0_DF_MASK);
653             break;
654
655         default:
656             cam_err(cam, "Unknown format %x\n", cam->pix_format.pixelformat);
657             break;
658         }
659         /*
660          * Make sure it knows we want to use hsync/vsync.
661          */
662         cafe_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC,
663                         C0_SIFM_MASK);
664 }
665
666
667 /*
668  * Configure the controller for operation; caller holds the
669  * device mutex.
670  */
671 static int cafe_ctlr_configure(struct cafe_camera *cam)
672 {
673         unsigned long flags;
674
675         spin_lock_irqsave(&cam->dev_lock, flags);
676         cafe_ctlr_dma(cam);
677         cafe_ctlr_image(cam);
678         cafe_set_config_needed(cam, 0);
679         spin_unlock_irqrestore(&cam->dev_lock, flags);
680         return 0;
681 }
682
683 static void cafe_ctlr_irq_enable(struct cafe_camera *cam)
684 {
685         /*
686          * Clear any pending interrupts, since we do not
687          * expect to have I/O active prior to enabling.
688          */
689         cafe_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
690         cafe_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
691 }
692
693 static void cafe_ctlr_irq_disable(struct cafe_camera *cam)
694 {
695         cafe_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
696 }
697
698 /*
699  * Make the controller start grabbing images.  Everything must
700  * be set up before doing this.
701  */
702 static void cafe_ctlr_start(struct cafe_camera *cam)
703 {
704         /* set_bit performs a read, so no other barrier should be
705            needed here */
706         cafe_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
707 }
708
709 static void cafe_ctlr_stop(struct cafe_camera *cam)
710 {
711         cafe_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
712 }
713
714 static void cafe_ctlr_init(struct cafe_camera *cam)
715 {
716         unsigned long flags;
717
718         spin_lock_irqsave(&cam->dev_lock, flags);
719         /*
720          * Added magic to bring up the hardware on the B-Test board
721          */
722         cafe_reg_write(cam, 0x3038, 0x8);
723         cafe_reg_write(cam, 0x315c, 0x80008);
724         /*
725          * Go through the dance needed to wake the device up.
726          * Note that these registers are global and shared
727          * with the NAND and SD devices.  Interaction between the
728          * three still needs to be examined.
729          */
730         cafe_reg_write(cam, REG_GL_CSR, GCSR_SRS|GCSR_MRS); /* Needed? */
731         cafe_reg_write(cam, REG_GL_CSR, GCSR_SRC|GCSR_MRC);
732         cafe_reg_write(cam, REG_GL_CSR, GCSR_SRC|GCSR_MRS);
733         /*
734          * Here we must wait a bit for the controller to come around.
735          */
736         spin_unlock_irqrestore(&cam->dev_lock, flags);
737         msleep(5);
738         spin_lock_irqsave(&cam->dev_lock, flags);
739
740         cafe_reg_write(cam, REG_GL_CSR, GCSR_CCIC_EN|GCSR_SRC|GCSR_MRC);
741         cafe_reg_set_bit(cam, REG_GL_IMASK, GIMSK_CCIC_EN);
742         /*
743          * Make sure it's not powered down.
744          */
745         cafe_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
746         /*
747          * Turn off the enable bit.  It sure should be off anyway,
748          * but it's good to be sure.
749          */
750         cafe_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
751         /*
752          * Mask all interrupts.
753          */
754         cafe_reg_write(cam, REG_IRQMASK, 0);
755         /*
756          * Clock the sensor appropriately.  Controller clock should
757          * be 48MHz, sensor "typical" value is half that.
758          */
759         cafe_reg_write_mask(cam, REG_CLKCTRL, 2, CLK_DIV_MASK);
760         spin_unlock_irqrestore(&cam->dev_lock, flags);
761 }
762
763
764 /*
765  * Stop the controller, and don't return until we're really sure that no
766  * further DMA is going on.
767  */
768 static void cafe_ctlr_stop_dma(struct cafe_camera *cam)
769 {
770         unsigned long flags;
771
772         /*
773          * Theory: stop the camera controller (whether it is operating
774          * or not).  Delay briefly just in case we race with the SOF
775          * interrupt, then wait until no DMA is active.
776          */
777         spin_lock_irqsave(&cam->dev_lock, flags);
778         cafe_ctlr_stop(cam);
779         spin_unlock_irqrestore(&cam->dev_lock, flags);
780         mdelay(1);
781         wait_event_timeout(cam->iowait,
782                         !test_bit(CF_DMA_ACTIVE, &cam->flags), HZ);
783         if (test_bit(CF_DMA_ACTIVE, &cam->flags))
784                 cam_err(cam, "Timeout waiting for DMA to end\n");
785                 /* This would be bad news - what now? */
786         spin_lock_irqsave(&cam->dev_lock, flags);
787         cam->state = S_IDLE;
788         cafe_ctlr_irq_disable(cam);
789         spin_unlock_irqrestore(&cam->dev_lock, flags);
790 }
791
792 /*
793  * Power up and down.
794  */
795 static void cafe_ctlr_power_up(struct cafe_camera *cam)
796 {
797         unsigned long flags;
798
799         spin_lock_irqsave(&cam->dev_lock, flags);
800         cafe_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
801         /*
802          * Part one of the sensor dance: turn the global
803          * GPIO signal on.
804          */
805         cafe_reg_write(cam, REG_GL_FCR, GFCR_GPIO_ON);
806         cafe_reg_write(cam, REG_GL_GPIOR, GGPIO_OUT|GGPIO_VAL);
807         /*
808          * Put the sensor into operational mode (assumes OLPC-style
809          * wiring).  Control 0 is reset - set to 1 to operate.
810          * Control 1 is power down, set to 0 to operate.
811          */
812         cafe_reg_write(cam, REG_GPR, GPR_C1EN|GPR_C0EN); /* pwr up, reset */
813 //      mdelay(1); /* Marvell says 1ms will do it */
814         cafe_reg_write(cam, REG_GPR, GPR_C1EN|GPR_C0EN|GPR_C0);
815 //      mdelay(1); /* Enough? */
816         spin_unlock_irqrestore(&cam->dev_lock, flags);
817         msleep(5); /* Just to be sure */
818 }
819
820 static void cafe_ctlr_power_down(struct cafe_camera *cam)
821 {
822         unsigned long flags;
823
824         spin_lock_irqsave(&cam->dev_lock, flags);
825         cafe_reg_write(cam, REG_GPR, GPR_C1EN|GPR_C0EN|GPR_C1);
826         cafe_reg_write(cam, REG_GL_FCR, GFCR_GPIO_ON);
827         cafe_reg_write(cam, REG_GL_GPIOR, GGPIO_OUT);
828         cafe_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
829         spin_unlock_irqrestore(&cam->dev_lock, flags);
830 }
831
832 /* -------------------------------------------------------------------- */
833 /*
834  * Communications with the sensor.
835  */
836
837 static int __cafe_cam_cmd(struct cafe_camera *cam, int cmd, void *arg)
838 {
839         struct i2c_client *sc = cam->sensor;
840         int ret;
841
842         if (sc == NULL || sc->driver == NULL || sc->driver->command == NULL)
843                 return -EINVAL;
844         ret = sc->driver->command(sc, cmd, arg);
845         if (ret == -EPERM) /* Unsupported command */
846                 return 0;
847         return ret;
848 }
849
850 static int __cafe_cam_reset(struct cafe_camera *cam)
851 {
852         int zero = 0;
853         return __cafe_cam_cmd(cam, VIDIOC_INT_RESET, &zero);
854 }
855
856 /*
857  * We have found the sensor on the i2c.  Let's try to have a
858  * conversation.
859  */
860 static int cafe_cam_init(struct cafe_camera *cam)
861 {
862         struct v4l2_chip_ident chip = { V4L2_CHIP_MATCH_I2C_ADDR, 0, 0, 0 };
863         int ret;
864
865         mutex_lock(&cam->s_mutex);
866         if (cam->state != S_NOTREADY)
867                 cam_warn(cam, "Cam init with device in funky state %d",
868                                 cam->state);
869         ret = __cafe_cam_reset(cam);
870         if (ret)
871                 goto out;
872         chip.match_chip = cam->sensor->addr;
873         ret = __cafe_cam_cmd(cam, VIDIOC_G_CHIP_IDENT, &chip);
874         if (ret)
875                 goto out;
876         cam->sensor_type = chip.ident;
877 //      if (cam->sensor->addr != OV7xx0_SID) {
878         if (cam->sensor_type != V4L2_IDENT_OV7670) {
879                 cam_err(cam, "Unsupported sensor type %d", cam->sensor->addr);
880                 ret = -EINVAL;
881                 goto out;
882         }
883 /* Get/set parameters? */
884         ret = 0;
885         cam->state = S_IDLE;
886   out:
887         cafe_ctlr_power_down(cam);
888         mutex_unlock(&cam->s_mutex);
889         return ret;
890 }
891
892 /*
893  * Configure the sensor to match the parameters we have.  Caller should
894  * hold s_mutex
895  */
896 static int cafe_cam_set_flip(struct cafe_camera *cam)
897 {
898         struct v4l2_control ctrl;
899
900         memset(&ctrl, 0, sizeof(ctrl));
901         ctrl.id = V4L2_CID_VFLIP;
902         ctrl.value = flip;
903         return __cafe_cam_cmd(cam, VIDIOC_S_CTRL, &ctrl);
904 }
905
906
907 static int cafe_cam_configure(struct cafe_camera *cam)
908 {
909         struct v4l2_format fmt;
910         int ret, zero = 0;
911
912         if (cam->state != S_IDLE)
913                 return -EINVAL;
914         fmt.fmt.pix = cam->pix_format;
915         ret = __cafe_cam_cmd(cam, VIDIOC_INT_INIT, &zero);
916         if (ret == 0)
917                 ret = __cafe_cam_cmd(cam, VIDIOC_S_FMT, &fmt);
918         /*
919          * OV7670 does weird things if flip is set *before* format...
920          */
921         ret += cafe_cam_set_flip(cam);
922         return ret;
923 }
924
925 /* -------------------------------------------------------------------- */
926 /*
927  * DMA buffer management.  These functions need s_mutex held.
928  */
929
930 /* FIXME: this is inefficient as hell, since dma_alloc_coherent just
931  * does a get_free_pages() call, and we waste a good chunk of an orderN
932  * allocation.  Should try to allocate the whole set in one chunk.
933  */
934 static int cafe_alloc_dma_bufs(struct cafe_camera *cam, int loadtime)
935 {
936         int i;
937
938         cafe_set_config_needed(cam, 1);
939         if (loadtime)
940                 cam->dma_buf_size = dma_buf_size;
941         else
942                 cam->dma_buf_size = cam->pix_format.sizeimage;
943         if (n_dma_bufs > 3)
944                 n_dma_bufs = 3;
945
946         cam->nbufs = 0;
947         for (i = 0; i < n_dma_bufs; i++) {
948                 cam->dma_bufs[i] = dma_alloc_coherent(&cam->pdev->dev,
949                                 cam->dma_buf_size, cam->dma_handles + i,
950                                 GFP_KERNEL);
951                 if (cam->dma_bufs[i] == NULL) {
952                         cam_warn(cam, "Failed to allocate DMA buffer\n");
953                         break;
954                 }
955                 /* For debug, remove eventually */
956                 memset(cam->dma_bufs[i], 0xcc, cam->dma_buf_size);
957                 (cam->nbufs)++;
958         }
959
960         switch (cam->nbufs) {
961         case 1:
962             dma_free_coherent(&cam->pdev->dev, cam->dma_buf_size,
963                             cam->dma_bufs[0], cam->dma_handles[0]);
964             cam->nbufs = 0;
965         case 0:
966             cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
967             return -ENOMEM;
968
969         case 2:
970             if (n_dma_bufs > 2)
971                     cam_warn(cam, "Will limp along with only 2 buffers\n");
972             break;
973         }
974         return 0;
975 }
976
977 static void cafe_free_dma_bufs(struct cafe_camera *cam)
978 {
979         int i;
980
981         for (i = 0; i < cam->nbufs; i++) {
982                 dma_free_coherent(&cam->pdev->dev, cam->dma_buf_size,
983                                 cam->dma_bufs[i], cam->dma_handles[i]);
984                 cam->dma_bufs[i] = NULL;
985         }
986         cam->nbufs = 0;
987 }
988
989
990
991
992
993 /* ----------------------------------------------------------------------- */
994 /*
995  * Here starts the V4L2 interface code.
996  */
997
998 /*
999  * Read an image from the device.
1000  */
1001 static ssize_t cafe_deliver_buffer(struct cafe_camera *cam,
1002                 char __user *buffer, size_t len, loff_t *pos)
1003 {
1004         int bufno;
1005         unsigned long flags;
1006
1007         spin_lock_irqsave(&cam->dev_lock, flags);
1008         if (cam->next_buf < 0) {
1009                 cam_err(cam, "deliver_buffer: No next buffer\n");
1010                 spin_unlock_irqrestore(&cam->dev_lock, flags);
1011                 return -EIO;
1012         }
1013         bufno = cam->next_buf;
1014         clear_bit(bufno, &cam->flags);
1015         if (++(cam->next_buf) >= cam->nbufs)
1016                 cam->next_buf = 0;
1017         if (! test_bit(cam->next_buf, &cam->flags))
1018                 cam->next_buf = -1;
1019         cam->specframes = 0;
1020         spin_unlock_irqrestore(&cam->dev_lock, flags);
1021
1022         if (len > cam->pix_format.sizeimage)
1023                 len = cam->pix_format.sizeimage;
1024         if (copy_to_user(buffer, cam->dma_bufs[bufno], len))
1025                 return -EFAULT;
1026         (*pos) += len;
1027         return len;
1028 }
1029
1030 /*
1031  * Get everything ready, and start grabbing frames.
1032  */
1033 static int cafe_read_setup(struct cafe_camera *cam, enum cafe_state state)
1034 {
1035         int ret;
1036         unsigned long flags;
1037
1038         /*
1039          * Configuration.  If we still don't have DMA buffers,
1040          * make one last, desperate attempt.
1041          */
1042         if (cam->nbufs == 0)
1043                 if (cafe_alloc_dma_bufs(cam, 0))
1044                         return -ENOMEM;
1045
1046         if (cafe_needs_config(cam)) {
1047                 cafe_cam_configure(cam);
1048                 ret = cafe_ctlr_configure(cam);
1049                 if (ret)
1050                         return ret;
1051         }
1052
1053         /*
1054          * Turn it loose.
1055          */
1056         spin_lock_irqsave(&cam->dev_lock, flags);
1057         cafe_reset_buffers(cam);
1058         cafe_ctlr_irq_enable(cam);
1059         cam->state = state;
1060         cafe_ctlr_start(cam);
1061         spin_unlock_irqrestore(&cam->dev_lock, flags);
1062         return 0;
1063 }
1064
1065
1066 static ssize_t cafe_v4l_read(struct file *filp,
1067                 char __user *buffer, size_t len, loff_t *pos)
1068 {
1069         struct cafe_camera *cam = filp->private_data;
1070         int ret = 0;
1071
1072         /*
1073          * Perhaps we're in speculative read mode and already
1074          * have data?
1075          */
1076         mutex_lock(&cam->s_mutex);
1077         if (cam->state == S_SPECREAD) {
1078                 if (cam->next_buf >= 0) {
1079                         ret = cafe_deliver_buffer(cam, buffer, len, pos);
1080                         if (ret != 0)
1081                                 goto out_unlock;
1082                 }
1083         } else if (cam->state == S_FLAKED || cam->state == S_NOTREADY) {
1084                 ret = -EIO;
1085                 goto out_unlock;
1086         } else if (cam->state != S_IDLE) {
1087                 ret = -EBUSY;
1088                 goto out_unlock;
1089         }
1090
1091         /*
1092          * v4l2: multiple processes can open the device, but only
1093          * one gets to grab data from it.
1094          */
1095         if (cam->owner && cam->owner != filp) {
1096                 ret = -EBUSY;
1097                 goto out_unlock;
1098         }
1099         cam->owner = filp;
1100
1101         /*
1102          * Do setup if need be.
1103          */
1104         if (cam->state != S_SPECREAD) {
1105                 ret = cafe_read_setup(cam, S_SINGLEREAD);
1106                 if (ret)
1107                         goto out_unlock;
1108         }
1109         /*
1110          * Wait for something to happen.  This should probably
1111          * be interruptible (FIXME).
1112          */
1113         wait_event_timeout(cam->iowait, cam->next_buf >= 0, HZ);
1114         if (cam->next_buf < 0) {
1115                 cam_err(cam, "read() operation timed out\n");
1116                 cafe_ctlr_stop_dma(cam);
1117                 ret = -EIO;
1118                 goto out_unlock;
1119         }
1120         /*
1121          * Give them their data and we should be done.
1122          */
1123         ret = cafe_deliver_buffer(cam, buffer, len, pos);
1124
1125   out_unlock:
1126         mutex_unlock(&cam->s_mutex);
1127         return ret;
1128 }
1129
1130
1131
1132
1133
1134
1135
1136
1137 /*
1138  * Streaming I/O support.
1139  */
1140
1141
1142
1143 static int cafe_vidioc_streamon(struct file *filp, void *priv,
1144                 enum v4l2_buf_type type)
1145 {
1146         struct cafe_camera *cam = filp->private_data;
1147         int ret = -EINVAL;
1148
1149         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1150                 goto out;
1151         mutex_lock(&cam->s_mutex);
1152         if (cam->state != S_IDLE || cam->n_sbufs == 0)
1153                 goto out_unlock;
1154
1155         cam->sequence = 0;
1156         ret = cafe_read_setup(cam, S_STREAMING);
1157
1158   out_unlock:
1159         mutex_unlock(&cam->s_mutex);
1160   out:
1161         return ret;
1162 }
1163
1164
1165 static int cafe_vidioc_streamoff(struct file *filp, void *priv,
1166                 enum v4l2_buf_type type)
1167 {
1168         struct cafe_camera *cam = filp->private_data;
1169         int ret = -EINVAL;
1170
1171         if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1172                 goto out;
1173         mutex_lock(&cam->s_mutex);
1174         if (cam->state != S_STREAMING)
1175                 goto out_unlock;
1176
1177         cafe_ctlr_stop_dma(cam);
1178         ret = 0;
1179
1180   out_unlock:
1181         mutex_unlock(&cam->s_mutex);
1182   out:
1183         return ret;
1184 }
1185
1186
1187
1188 static int cafe_setup_siobuf(struct cafe_camera *cam, int index)
1189 {
1190         struct cafe_sio_buffer *buf = cam->sb_bufs + index;
1191
1192         INIT_LIST_HEAD(&buf->list);
1193         buf->v4lbuf.length = PAGE_ALIGN(cam->pix_format.sizeimage);
1194         buf->buffer = vmalloc_user(buf->v4lbuf.length);
1195         if (buf->buffer == NULL)
1196                 return -ENOMEM;
1197         buf->mapcount = 0;
1198         buf->cam = cam;
1199
1200         buf->v4lbuf.index = index;
1201         buf->v4lbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1202         buf->v4lbuf.field = V4L2_FIELD_NONE;
1203         buf->v4lbuf.memory = V4L2_MEMORY_MMAP;
1204         /*
1205          * Offset: must be 32-bit even on a 64-bit system.  videobuf-dma-sg
1206          * just uses the length times the index, but the spec warns
1207          * against doing just that - vma merging problems.  So we
1208          * leave a gap between each pair of buffers.
1209          */
1210         buf->v4lbuf.m.offset = 2*index*buf->v4lbuf.length;
1211         return 0;
1212 }
1213
1214 static int cafe_free_sio_buffers(struct cafe_camera *cam)
1215 {
1216         int i;
1217
1218         /*
1219          * If any buffers are mapped, we cannot free them at all.
1220          */
1221         for (i = 0; i < cam->n_sbufs; i++)
1222                 if (cam->sb_bufs[i].mapcount > 0)
1223                         return -EBUSY;
1224         /*
1225          * OK, let's do it.
1226          */
1227         for (i = 0; i < cam->n_sbufs; i++)
1228                 vfree(cam->sb_bufs[i].buffer);
1229         cam->n_sbufs = 0;
1230         kfree(cam->sb_bufs);
1231         cam->sb_bufs = NULL;
1232         INIT_LIST_HEAD(&cam->sb_avail);
1233         INIT_LIST_HEAD(&cam->sb_full);
1234         return 0;
1235 }
1236
1237
1238
1239 static int cafe_vidioc_reqbufs(struct file *filp, void *priv,
1240                 struct v4l2_requestbuffers *req)
1241 {
1242         struct cafe_camera *cam = filp->private_data;
1243         int ret = 0;  /* Silence warning */
1244
1245         /*
1246          * Make sure it's something we can do.  User pointers could be
1247          * implemented without great pain, but that's not been done yet.
1248          */
1249         if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1250                 return -EINVAL;
1251         if (req->memory != V4L2_MEMORY_MMAP)
1252                 return -EINVAL;
1253         /*
1254          * If they ask for zero buffers, they really want us to stop streaming
1255          * (if it's happening) and free everything.  Should we check owner?
1256          */
1257         mutex_lock(&cam->s_mutex);
1258         if (req->count == 0) {
1259                 if (cam->state == S_STREAMING)
1260                         cafe_ctlr_stop_dma(cam);
1261                 ret = cafe_free_sio_buffers (cam);
1262                 goto out;
1263         }
1264         /*
1265          * Device needs to be idle and working.  We *could* try to do the
1266          * right thing in S_SPECREAD by shutting things down, but it
1267          * probably doesn't matter.
1268          */
1269         if (cam->state != S_IDLE || (cam->owner && cam->owner != filp)) {
1270                 ret = -EBUSY;
1271                 goto out;
1272         }
1273         cam->owner = filp;
1274
1275         if (req->count < min_buffers)
1276                 req->count = min_buffers;
1277         else if (req->count > max_buffers)
1278                 req->count = max_buffers;
1279         if (cam->n_sbufs > 0) {
1280                 ret = cafe_free_sio_buffers(cam);
1281                 if (ret)
1282                         goto out;
1283         }
1284
1285         cam->sb_bufs = kzalloc(req->count*sizeof(struct cafe_sio_buffer),
1286                         GFP_KERNEL);
1287         if (cam->sb_bufs == NULL) {
1288                 ret = -ENOMEM;
1289                 goto out;
1290         }
1291         for (cam->n_sbufs = 0; cam->n_sbufs < req->count; (cam->n_sbufs++)) {
1292                 ret = cafe_setup_siobuf(cam, cam->n_sbufs);
1293                 if (ret)
1294                         break;
1295         }
1296
1297         if (cam->n_sbufs == 0)  /* no luck at all - ret already set */
1298                 kfree(cam->sb_bufs);
1299         req->count = cam->n_sbufs;  /* In case of partial success */
1300
1301   out:
1302         mutex_unlock(&cam->s_mutex);
1303         return ret;
1304 }
1305
1306
1307 static int cafe_vidioc_querybuf(struct file *filp, void *priv,
1308                 struct v4l2_buffer *buf)
1309 {
1310         struct cafe_camera *cam = filp->private_data;
1311         int ret = -EINVAL;
1312
1313         mutex_lock(&cam->s_mutex);
1314         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1315                 goto out;
1316         if (buf->index < 0 || buf->index >= cam->n_sbufs)
1317                 goto out;
1318         *buf = cam->sb_bufs[buf->index].v4lbuf;
1319         ret = 0;
1320   out:
1321         mutex_unlock(&cam->s_mutex);
1322         return ret;
1323 }
1324
1325 static int cafe_vidioc_qbuf(struct file *filp, void *priv,
1326                 struct v4l2_buffer *buf)
1327 {
1328         struct cafe_camera *cam = filp->private_data;
1329         struct cafe_sio_buffer *sbuf;
1330         int ret = -EINVAL;
1331         unsigned long flags;
1332
1333         mutex_lock(&cam->s_mutex);
1334         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1335                 goto out;
1336         if (buf->index < 0 || buf->index >= cam->n_sbufs)
1337                 goto out;
1338         sbuf = cam->sb_bufs + buf->index;
1339         if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_QUEUED) {
1340                 ret = 0; /* Already queued?? */
1341                 goto out;
1342         }
1343         if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_DONE) {
1344                 /* Spec doesn't say anything, seems appropriate tho */
1345                 ret = -EBUSY;
1346                 goto out;
1347         }
1348         sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_QUEUED;
1349         spin_lock_irqsave(&cam->dev_lock, flags);
1350         list_add(&sbuf->list, &cam->sb_avail);
1351         spin_unlock_irqrestore(&cam->dev_lock, flags);
1352         ret = 0;
1353   out:
1354         mutex_unlock(&cam->s_mutex);
1355         return ret;
1356 }
1357
1358 static int cafe_vidioc_dqbuf(struct file *filp, void *priv,
1359                 struct v4l2_buffer *buf)
1360 {
1361         struct cafe_camera *cam = filp->private_data;
1362         struct cafe_sio_buffer *sbuf;
1363         int ret = -EINVAL;
1364         unsigned long flags;
1365
1366         mutex_lock(&cam->s_mutex);
1367         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1368                 goto out_unlock;
1369         if (cam->state != S_STREAMING)
1370                 goto out_unlock;
1371         if (list_empty(&cam->sb_full) && filp->f_flags & O_NONBLOCK) {
1372                 ret = -EAGAIN;
1373                 goto out_unlock;
1374         }
1375
1376         while (list_empty(&cam->sb_full) && cam->state == S_STREAMING) {
1377                 mutex_unlock(&cam->s_mutex);
1378                 if (wait_event_interruptible(cam->iowait,
1379                                                 !list_empty(&cam->sb_full))) {
1380                         ret = -ERESTARTSYS;
1381                         goto out;
1382                 }
1383                 mutex_lock(&cam->s_mutex);
1384         }
1385
1386         if (cam->state != S_STREAMING)
1387                 ret = -EINTR;
1388         else {
1389                 spin_lock_irqsave(&cam->dev_lock, flags);
1390                 /* Should probably recheck !list_empty() here */
1391                 sbuf = list_entry(cam->sb_full.next,
1392                                 struct cafe_sio_buffer, list);
1393                 list_del_init(&sbuf->list);
1394                 spin_unlock_irqrestore(&cam->dev_lock, flags);
1395                 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_DONE;
1396                 *buf = sbuf->v4lbuf;
1397                 ret = 0;
1398         }
1399
1400   out_unlock:
1401         mutex_unlock(&cam->s_mutex);
1402   out:
1403         return ret;
1404 }
1405
1406
1407
1408 static void cafe_v4l_vm_open(struct vm_area_struct *vma)
1409 {
1410         struct cafe_sio_buffer *sbuf = vma->vm_private_data;
1411         /*
1412          * Locking: done under mmap_sem, so we don't need to
1413          * go back to the camera lock here.
1414          */
1415         sbuf->mapcount++;
1416 }
1417
1418
1419 static void cafe_v4l_vm_close(struct vm_area_struct *vma)
1420 {
1421         struct cafe_sio_buffer *sbuf = vma->vm_private_data;
1422
1423         mutex_lock(&sbuf->cam->s_mutex);
1424         sbuf->mapcount--;
1425         /* Docs say we should stop I/O too... */
1426         if (sbuf->mapcount == 0)
1427                 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_MAPPED;
1428         mutex_unlock(&sbuf->cam->s_mutex);
1429 }
1430
1431 static struct vm_operations_struct cafe_v4l_vm_ops = {
1432         .open = cafe_v4l_vm_open,
1433         .close = cafe_v4l_vm_close
1434 };
1435
1436
1437 static int cafe_v4l_mmap(struct file *filp, struct vm_area_struct *vma)
1438 {
1439         struct cafe_camera *cam = filp->private_data;
1440         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1441         int ret = -EINVAL;
1442         int i;
1443         struct cafe_sio_buffer *sbuf = NULL;
1444
1445         if (! (vma->vm_flags & VM_WRITE) || ! (vma->vm_flags & VM_SHARED))
1446                 return -EINVAL;
1447         /*
1448          * Find the buffer they are looking for.
1449          */
1450         mutex_lock(&cam->s_mutex);
1451         for (i = 0; i < cam->n_sbufs; i++)
1452                 if (cam->sb_bufs[i].v4lbuf.m.offset == offset) {
1453                         sbuf = cam->sb_bufs + i;
1454                         break;
1455                 }
1456         if (sbuf == NULL)
1457                 goto out;
1458
1459         ret = remap_vmalloc_range(vma, sbuf->buffer, 0);
1460         if (ret)
1461                 goto out;
1462         vma->vm_flags |= VM_DONTEXPAND;
1463         vma->vm_private_data = sbuf;
1464         vma->vm_ops = &cafe_v4l_vm_ops;
1465         sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_MAPPED;
1466         cafe_v4l_vm_open(vma);
1467         ret = 0;
1468   out:
1469         mutex_unlock(&cam->s_mutex);
1470         return ret;
1471 }
1472
1473
1474
1475 static int cafe_v4l_open(struct inode *inode, struct file *filp)
1476 {
1477         struct cafe_camera *cam;
1478
1479         cam = cafe_find_dev(iminor(inode));
1480         if (cam == NULL)
1481                 return -ENODEV;
1482         filp->private_data = cam;
1483
1484         mutex_lock(&cam->s_mutex);
1485         if (cam->users == 0) {
1486                 cafe_ctlr_power_up(cam);
1487                 __cafe_cam_reset(cam);
1488                 cafe_set_config_needed(cam, 1);
1489         /* FIXME make sure this is complete */
1490         }
1491         (cam->users)++;
1492         mutex_unlock(&cam->s_mutex);
1493         return 0;
1494 }
1495
1496
1497 static int cafe_v4l_release(struct inode *inode, struct file *filp)
1498 {
1499         struct cafe_camera *cam = filp->private_data;
1500
1501         mutex_lock(&cam->s_mutex);
1502         (cam->users)--;
1503         if (filp == cam->owner) {
1504                 cafe_ctlr_stop_dma(cam);
1505                 cafe_free_sio_buffers(cam);
1506                 cam->owner = NULL;
1507         }
1508         if (cam->users == 0) {
1509                 cafe_ctlr_power_down(cam);
1510                 if (alloc_bufs_at_read)
1511                         cafe_free_dma_bufs(cam);
1512         }
1513         mutex_unlock(&cam->s_mutex);
1514         return 0;
1515 }
1516
1517
1518
1519 static unsigned int cafe_v4l_poll(struct file *filp,
1520                 struct poll_table_struct *pt)
1521 {
1522         struct cafe_camera *cam = filp->private_data;
1523
1524         poll_wait(filp, &cam->iowait, pt);
1525         if (cam->next_buf >= 0)
1526                 return POLLIN | POLLRDNORM;
1527         return 0;
1528 }
1529
1530
1531
1532 static int cafe_vidioc_queryctrl(struct file *filp, void *priv,
1533                 struct v4l2_queryctrl *qc)
1534 {
1535         struct cafe_camera *cam = filp->private_data;
1536         int ret;
1537
1538         mutex_lock(&cam->s_mutex);
1539         ret = __cafe_cam_cmd(cam, VIDIOC_QUERYCTRL, qc);
1540         mutex_unlock(&cam->s_mutex);
1541         return ret;
1542 }
1543
1544
1545 static int cafe_vidioc_g_ctrl(struct file *filp, void *priv,
1546                 struct v4l2_control *ctrl)
1547 {
1548         struct cafe_camera *cam = filp->private_data;
1549         int ret;
1550
1551         mutex_lock(&cam->s_mutex);
1552         ret = __cafe_cam_cmd(cam, VIDIOC_G_CTRL, ctrl);
1553         mutex_unlock(&cam->s_mutex);
1554         return ret;
1555 }
1556
1557
1558 static int cafe_vidioc_s_ctrl(struct file *filp, void *priv,
1559                 struct v4l2_control *ctrl)
1560 {
1561         struct cafe_camera *cam = filp->private_data;
1562         int ret;
1563
1564         mutex_lock(&cam->s_mutex);
1565         ret = __cafe_cam_cmd(cam, VIDIOC_S_CTRL, ctrl);
1566         mutex_unlock(&cam->s_mutex);
1567         return ret;
1568 }
1569
1570
1571
1572
1573
1574 static int cafe_vidioc_querycap(struct file *file, void *priv,
1575                 struct v4l2_capability *cap)
1576 {
1577         strcpy(cap->driver, "cafe_ccic");
1578         strcpy(cap->card, "cafe_ccic");
1579         cap->version = CAFE_VERSION;
1580         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1581                 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1582         return 0;
1583 }
1584
1585
1586 /*
1587  * The default format we use until somebody says otherwise.
1588  */
1589 static struct v4l2_pix_format cafe_def_pix_format = {
1590         .width          = VGA_WIDTH,
1591         .height         = VGA_HEIGHT,
1592         .pixelformat    = V4L2_PIX_FMT_YUYV,
1593         .field          = V4L2_FIELD_NONE,
1594         .bytesperline   = VGA_WIDTH*2,
1595         .sizeimage      = VGA_WIDTH*VGA_HEIGHT*2,
1596 };
1597
1598 static int cafe_vidioc_enum_fmt_vid_cap(struct file *filp,
1599                 void *priv, struct v4l2_fmtdesc *fmt)
1600 {
1601         struct cafe_camera *cam = priv;
1602         int ret;
1603
1604         if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1605                 return -EINVAL;
1606         mutex_lock(&cam->s_mutex);
1607         ret = __cafe_cam_cmd(cam, VIDIOC_ENUM_FMT, fmt);
1608         mutex_unlock(&cam->s_mutex);
1609         return ret;
1610 }
1611
1612
1613 static int cafe_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
1614                 struct v4l2_format *fmt)
1615 {
1616         struct cafe_camera *cam = priv;
1617         int ret;
1618
1619         mutex_lock(&cam->s_mutex);
1620         ret = __cafe_cam_cmd(cam, VIDIOC_TRY_FMT, fmt);
1621         mutex_unlock(&cam->s_mutex);
1622         return ret;
1623 }
1624
1625 static int cafe_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
1626                 struct v4l2_format *fmt)
1627 {
1628         struct cafe_camera *cam = priv;
1629         int ret;
1630
1631         /*
1632          * Can't do anything if the device is not idle
1633          * Also can't if there are streaming buffers in place.
1634          */
1635         if (cam->state != S_IDLE || cam->n_sbufs > 0)
1636                 return -EBUSY;
1637         /*
1638          * See if the formatting works in principle.
1639          */
1640         ret = cafe_vidioc_try_fmt_vid_cap(filp, priv, fmt);
1641         if (ret)
1642                 return ret;
1643         /*
1644          * Now we start to change things for real, so let's do it
1645          * under lock.
1646          */
1647         mutex_lock(&cam->s_mutex);
1648         cam->pix_format = fmt->fmt.pix;
1649         /*
1650          * Make sure we have appropriate DMA buffers.
1651          */
1652         ret = -ENOMEM;
1653         if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
1654                 cafe_free_dma_bufs(cam);
1655         if (cam->nbufs == 0) {
1656                 if (cafe_alloc_dma_bufs(cam, 0))
1657                         goto out;
1658         }
1659         /*
1660          * It looks like this might work, so let's program the sensor.
1661          */
1662         ret = cafe_cam_configure(cam);
1663         if (! ret)
1664                 ret = cafe_ctlr_configure(cam);
1665   out:
1666         mutex_unlock(&cam->s_mutex);
1667         return ret;
1668 }
1669
1670 /*
1671  * Return our stored notion of how the camera is/should be configured.
1672  * The V4l2 spec wants us to be smarter, and actually get this from
1673  * the camera (and not mess with it at open time).  Someday.
1674  */
1675 static int cafe_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
1676                 struct v4l2_format *f)
1677 {
1678         struct cafe_camera *cam = priv;
1679
1680         f->fmt.pix = cam->pix_format;
1681         return 0;
1682 }
1683
1684 /*
1685  * We only have one input - the sensor - so minimize the nonsense here.
1686  */
1687 static int cafe_vidioc_enum_input(struct file *filp, void *priv,
1688                 struct v4l2_input *input)
1689 {
1690         if (input->index != 0)
1691                 return -EINVAL;
1692
1693         input->type = V4L2_INPUT_TYPE_CAMERA;
1694         input->std = V4L2_STD_ALL; /* Not sure what should go here */
1695         strcpy(input->name, "Camera");
1696         return 0;
1697 }
1698
1699 static int cafe_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
1700 {
1701         *i = 0;
1702         return 0;
1703 }
1704
1705 static int cafe_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1706 {
1707         if (i != 0)
1708                 return -EINVAL;
1709         return 0;
1710 }
1711
1712 /* from vivi.c */
1713 static int cafe_vidioc_s_std(struct file *filp, void *priv, v4l2_std_id *a)
1714 {
1715         return 0;
1716 }
1717
1718 /*
1719  * G/S_PARM.  Most of this is done by the sensor, but we are
1720  * the level which controls the number of read buffers.
1721  */
1722 static int cafe_vidioc_g_parm(struct file *filp, void *priv,
1723                 struct v4l2_streamparm *parms)
1724 {
1725         struct cafe_camera *cam = priv;
1726         int ret;
1727
1728         mutex_lock(&cam->s_mutex);
1729         ret = __cafe_cam_cmd(cam, VIDIOC_G_PARM, parms);
1730         mutex_unlock(&cam->s_mutex);
1731         parms->parm.capture.readbuffers = n_dma_bufs;
1732         return ret;
1733 }
1734
1735 static int cafe_vidioc_s_parm(struct file *filp, void *priv,
1736                 struct v4l2_streamparm *parms)
1737 {
1738         struct cafe_camera *cam = priv;
1739         int ret;
1740
1741         mutex_lock(&cam->s_mutex);
1742         ret = __cafe_cam_cmd(cam, VIDIOC_S_PARM, parms);
1743         mutex_unlock(&cam->s_mutex);
1744         parms->parm.capture.readbuffers = n_dma_bufs;
1745         return ret;
1746 }
1747
1748
1749 static void cafe_v4l_dev_release(struct video_device *vd)
1750 {
1751         struct cafe_camera *cam = container_of(vd, struct cafe_camera, v4ldev);
1752
1753         kfree(cam);
1754 }
1755
1756
1757 /*
1758  * This template device holds all of those v4l2 methods; we
1759  * clone it for specific real devices.
1760  */
1761
1762 static const struct file_operations cafe_v4l_fops = {
1763         .owner = THIS_MODULE,
1764         .open = cafe_v4l_open,
1765         .release = cafe_v4l_release,
1766         .read = cafe_v4l_read,
1767         .poll = cafe_v4l_poll,
1768         .mmap = cafe_v4l_mmap,
1769         .ioctl = video_ioctl2,
1770         .llseek = no_llseek,
1771 };
1772
1773 static const struct v4l2_ioctl_ops cafe_v4l_ioctl_ops = {
1774         .vidioc_querycap        = cafe_vidioc_querycap,
1775         .vidioc_enum_fmt_vid_cap = cafe_vidioc_enum_fmt_vid_cap,
1776         .vidioc_try_fmt_vid_cap = cafe_vidioc_try_fmt_vid_cap,
1777         .vidioc_s_fmt_vid_cap   = cafe_vidioc_s_fmt_vid_cap,
1778         .vidioc_g_fmt_vid_cap   = cafe_vidioc_g_fmt_vid_cap,
1779         .vidioc_enum_input      = cafe_vidioc_enum_input,
1780         .vidioc_g_input         = cafe_vidioc_g_input,
1781         .vidioc_s_input         = cafe_vidioc_s_input,
1782         .vidioc_s_std           = cafe_vidioc_s_std,
1783         .vidioc_reqbufs         = cafe_vidioc_reqbufs,
1784         .vidioc_querybuf        = cafe_vidioc_querybuf,
1785         .vidioc_qbuf            = cafe_vidioc_qbuf,
1786         .vidioc_dqbuf           = cafe_vidioc_dqbuf,
1787         .vidioc_streamon        = cafe_vidioc_streamon,
1788         .vidioc_streamoff       = cafe_vidioc_streamoff,
1789         .vidioc_queryctrl       = cafe_vidioc_queryctrl,
1790         .vidioc_g_ctrl          = cafe_vidioc_g_ctrl,
1791         .vidioc_s_ctrl          = cafe_vidioc_s_ctrl,
1792         .vidioc_g_parm          = cafe_vidioc_g_parm,
1793         .vidioc_s_parm          = cafe_vidioc_s_parm,
1794 };
1795
1796 static struct video_device cafe_v4l_template = {
1797         .name = "cafe",
1798         .minor = -1, /* Get one dynamically */
1799         .tvnorms = V4L2_STD_NTSC_M,
1800         .current_norm = V4L2_STD_NTSC_M,  /* make mplayer happy */
1801
1802         .fops = &cafe_v4l_fops,
1803         .ioctl_ops = &cafe_v4l_ioctl_ops,
1804         .release = cafe_v4l_dev_release,
1805 };
1806
1807
1808
1809
1810
1811
1812
1813 /* ---------------------------------------------------------------------- */
1814 /*
1815  * Interrupt handler stuff
1816  */
1817
1818
1819
1820 static void cafe_frame_tasklet(unsigned long data)
1821 {
1822         struct cafe_camera *cam = (struct cafe_camera *) data;
1823         int i;
1824         unsigned long flags;
1825         struct cafe_sio_buffer *sbuf;
1826
1827         spin_lock_irqsave(&cam->dev_lock, flags);
1828         for (i = 0; i < cam->nbufs; i++) {
1829                 int bufno = cam->next_buf;
1830                 if (bufno < 0) {  /* "will never happen" */
1831                         cam_err(cam, "No valid bufs in tasklet!\n");
1832                         break;
1833                 }
1834                 if (++(cam->next_buf) >= cam->nbufs)
1835                         cam->next_buf = 0;
1836                 if (! test_bit(bufno, &cam->flags))
1837                         continue;
1838                 if (list_empty(&cam->sb_avail))
1839                         break;  /* Leave it valid, hope for better later */
1840                 clear_bit(bufno, &cam->flags);
1841                 sbuf = list_entry(cam->sb_avail.next,
1842                                 struct cafe_sio_buffer, list);
1843                 /*
1844                  * Drop the lock during the big copy.  This *should* be safe...
1845                  */
1846                 spin_unlock_irqrestore(&cam->dev_lock, flags);
1847                 memcpy(sbuf->buffer, cam->dma_bufs[bufno],
1848                                 cam->pix_format.sizeimage);
1849                 sbuf->v4lbuf.bytesused = cam->pix_format.sizeimage;
1850                 sbuf->v4lbuf.sequence = cam->buf_seq[bufno];
1851                 sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
1852                 sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
1853                 spin_lock_irqsave(&cam->dev_lock, flags);
1854                 list_move_tail(&sbuf->list, &cam->sb_full);
1855         }
1856         if (! list_empty(&cam->sb_full))
1857                 wake_up(&cam->iowait);
1858         spin_unlock_irqrestore(&cam->dev_lock, flags);
1859 }
1860
1861
1862
1863 static void cafe_frame_complete(struct cafe_camera *cam, int frame)
1864 {
1865         /*
1866          * Basic frame housekeeping.
1867          */
1868         if (test_bit(frame, &cam->flags) && printk_ratelimit())
1869                 cam_err(cam, "Frame overrun on %d, frames lost\n", frame);
1870         set_bit(frame, &cam->flags);
1871         clear_bit(CF_DMA_ACTIVE, &cam->flags);
1872         if (cam->next_buf < 0)
1873                 cam->next_buf = frame;
1874         cam->buf_seq[frame] = ++(cam->sequence);
1875
1876         switch (cam->state) {
1877         /*
1878          * If in single read mode, try going speculative.
1879          */
1880             case S_SINGLEREAD:
1881                 cam->state = S_SPECREAD;
1882                 cam->specframes = 0;
1883                 wake_up(&cam->iowait);
1884                 break;
1885
1886         /*
1887          * If we are already doing speculative reads, and nobody is
1888          * reading them, just stop.
1889          */
1890             case S_SPECREAD:
1891                 if (++(cam->specframes) >= cam->nbufs) {
1892                         cafe_ctlr_stop(cam);
1893                         cafe_ctlr_irq_disable(cam);
1894                         cam->state = S_IDLE;
1895                 }
1896                 wake_up(&cam->iowait);
1897                 break;
1898         /*
1899          * For the streaming case, we defer the real work to the
1900          * camera tasklet.
1901          *
1902          * FIXME: if the application is not consuming the buffers,
1903          * we should eventually put things on hold and restart in
1904          * vidioc_dqbuf().
1905          */
1906             case S_STREAMING:
1907                 tasklet_schedule(&cam->s_tasklet);
1908                 break;
1909
1910             default:
1911                 cam_err(cam, "Frame interrupt in non-operational state\n");
1912                 break;
1913         }
1914 }
1915
1916
1917
1918
1919 static void cafe_frame_irq(struct cafe_camera *cam, unsigned int irqs)
1920 {
1921         unsigned int frame;
1922
1923         cafe_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
1924         /*
1925          * Handle any frame completions.  There really should
1926          * not be more than one of these, or we have fallen
1927          * far behind.
1928          */
1929         for (frame = 0; frame < cam->nbufs; frame++)
1930                 if (irqs & (IRQ_EOF0 << frame))
1931                         cafe_frame_complete(cam, frame);
1932         /*
1933          * If a frame starts, note that we have DMA active.  This
1934          * code assumes that we won't get multiple frame interrupts
1935          * at once; may want to rethink that.
1936          */
1937         if (irqs & (IRQ_SOF0 | IRQ_SOF1 | IRQ_SOF2))
1938                 set_bit(CF_DMA_ACTIVE, &cam->flags);
1939 }
1940
1941
1942
1943 static irqreturn_t cafe_irq(int irq, void *data)
1944 {
1945         struct cafe_camera *cam = data;
1946         unsigned int irqs;
1947
1948         spin_lock(&cam->dev_lock);
1949         irqs = cafe_reg_read(cam, REG_IRQSTAT);
1950         if ((irqs & ALLIRQS) == 0) {
1951                 spin_unlock(&cam->dev_lock);
1952                 return IRQ_NONE;
1953         }
1954         if (irqs & FRAMEIRQS)
1955                 cafe_frame_irq(cam, irqs);
1956         if (irqs & TWSIIRQS) {
1957                 cafe_reg_write(cam, REG_IRQSTAT, TWSIIRQS);
1958                 wake_up(&cam->smbus_wait);
1959         }
1960         spin_unlock(&cam->dev_lock);
1961         return IRQ_HANDLED;
1962 }
1963
1964
1965 /* -------------------------------------------------------------------------- */
1966 #ifdef CONFIG_VIDEO_ADV_DEBUG
1967 /*
1968  * Debugfs stuff.
1969  */
1970
1971 static char cafe_debug_buf[1024];
1972 static struct dentry *cafe_dfs_root;
1973
1974 static void cafe_dfs_setup(void)
1975 {
1976         cafe_dfs_root = debugfs_create_dir("cafe_ccic", NULL);
1977         if (IS_ERR(cafe_dfs_root)) {
1978                 cafe_dfs_root = NULL;  /* Never mind */
1979                 printk(KERN_NOTICE "cafe_ccic unable to set up debugfs\n");
1980         }
1981 }
1982
1983 static void cafe_dfs_shutdown(void)
1984 {
1985         if (cafe_dfs_root)
1986                 debugfs_remove(cafe_dfs_root);
1987 }
1988
1989 static int cafe_dfs_open(struct inode *inode, struct file *file)
1990 {
1991         file->private_data = inode->i_private;
1992         return 0;
1993 }
1994
1995 static ssize_t cafe_dfs_read_regs(struct file *file,
1996                 char __user *buf, size_t count, loff_t *ppos)
1997 {
1998         struct cafe_camera *cam = file->private_data;
1999         char *s = cafe_debug_buf;
2000         int offset;
2001
2002         for (offset = 0; offset < 0x44; offset += 4)
2003                 s += sprintf(s, "%02x: %08x\n", offset,
2004                                 cafe_reg_read(cam, offset));
2005         for (offset = 0x88; offset <= 0x90; offset += 4)
2006                 s += sprintf(s, "%02x: %08x\n", offset,
2007                                 cafe_reg_read(cam, offset));
2008         for (offset = 0xb4; offset <= 0xbc; offset += 4)
2009                 s += sprintf(s, "%02x: %08x\n", offset,
2010                                 cafe_reg_read(cam, offset));
2011         for (offset = 0x3000; offset <= 0x300c; offset += 4)
2012                 s += sprintf(s, "%04x: %08x\n", offset,
2013                                 cafe_reg_read(cam, offset));
2014         return simple_read_from_buffer(buf, count, ppos, cafe_debug_buf,
2015                         s - cafe_debug_buf);
2016 }
2017
2018 static const struct file_operations cafe_dfs_reg_ops = {
2019         .owner = THIS_MODULE,
2020         .read = cafe_dfs_read_regs,
2021         .open = cafe_dfs_open
2022 };
2023
2024 static ssize_t cafe_dfs_read_cam(struct file *file,
2025                 char __user *buf, size_t count, loff_t *ppos)
2026 {
2027         struct cafe_camera *cam = file->private_data;
2028         char *s = cafe_debug_buf;
2029         int offset;
2030
2031         if (! cam->sensor)
2032                 return -EINVAL;
2033         for (offset = 0x0; offset < 0x8a; offset++)
2034         {
2035                 u8 v;
2036
2037                 cafe_smbus_read_data(cam, cam->sensor->addr, offset, &v);
2038                 s += sprintf(s, "%02x: %02x\n", offset, v);
2039         }
2040         return simple_read_from_buffer(buf, count, ppos, cafe_debug_buf,
2041                         s - cafe_debug_buf);
2042 }
2043
2044 static const struct file_operations cafe_dfs_cam_ops = {
2045         .owner = THIS_MODULE,
2046         .read = cafe_dfs_read_cam,
2047         .open = cafe_dfs_open
2048 };
2049
2050
2051
2052 static void cafe_dfs_cam_setup(struct cafe_camera *cam)
2053 {
2054         char fname[40];
2055
2056         if (!cafe_dfs_root)
2057                 return;
2058         sprintf(fname, "regs-%d", cam->v4ldev.num);
2059         cam->dfs_regs = debugfs_create_file(fname, 0444, cafe_dfs_root,
2060                         cam, &cafe_dfs_reg_ops);
2061         sprintf(fname, "cam-%d", cam->v4ldev.num);
2062         cam->dfs_cam_regs = debugfs_create_file(fname, 0444, cafe_dfs_root,
2063                         cam, &cafe_dfs_cam_ops);
2064 }
2065
2066
2067 static void cafe_dfs_cam_shutdown(struct cafe_camera *cam)
2068 {
2069         if (! IS_ERR(cam->dfs_regs))
2070                 debugfs_remove(cam->dfs_regs);
2071         if (! IS_ERR(cam->dfs_cam_regs))
2072                 debugfs_remove(cam->dfs_cam_regs);
2073 }
2074
2075 #else
2076
2077 #define cafe_dfs_setup()
2078 #define cafe_dfs_shutdown()
2079 #define cafe_dfs_cam_setup(cam)
2080 #define cafe_dfs_cam_shutdown(cam)
2081 #endif    /* CONFIG_VIDEO_ADV_DEBUG */
2082
2083
2084
2085
2086 /* ------------------------------------------------------------------------*/
2087 /*
2088  * PCI interface stuff.
2089  */
2090
2091 static int cafe_pci_probe(struct pci_dev *pdev,
2092                 const struct pci_device_id *id)
2093 {
2094         int ret;
2095         struct cafe_camera *cam;
2096
2097         /*
2098          * Start putting together one of our big camera structures.
2099          */
2100         ret = -ENOMEM;
2101         cam = kzalloc(sizeof(struct cafe_camera), GFP_KERNEL);
2102         if (cam == NULL)
2103                 goto out;
2104         mutex_init(&cam->s_mutex);
2105         mutex_lock(&cam->s_mutex);
2106         spin_lock_init(&cam->dev_lock);
2107         cam->state = S_NOTREADY;
2108         cafe_set_config_needed(cam, 1);
2109         init_waitqueue_head(&cam->smbus_wait);
2110         init_waitqueue_head(&cam->iowait);
2111         cam->pdev = pdev;
2112         cam->pix_format = cafe_def_pix_format;
2113         INIT_LIST_HEAD(&cam->dev_list);
2114         INIT_LIST_HEAD(&cam->sb_avail);
2115         INIT_LIST_HEAD(&cam->sb_full);
2116         tasklet_init(&cam->s_tasklet, cafe_frame_tasklet, (unsigned long) cam);
2117         /*
2118          * Get set up on the PCI bus.
2119          */
2120         ret = pci_enable_device(pdev);
2121         if (ret)
2122                 goto out_free;
2123         pci_set_master(pdev);
2124
2125         ret = -EIO;
2126         cam->regs = pci_iomap(pdev, 0, 0);
2127         if (! cam->regs) {
2128                 printk(KERN_ERR "Unable to ioremap cafe-ccic regs\n");
2129                 goto out_free;
2130         }
2131         ret = request_irq(pdev->irq, cafe_irq, IRQF_SHARED, "cafe-ccic", cam);
2132         if (ret)
2133                 goto out_iounmap;
2134         /*
2135          * Initialize the controller and leave it powered up.  It will
2136          * stay that way until the sensor driver shows up.
2137          */
2138         cafe_ctlr_init(cam);
2139         cafe_ctlr_power_up(cam);
2140         /*
2141          * Set up I2C/SMBUS communications.  We have to drop the mutex here
2142          * because the sensor could attach in this call chain, leading to
2143          * unsightly deadlocks.
2144          */
2145         mutex_unlock(&cam->s_mutex);  /* attach can deadlock */
2146         ret = cafe_smbus_setup(cam);
2147         if (ret)
2148                 goto out_freeirq;
2149         /*
2150          * Get the v4l2 setup done.
2151          */
2152         mutex_lock(&cam->s_mutex);
2153         cam->v4ldev = cafe_v4l_template;
2154         cam->v4ldev.debug = 0;
2155 //      cam->v4ldev.debug = V4L2_DEBUG_IOCTL_ARG;
2156         cam->v4ldev.parent = &pdev->dev;
2157         ret = video_register_device(&cam->v4ldev, VFL_TYPE_GRABBER, -1);
2158         if (ret)
2159                 goto out_smbus;
2160         /*
2161          * If so requested, try to get our DMA buffers now.
2162          */
2163         if (!alloc_bufs_at_read) {
2164                 if (cafe_alloc_dma_bufs(cam, 1))
2165                         cam_warn(cam, "Unable to alloc DMA buffers at load"
2166                                         " will try again later.");
2167         }
2168
2169         cafe_dfs_cam_setup(cam);
2170         mutex_unlock(&cam->s_mutex);
2171         cafe_add_dev(cam);
2172         return 0;
2173
2174   out_smbus:
2175         cafe_smbus_shutdown(cam);
2176   out_freeirq:
2177         cafe_ctlr_power_down(cam);
2178         free_irq(pdev->irq, cam);
2179   out_iounmap:
2180         pci_iounmap(pdev, cam->regs);
2181   out_free:
2182         kfree(cam);
2183   out:
2184         return ret;
2185 }
2186
2187
2188 /*
2189  * Shut down an initialized device
2190  */
2191 static void cafe_shutdown(struct cafe_camera *cam)
2192 {
2193 /* FIXME: Make sure we take care of everything here */
2194         cafe_dfs_cam_shutdown(cam);
2195         if (cam->n_sbufs > 0)
2196                 /* What if they are still mapped?  Shouldn't be, but... */
2197                 cafe_free_sio_buffers(cam);
2198         cafe_remove_dev(cam);
2199         cafe_ctlr_stop_dma(cam);
2200         cafe_ctlr_power_down(cam);
2201         cafe_smbus_shutdown(cam);
2202         cafe_free_dma_bufs(cam);
2203         free_irq(cam->pdev->irq, cam);
2204         pci_iounmap(cam->pdev, cam->regs);
2205         video_unregister_device(&cam->v4ldev);
2206         /* kfree(cam); done in v4l_release () */
2207 }
2208
2209
2210 static void cafe_pci_remove(struct pci_dev *pdev)
2211 {
2212         struct cafe_camera *cam = cafe_find_by_pdev(pdev);
2213
2214         if (cam == NULL) {
2215                 printk(KERN_WARNING "pci_remove on unknown pdev %p\n", pdev);
2216                 return;
2217         }
2218         mutex_lock(&cam->s_mutex);
2219         if (cam->users > 0)
2220                 cam_warn(cam, "Removing a device with users!\n");
2221         cafe_shutdown(cam);
2222 /* No unlock - it no longer exists */
2223 }
2224
2225
2226 #ifdef CONFIG_PM
2227 /*
2228  * Basic power management.
2229  */
2230 static int cafe_pci_suspend(struct pci_dev *pdev, pm_message_t state)
2231 {
2232         struct cafe_camera *cam = cafe_find_by_pdev(pdev);
2233         int ret;
2234         enum cafe_state cstate;
2235
2236         ret = pci_save_state(pdev);
2237         if (ret)
2238                 return ret;
2239         cstate = cam->state; /* HACK - stop_dma sets to idle */
2240         cafe_ctlr_stop_dma(cam);
2241         cafe_ctlr_power_down(cam);
2242         pci_disable_device(pdev);
2243         cam->state = cstate;
2244         return 0;
2245 }
2246
2247
2248 static int cafe_pci_resume(struct pci_dev *pdev)
2249 {
2250         struct cafe_camera *cam = cafe_find_by_pdev(pdev);
2251         int ret = 0;
2252
2253         ret = pci_restore_state(pdev);
2254         if (ret)
2255                 return ret;
2256         ret = pci_enable_device(pdev);
2257
2258         if (ret) {
2259                 cam_warn(cam, "Unable to re-enable device on resume!\n");
2260                 return ret;
2261         }
2262         cafe_ctlr_init(cam);
2263         cafe_ctlr_power_down(cam);
2264
2265         mutex_lock(&cam->s_mutex);
2266         if (cam->users > 0) {
2267                 cafe_ctlr_power_up(cam);
2268                 __cafe_cam_reset(cam);
2269         }
2270         mutex_unlock(&cam->s_mutex);
2271
2272         set_bit(CF_CONFIG_NEEDED, &cam->flags);
2273         if (cam->state == S_SPECREAD)
2274                 cam->state = S_IDLE;  /* Don't bother restarting */
2275         else if (cam->state == S_SINGLEREAD || cam->state == S_STREAMING)
2276                 ret = cafe_read_setup(cam, cam->state);
2277         return ret;
2278 }
2279
2280 #endif  /* CONFIG_PM */
2281
2282
2283 static struct pci_device_id cafe_ids[] = {
2284         { PCI_DEVICE(PCI_VENDOR_ID_MARVELL,
2285                      PCI_DEVICE_ID_MARVELL_88ALP01_CCIC) },
2286         { 0, }
2287 };
2288
2289 MODULE_DEVICE_TABLE(pci, cafe_ids);
2290
2291 static struct pci_driver cafe_pci_driver = {
2292         .name = "cafe1000-ccic",
2293         .id_table = cafe_ids,
2294         .probe = cafe_pci_probe,
2295         .remove = cafe_pci_remove,
2296 #ifdef CONFIG_PM
2297         .suspend = cafe_pci_suspend,
2298         .resume = cafe_pci_resume,
2299 #endif
2300 };
2301
2302
2303
2304
2305 static int __init cafe_init(void)
2306 {
2307         int ret;
2308
2309         printk(KERN_NOTICE "Marvell M88ALP01 'CAFE' Camera Controller version %d\n",
2310                         CAFE_VERSION);
2311         cafe_dfs_setup();
2312         ret = pci_register_driver(&cafe_pci_driver);
2313         if (ret) {
2314                 printk(KERN_ERR "Unable to register cafe_ccic driver\n");
2315                 goto out;
2316         }
2317         request_module("ov7670");  /* FIXME want something more general */
2318         ret = 0;
2319
2320   out:
2321         return ret;
2322 }
2323
2324
2325 static void __exit cafe_exit(void)
2326 {
2327         pci_unregister_driver(&cafe_pci_driver);
2328         cafe_dfs_shutdown();
2329 }
2330
2331 module_init(cafe_init);
2332 module_exit(cafe_exit);