[PATCH] v4l: add TerraTec Cinergy 1400 DVB-T
[linux-2.6] / drivers / media / video / vino.c
1 /*
2  * (incomplete) Driver for the VINO (Video In No Out) system found in SGI Indys.
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License version 2 as published by the Free Software Foundation.
6  *
7  * Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
8  */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/types.h>
13 #include <linux/mm.h>
14 #include <linux/slab.h>
15 #include <linux/wrapper.h>
16 #include <linux/errno.h>
17 #include <linux/irq.h>
18 #include <linux/delay.h>
19 #include <linux/videodev.h>
20 #include <linux/i2c.h>
21 #include <linux/i2c-algo-sgi.h>
22
23 #include <asm/addrspace.h>
24 #include <asm/system.h>
25 #include <asm/bootinfo.h>
26 #include <asm/pgtable.h>
27 #include <asm/paccess.h>
28 #include <asm/io.h>
29 #include <asm/sgi/ip22.h>
30 #include <asm/sgi/hpc3.h>
31 #include <asm/sgi/mc.h>
32
33 #include "vino.h"
34
35 /* debugging? */
36 #if 1
37 #define DEBUG(x...)     printk(x);
38 #else
39 #define DEBUG(x...)
40 #endif
41
42
43 /* VINO ASIC registers */
44 struct sgi_vino *vino;
45
46 static const char *vinostr = "VINO IndyCam/TV";
47 static int threshold_a = 512;
48 static int threshold_b = 512;
49
50 struct vino_device {
51         struct video_device vdev;
52 #define VINO_CHAN_A             1
53 #define VINO_CHAN_B             2
54         int chan;
55 };
56
57 struct vino_client {
58         struct i2c_client *driver;
59         int owner;
60 };
61
62 struct vino_video {
63         struct vino_device chA;
64         struct vino_device chB;
65
66         struct vino_client decoder;
67         struct vino_client camera;
68
69         struct semaphore input_lock;
70
71         /* Loaded into VINO descriptors to clear End Of Descriptors table
72          * interupt condition */
73         unsigned long dummy_page;
74         unsigned int dummy_buf[4] __attribute__((aligned(8)));
75 };
76
77 static struct vino_video *Vino;
78
79 unsigned i2c_vino_getctrl(void *data)
80 {
81         return vino->i2c_control;
82 }
83
84 void i2c_vino_setctrl(void *data, unsigned val)
85 {
86         vino->i2c_control = val;
87 }
88
89 unsigned i2c_vino_rdata(void *data)
90 {
91         return vino->i2c_data;
92 }
93
94 void i2c_vino_wdata(void *data, unsigned val)
95 {
96         vino->i2c_data = val;
97 }
98
99 static struct i2c_algo_sgi_data i2c_sgi_vino_data =
100 {
101         .getctrl = &i2c_vino_getctrl,
102         .setctrl = &i2c_vino_setctrl,
103         .rdata   = &i2c_vino_rdata,
104         .wdata   = &i2c_vino_wdata,
105         .xfer_timeout = 200,
106         .ack_timeout  = 1000,
107 };
108
109 /*
110  * There are two possible clients on VINO I2C bus, so we limit usage only
111  * to them.
112  */
113 static int i2c_vino_client_reg(struct i2c_client *client)
114 {
115         int res = 0;
116
117         down(&Vino->input_lock);
118         switch (client->driver->id) {
119         case I2C_DRIVERID_SAA7191:
120                 if (Vino->decoder.driver)
121                         res = -EBUSY;
122                 else
123                         Vino->decoder.driver = client;
124                 break;
125         case I2C_DRIVERID_INDYCAM:
126                 if (Vino->camera.driver)
127                         res = -EBUSY;
128                 else
129                         Vino->camera.driver = client;
130                 break;
131         default:
132                 res = -ENODEV;
133         }
134         up(&Vino->input_lock);
135
136         return res;
137 }
138
139 static int i2c_vino_client_unreg(struct i2c_client *client)
140 {
141         int res = 0;
142
143         down(&Vino->input_lock);
144         if (client == Vino->decoder.driver) {
145                 if (Vino->decoder.owner)
146                         res = -EBUSY;
147                 else
148                         Vino->decoder.driver = NULL;
149         } else if (client == Vino->camera.driver) {
150                 if (Vino->camera.owner)
151                         res = -EBUSY;
152                 else
153                         Vino->camera.driver = NULL;
154         }
155         up(&Vino->input_lock);
156
157         return res;
158 }
159
160 static struct i2c_adapter vino_i2c_adapter =
161 {
162         .name                   = "VINO I2C bus",
163         .id                     = I2C_HW_SGI_VINO,
164         .algo_data              = &i2c_sgi_vino_data,
165         .client_register        = &i2c_vino_client_reg,
166         .client_unregister      = &i2c_vino_client_unreg,
167 };
168
169 static int vino_i2c_add_bus(void)
170 {
171         return i2c_sgi_add_bus(&vino_i2c_adapter);
172 }
173
174 static int vino_i2c_del_bus(void)
175 {
176         return i2c_sgi_del_bus(&vino_i2c_adapter);
177 }
178
179
180 static void vino_interrupt(int irq, void *dev_id, struct pt_regs *regs)
181 {
182 }
183
184 static int vino_open(struct video_device *dev, int flags)
185 {
186         struct vino_device *videv = (struct vino_device *)dev;
187
188         return 0;
189 }
190
191 static void vino_close(struct video_device *dev)
192 {
193         struct vino_device *videv = (struct vino_device *)dev;
194 }
195
196 static int vino_mmap(struct video_device *dev, const char *adr,
197                      unsigned long size)
198 {
199         struct vino_device *videv = (struct vino_device *)dev;
200
201         return -EINVAL;
202 }
203
204 static int vino_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
205 {
206         struct vino_device *videv = (struct vino_device *)dev;
207
208         return -EINVAL;
209 }
210
211 static const struct video_device vino_device = {
212         .owner          = THIS_MODULE,
213         .type           = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE,
214         .hardware       = VID_HARDWARE_VINO,
215         .name           = "VINO",
216         .open           = vino_open,
217         .close          = vino_close,
218         .ioctl          = vino_ioctl,
219         .mmap           = vino_mmap,
220 };
221
222 static int __init vino_init(void)
223 {
224         unsigned long rev;
225         int i, ret = 0;
226
227         /* VINO is Indy specific beast */
228         if (ip22_is_fullhouse())
229                 return -ENODEV;
230
231         /*
232          * VINO is in the EISA address space, so the sysid register will tell
233          * us if the EISA_PRESENT pin on MC has been pulled low.
234          *
235          * If EISA_PRESENT is not set we definitely don't have a VINO equiped
236          * system.
237          */
238         if (!(sgimc->systemid & SGIMC_SYSID_EPRESENT)) {
239                 printk(KERN_ERR "VINO not found\n");
240                 return -ENODEV;
241         }
242
243         vino = (struct sgi_vino *)ioremap(VINO_BASE, sizeof(struct sgi_vino));
244         if (!vino)
245                 return -EIO;
246
247         /* Okay, once we know that VINO is present we'll read its revision
248          * safe way. One never knows... */
249         if (get_dbe(rev, &(vino->rev_id))) {
250                 printk(KERN_ERR "VINO: failed to read revision register\n");
251                 ret = -ENODEV;
252                 goto out_unmap;
253         }
254         if (VINO_ID_VALUE(rev) != VINO_CHIP_ID) {
255                 printk(KERN_ERR "VINO is not VINO (Rev/ID: 0x%04lx)\n", rev);
256                 ret = -ENODEV;
257                 goto out_unmap;
258         }
259         printk(KERN_INFO "VINO Rev: 0x%02lx\n", VINO_REV_NUM(rev));
260
261         Vino = (struct vino_video *)
262                 kmalloc(sizeof(struct vino_video), GFP_KERNEL);
263         if (!Vino) {
264                 ret = -ENOMEM;
265                 goto out_unmap;
266         }
267
268         Vino->dummy_page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
269         if (!Vino->dummy_page) {
270                 ret = -ENOMEM;
271                 goto out_free_vino;
272         }
273         for (i = 0; i < 4; i++)
274                 Vino->dummy_buf[i] = PHYSADDR(Vino->dummy_page);
275
276         vino->control = 0;
277         /* prevent VINO from throwing spurious interrupts */
278         vino->a.next_4_desc = PHYSADDR(Vino->dummy_buf);
279         vino->b.next_4_desc = PHYSADDR(Vino->dummy_buf);
280         udelay(5);
281         vino->intr_status = 0;
282         /* set threshold level */
283         vino->a.fifo_thres = threshold_a;
284         vino->b.fifo_thres = threshold_b;
285
286         init_MUTEX(&Vino->input_lock);
287
288         if (request_irq(SGI_VINO_IRQ, vino_interrupt, 0, vinostr, NULL)) {
289                 printk(KERN_ERR "VINO: irq%02d registration failed\n",
290                        SGI_VINO_IRQ);
291                 ret = -EAGAIN;
292                 goto out_free_page;
293         }
294
295         ret = vino_i2c_add_bus();
296         if (ret) {
297                 printk(KERN_ERR "VINO: I2C bus registration failed\n");
298                 goto out_free_irq;
299         }
300
301         if (video_register_device(&Vino->chA.vdev, VFL_TYPE_GRABBER, -1) < 0) {
302                 printk("%s, chnl %d: device registration failed.\n",
303                         Vino->chA.vdev.name, Vino->chA.chan);
304                 ret = -EINVAL;
305                 goto out_i2c_del_bus;
306         }
307         if (video_register_device(&Vino->chB.vdev, VFL_TYPE_GRABBER, -1) < 0) {
308                 printk("%s, chnl %d: device registration failed.\n",
309                         Vino->chB.vdev.name, Vino->chB.chan);
310                 ret = -EINVAL;
311                 goto out_unregister_vdev;
312         }
313
314         return 0;
315
316 out_unregister_vdev:
317         video_unregister_device(&Vino->chA.vdev);
318 out_i2c_del_bus:
319         vino_i2c_del_bus();
320 out_free_irq:
321         free_irq(SGI_VINO_IRQ, NULL);
322 out_free_page:
323         free_page(Vino->dummy_page);
324 out_free_vino:
325         kfree(Vino);
326 out_unmap:
327         iounmap(vino);
328
329         return ret;
330 }
331
332 static void __exit vino_exit(void)
333 {
334         video_unregister_device(&Vino->chA.vdev);
335         video_unregister_device(&Vino->chB.vdev);
336         vino_i2c_del_bus();
337         free_irq(SGI_VINO_IRQ, NULL);
338         free_page(Vino->dummy_page);
339         kfree(Vino);
340         iounmap(vino);
341 }
342
343 module_init(vino_init);
344 module_exit(vino_exit);
345
346 MODULE_DESCRIPTION("Video4Linux driver for SGI Indy VINO (IndyCam)");
347 MODULE_LICENSE("GPL");