vfc_dev conversion to mutex: fallout
[linux-2.6.git] / drivers / sbus / char / vfc_dev.c
1 /*
2  * drivers/sbus/char/vfc_dev.c
3  *
4  * Driver for the Videopix Frame Grabber.
5  * 
6  * In order to use the VFC you need to program the video controller
7  * chip. This chip is the Phillips SAA9051.  You need to call their
8  * documentation ordering line to get the docs.
9  *
10  * There is very little documentation on the VFC itself.  There is
11  * some useful info that can be found in the manuals that come with
12  * the card.  I will hopefully write some better docs at a later date.
13  *
14  * Copyright (C) 1996 Manish Vachharajani (mvachhar@noc.rutgers.edu)
15  * */
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/slab.h>
21 #include <linux/errno.h>
22 #include <linux/fs.h>
23 #include <linux/delay.h>
24 #include <linux/spinlock.h>
25 #include <linux/mutex.h>
26 #include <linux/mm.h>
27
28 #include <asm/openprom.h>
29 #include <asm/oplib.h>
30 #include <asm/io.h>
31 #include <asm/system.h>
32 #include <asm/sbus.h>
33 #include <asm/page.h>
34 #include <asm/pgtable.h>
35 #include <asm/uaccess.h>
36
37 #define VFC_MAJOR (60)
38
39 #if 0
40 #define VFC_IOCTL_DEBUG
41 #endif
42
43 #include "vfc.h"
44 #include <asm/vfc_ioctls.h>
45
46 static const struct file_operations vfc_fops;
47 struct vfc_dev **vfc_dev_lst;
48 static char vfcstr[]="vfc";
49 static unsigned char saa9051_init_array[VFC_SAA9051_NR] = {
50         0x00, 0x64, 0x72, 0x52,
51         0x36, 0x18, 0xff, 0x20,
52         0xfc, 0x77, 0xe3, 0x50,
53         0x3e
54 };
55
56 void vfc_lock_device(struct vfc_dev *dev)
57 {
58         mutex_lock(&dev->device_lock_mtx);
59 }
60
61 void vfc_unlock_device(struct vfc_dev *dev)
62 {
63         mutex_unlock(&dev->device_lock_mtx);
64 }
65
66
67 void vfc_captstat_reset(struct vfc_dev *dev) 
68 {
69         dev->control_reg |= VFC_CONTROL_CAPTRESET;
70         sbus_writel(dev->control_reg, &dev->regs->control);
71         dev->control_reg &= ~VFC_CONTROL_CAPTRESET;
72         sbus_writel(dev->control_reg, &dev->regs->control);
73         dev->control_reg |= VFC_CONTROL_CAPTRESET;
74         sbus_writel(dev->control_reg, &dev->regs->control);
75 }
76
77 void vfc_memptr_reset(struct vfc_dev *dev) 
78 {
79         dev->control_reg |= VFC_CONTROL_MEMPTR;
80         sbus_writel(dev->control_reg, &dev->regs->control);
81         dev->control_reg &= ~VFC_CONTROL_MEMPTR;
82         sbus_writel(dev->control_reg, &dev->regs->control);
83         dev->control_reg |= VFC_CONTROL_MEMPTR; 
84         sbus_writel(dev->control_reg, &dev->regs->control);
85 }
86
87 int vfc_csr_init(struct vfc_dev *dev)
88 {
89         dev->control_reg = 0x80000000;
90         sbus_writel(dev->control_reg, &dev->regs->control);
91         udelay(200); 
92         dev->control_reg &= ~0x80000000;
93         sbus_writel(dev->control_reg, &dev->regs->control);
94         udelay(100); 
95         sbus_writel(0x0f000000, &dev->regs->i2c_magic2);
96
97         vfc_memptr_reset(dev);
98
99         dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
100         dev->control_reg &= ~VFC_CONTROL_CAPTURE;
101         dev->control_reg |= 0x40000000;
102         sbus_writel(dev->control_reg, &dev->regs->control);
103
104         vfc_captstat_reset(dev);
105
106         return 0;
107 }
108
109 int vfc_saa9051_init(struct vfc_dev *dev)
110 {
111         int i;
112
113         for (i = 0; i < VFC_SAA9051_NR; i++)
114                 dev->saa9051_state_array[i] = saa9051_init_array[i];
115
116         vfc_i2c_sendbuf(dev,VFC_SAA9051_ADDR,
117                         dev->saa9051_state_array, VFC_SAA9051_NR);
118         return 0;
119 }
120
121 int init_vfc_hw(struct vfc_dev *dev) 
122 {
123         vfc_lock_device(dev);
124         vfc_csr_init(dev);
125
126         vfc_pcf8584_init(dev);
127         vfc_init_i2c_bus(dev); /* hopefully this doesn't undo the magic
128                                   sun code above*/
129         vfc_saa9051_init(dev);
130         vfc_unlock_device(dev);
131         return 0; 
132 }
133
134 int init_vfc_devstruct(struct vfc_dev *dev, int instance) 
135 {
136         dev->instance=instance;
137         mutex_init(&dev->device_lock_mtx);
138         dev->control_reg=0;
139         dev->busy=0;
140         return 0;
141 }
142
143 int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance)
144 {
145         if(dev == NULL) {
146                 printk(KERN_ERR "VFC: Bogus pointer passed\n");
147                 return -ENOMEM;
148         }
149         printk("Initializing vfc%d\n",instance);
150         dev->regs = NULL;
151         dev->regs = (volatile struct vfc_regs __iomem *)
152                 sbus_ioremap(&sdev->resource[0], 0,
153                              sizeof(struct vfc_regs), vfcstr);
154         dev->which_io = sdev->reg_addrs[0].which_io;
155         dev->phys_regs = (struct vfc_regs *) sdev->reg_addrs[0].phys_addr;
156         if (dev->regs == NULL)
157                 return -EIO;
158
159         printk("vfc%d: registers mapped at phys_addr: 0x%lx\n    virt_addr: 0x%lx\n",
160                instance,(unsigned long)sdev->reg_addrs[0].phys_addr,(unsigned long)dev->regs);
161
162         if (init_vfc_devstruct(dev, instance))
163                 return -EINVAL;
164         if (init_vfc_hw(dev))
165                 return -EIO;
166         return 0;
167 }
168
169
170 struct vfc_dev *vfc_get_dev_ptr(int instance) 
171 {
172         return vfc_dev_lst[instance];
173 }
174
175 static DEFINE_SPINLOCK(vfc_dev_lock);
176
177 static int vfc_open(struct inode *inode, struct file *file) 
178 {
179         struct vfc_dev *dev;
180
181         spin_lock(&vfc_dev_lock);
182         dev = vfc_get_dev_ptr(iminor(inode));
183         if (dev == NULL) {
184                 spin_unlock(&vfc_dev_lock);
185                 return -ENODEV;
186         }
187         if (dev->busy) {
188                 spin_unlock(&vfc_dev_lock);
189                 return -EBUSY;
190         }
191
192         dev->busy = 1;
193         spin_unlock(&vfc_dev_lock);
194
195         vfc_lock_device(dev);
196         
197         vfc_csr_init(dev);
198         vfc_pcf8584_init(dev);
199         vfc_init_i2c_bus(dev);
200         vfc_saa9051_init(dev);
201         vfc_memptr_reset(dev);
202         vfc_captstat_reset(dev);
203         
204         vfc_unlock_device(dev);
205         return 0;
206 }
207
208 static int vfc_release(struct inode *inode,struct file *file) 
209 {
210         struct vfc_dev *dev;
211
212         spin_lock(&vfc_dev_lock);
213         dev = vfc_get_dev_ptr(iminor(inode));
214         if (!dev || !dev->busy) {
215                 spin_unlock(&vfc_dev_lock);
216                 return -EINVAL;
217         }
218         dev->busy = 0;
219         spin_unlock(&vfc_dev_lock);
220         return 0;
221 }
222
223 static int vfc_debug(struct vfc_dev *dev, int cmd, void __user *argp)
224 {
225         struct vfc_debug_inout inout;
226         unsigned char *buffer;
227
228         if (!capable(CAP_SYS_ADMIN))
229                 return -EPERM;
230
231         switch(cmd) {
232         case VFC_I2C_SEND:
233                 if(copy_from_user(&inout, argp, sizeof(inout)))
234                         return -EFAULT;
235
236                 buffer = kmalloc(inout.len, GFP_KERNEL);
237                 if (buffer == NULL)
238                         return -ENOMEM;
239
240                 if(copy_from_user(buffer, inout.buffer, inout.len)) {
241                         kfree(buffer);
242                         return -EFAULT;
243                 }
244                 
245
246                 vfc_lock_device(dev);
247                 inout.ret=
248                         vfc_i2c_sendbuf(dev,inout.addr & 0xff,
249                                         buffer,inout.len);
250
251                 if (copy_to_user(argp,&inout,sizeof(inout))) {
252                         vfc_unlock_device(dev);
253                         kfree(buffer);
254                         return -EFAULT;
255                 }
256                 vfc_unlock_device(dev);
257
258                 break;
259         case VFC_I2C_RECV:
260                 if (copy_from_user(&inout, argp, sizeof(inout)))
261                         return -EFAULT;
262
263                 buffer = kzalloc(inout.len, GFP_KERNEL);
264                 if (buffer == NULL)
265                         return -ENOMEM;
266
267                 vfc_lock_device(dev);
268                 inout.ret=
269                         vfc_i2c_recvbuf(dev,inout.addr & 0xff
270                                         ,buffer,inout.len);
271                 vfc_unlock_device(dev);
272                 
273                 if (copy_to_user(inout.buffer, buffer, inout.len)) {
274                         kfree(buffer);
275                         return -EFAULT;
276                 }
277                 if (copy_to_user(argp,&inout,sizeof(inout))) {
278                         kfree(buffer);
279                         return -EFAULT;
280                 }
281                 kfree(buffer);
282                 break;
283         default:
284                 return -EINVAL;
285         };
286
287         return 0;
288 }
289
290 int vfc_capture_start(struct vfc_dev *dev) 
291 {
292         vfc_captstat_reset(dev);
293         dev->control_reg = sbus_readl(&dev->regs->control);
294         if((dev->control_reg & VFC_STATUS_CAPTURE)) {
295                 printk(KERN_ERR "vfc%d: vfc capture status not reset\n",
296                        dev->instance);
297                 return -EIO;
298         }
299
300         vfc_lock_device(dev);
301         dev->control_reg &= ~VFC_CONTROL_CAPTURE;
302         sbus_writel(dev->control_reg, &dev->regs->control);
303         dev->control_reg |= VFC_CONTROL_CAPTURE;
304         sbus_writel(dev->control_reg, &dev->regs->control);
305         dev->control_reg &= ~VFC_CONTROL_CAPTURE;
306         sbus_writel(dev->control_reg, &dev->regs->control);
307         vfc_unlock_device(dev);
308
309         return 0;
310 }
311
312 int vfc_capture_poll(struct vfc_dev *dev) 
313 {
314         int timeout = 1000;
315
316         while (!timeout--) {
317                 if (sbus_readl(&dev->regs->control) & VFC_STATUS_CAPTURE)
318                         break;
319                 vfc_i2c_delay_no_busy(dev, 100);
320         }
321         if(!timeout) {
322                 printk(KERN_WARNING "vfc%d: capture timed out\n",
323                        dev->instance);
324                 return -ETIMEDOUT;
325         }
326         return 0;
327 }
328
329
330
331 static int vfc_set_control_ioctl(struct inode *inode, struct file *file, 
332                           struct vfc_dev *dev, unsigned long arg) 
333 {
334         int setcmd, ret = 0;
335
336         if (copy_from_user(&setcmd,(void __user *)arg,sizeof(unsigned int)))
337                 return -EFAULT;
338
339         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%x\n",
340                                 dev->instance,setcmd));
341
342         switch(setcmd) {
343         case MEMPRST:
344                 vfc_lock_device(dev);
345                 vfc_memptr_reset(dev);
346                 vfc_unlock_device(dev);
347                 ret=0;
348                 break;
349         case CAPTRCMD:
350                 vfc_capture_start(dev);
351                 vfc_capture_poll(dev);
352                 break;
353         case DIAGMODE:
354                 if(capable(CAP_SYS_ADMIN)) {
355                         vfc_lock_device(dev);
356                         dev->control_reg |= VFC_CONTROL_DIAGMODE;
357                         sbus_writel(dev->control_reg, &dev->regs->control);
358                         vfc_unlock_device(dev);
359                         ret = 0;
360                 } else {
361                         ret = -EPERM; 
362                 }
363                 break;
364         case NORMMODE:
365                 vfc_lock_device(dev);
366                 dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
367                 sbus_writel(dev->control_reg, &dev->regs->control);
368                 vfc_unlock_device(dev);
369                 ret = 0;
370                 break;
371         case CAPTRSTR:
372                 vfc_capture_start(dev);
373                 ret = 0;
374                 break;
375         case CAPTRWAIT:
376                 vfc_capture_poll(dev);
377                 ret = 0;
378                 break;
379         default:
380                 ret = -EINVAL;
381                 break;
382         };
383
384         return ret;
385 }
386
387
388 int vfc_port_change_ioctl(struct inode *inode, struct file *file, 
389                           struct vfc_dev *dev, unsigned long arg) 
390 {
391         int ret = 0;
392         int cmd;
393
394         if(copy_from_user(&cmd, (void __user *)arg, sizeof(unsigned int))) {
395                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
396                                         "vfc_port_change_ioctl\n",
397                                         dev->instance));
398                 return -EFAULT;
399         }
400         
401         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%x\n",
402                                 dev->instance, cmd));
403
404         switch(cmd) {
405         case 1:
406         case 2:
407                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72; 
408                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52;
409                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36;
410                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18;
411                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2;
412                 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3;
413                 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e;
414                 break;
415         case 3:
416                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a;
417                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17;
418                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa;
419                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde;
420                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) =
421                         VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2;
422                 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC;
423                 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0;
424                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
425                         ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
426                 break;
427         default:
428                 ret = -EINVAL;
429                 return ret;
430                 break;
431         }
432
433         switch(cmd) {
434         case 1:
435                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |=
436                         (VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
437                 break;
438         case 2:
439                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
440                         ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
441                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0; 
442                 break;
443         case 3:
444                 break;
445         default:
446                 ret = -EINVAL;
447                 return ret;
448                 break;
449         }
450         VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2);
451         ret=vfc_update_saa9051(dev);
452         udelay(500);
453         VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2);
454         ret=vfc_update_saa9051(dev);
455         return ret;
456 }
457
458 int vfc_set_video_ioctl(struct inode *inode, struct file *file, 
459                         struct vfc_dev *dev, unsigned long arg) 
460 {
461         int ret = 0;
462         int cmd;
463
464         if(copy_from_user(&cmd, (void __user *)arg, sizeof(unsigned int))) {
465                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
466                                         "vfc_set_video_ioctl\n",
467                                         dev->instance));
468                 return ret;
469         }
470         
471         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%x\n",
472                                 dev->instance, cmd));
473         switch(cmd) {
474         case STD_NTSC:
475                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT;
476                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN | 
477                         VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS;
478                 ret = vfc_update_saa9051(dev);
479                 break;
480         case STD_PAL:
481                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN | 
482                                                         VFC_SAA9051_CCFR1 | 
483                                                         VFC_SAA9051_CCFR0 |
484                                                         VFC_SAA9051_FS);
485                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT;
486                 ret = vfc_update_saa9051(dev);
487                 break;
488
489         case COLOR_ON:
490                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO;
491                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &=
492                         ~(VFC_SAA9051_BY | VFC_SAA9051_PF);
493                 ret = vfc_update_saa9051(dev);
494                 break;
495         case MONO:
496                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO);
497                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |=
498                         (VFC_SAA9051_BY | VFC_SAA9051_PF);
499                 ret = vfc_update_saa9051(dev);
500                 break;
501         default:
502                 ret = -EINVAL;
503                 break;
504         };
505
506         return ret;
507 }
508
509 int vfc_get_video_ioctl(struct inode *inode, struct file *file, 
510                         struct vfc_dev *dev, unsigned long arg) 
511 {
512         int ret = 0;
513         unsigned int status = NO_LOCK;
514         unsigned char buf[1];
515
516         if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) {
517                 printk(KERN_ERR "vfc%d: Unable to get status\n",
518                        dev->instance);
519                 return -EIO;
520         }
521
522         if(buf[0] & VFC_SAA9051_HLOCK) {
523                 status = NO_LOCK;
524         } else if(buf[0] & VFC_SAA9051_FD) {
525                 if(buf[0] & VFC_SAA9051_CD)
526                         status = NTSC_COLOR;
527                 else
528                         status = NTSC_NOCOLOR;
529         } else {
530                 if(buf[0] & VFC_SAA9051_CD)
531                         status = PAL_COLOR;
532                 else
533                         status = PAL_NOCOLOR;
534         }
535         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; "
536                                 "buf[0]=%x\n", dev->instance, status, buf[0]));
537
538         if (copy_to_user((void __user *)arg,&status,sizeof(unsigned int))) {
539                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
540                                         "vfc_get_video_ioctl\n",
541                                         dev->instance));
542                 return ret;
543         }
544         return ret;
545 }
546
547 static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
548               unsigned long arg) 
549 {
550         int ret = 0;
551         unsigned int tmp;
552         struct vfc_dev *dev;
553         void __user *argp = (void __user *)arg;
554
555         dev = vfc_get_dev_ptr(iminor(inode));
556         if(dev == NULL)
557                 return -ENODEV;
558         
559         switch(cmd & 0x0000ffff) {
560         case VFCGCTRL:
561 #if 0
562                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)\n", dev->instance));
563 #endif
564                 tmp = sbus_readl(&dev->regs->control);
565                 if(copy_to_user(argp, &tmp, sizeof(unsigned int))) {
566                         ret = -EFAULT;
567                         break;
568                 }
569                 ret = 0;
570                 break;
571         case VFCSCTRL:
572                 ret = vfc_set_control_ioctl(inode, file, dev, arg);
573                 break;
574         case VFCGVID:
575                 ret = vfc_get_video_ioctl(inode, file, dev, arg);
576                 break;
577         case VFCSVID:
578                 ret = vfc_set_video_ioctl(inode, file, dev, arg);
579                 break;
580         case VFCHUE:
581                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)\n", dev->instance));
582                 if(copy_from_user(&tmp,argp,sizeof(unsigned int))) {
583                         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer "
584                                                 "to IOCTL(VFCHUE)", dev->instance));
585                         ret = -EFAULT;
586                 } else {
587                         VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp;
588                         vfc_update_saa9051(dev);
589                         ret = 0;
590                 }
591                 break;
592         case VFCPORTCHG:
593                 ret = vfc_port_change_ioctl(inode, file, dev, arg);
594                 break;
595         case VFCRDINFO:
596                 ret = -EINVAL;
597                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)\n", dev->instance));
598                 break;
599         default:
600                 ret = vfc_debug(vfc_get_dev_ptr(iminor(inode)), cmd, argp);
601                 break;
602         };
603
604         return ret;
605 }
606
607 static int vfc_mmap(struct file *file, struct vm_area_struct *vma) 
608 {
609         unsigned int map_size, ret, map_offset;
610         struct vfc_dev *dev;
611         
612         dev = vfc_get_dev_ptr(iminor(file->f_path.dentry->d_inode));
613         if(dev == NULL)
614                 return -ENODEV;
615
616         map_size = vma->vm_end - vma->vm_start;
617         if(map_size > sizeof(struct vfc_regs)) 
618                 map_size = sizeof(struct vfc_regs);
619
620         vma->vm_flags |=
621                 (VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
622         map_offset = (unsigned int) (long)dev->phys_regs;
623         ret = io_remap_pfn_range(vma, vma->vm_start,
624                                   MK_IOSPACE_PFN(dev->which_io,
625                                         map_offset >> PAGE_SHIFT),
626                                   map_size, vma->vm_page_prot);
627
628         if(ret)
629                 return -EAGAIN;
630
631         return 0;
632 }
633
634
635 static const struct file_operations vfc_fops = {
636         .owner =        THIS_MODULE,
637         .llseek =       no_llseek,
638         .ioctl =        vfc_ioctl,
639         .mmap =         vfc_mmap,
640         .open =         vfc_open,
641         .release =      vfc_release,
642 };
643
644 static int vfc_probe(void)
645 {
646         struct sbus_bus *sbus;
647         struct sbus_dev *sdev = NULL;
648         int ret;
649         int instance = 0, cards = 0;
650
651         for_all_sbusdev(sdev, sbus) {
652                 if (strcmp(sdev->prom_name, "vfc") == 0) {
653                         cards++;
654                         continue;
655                 }
656         }
657
658         if (!cards)
659                 return -ENODEV;
660
661         vfc_dev_lst = kcalloc(cards + 1, sizeof(struct vfc_dev*), GFP_KERNEL);
662         if (vfc_dev_lst == NULL)
663                 return -ENOMEM;
664         vfc_dev_lst[cards] = NULL;
665
666         ret = register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
667         if(ret) {
668                 printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
669                 kfree(vfc_dev_lst);
670                 return -EIO;
671         }
672         instance = 0;
673         for_all_sbusdev(sdev, sbus) {
674                 if (strcmp(sdev->prom_name, "vfc") == 0) {
675                         vfc_dev_lst[instance]=(struct vfc_dev *)
676                                 kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
677                         if (vfc_dev_lst[instance] == NULL)
678                                 return -ENOMEM;
679                         ret = init_vfc_device(sdev,
680                                               vfc_dev_lst[instance],
681                                               instance);
682                         if(ret) {
683                                 printk(KERN_ERR "Unable to initialize"
684                                        " vfc%d device\n",
685                                        instance);
686                         } else {
687                         }
688                 
689                         instance++;
690                         continue;
691                 }
692         }
693
694         return 0;
695 }
696
697 #ifdef MODULE
698 int init_module(void)
699 #else 
700 int vfc_init(void)
701 #endif
702 {
703         return vfc_probe();
704 }
705
706 #ifdef MODULE
707 static void deinit_vfc_device(struct vfc_dev *dev)
708 {
709         if(dev == NULL)
710                 return;
711         sbus_iounmap(dev->regs, sizeof(struct vfc_regs));
712         kfree(dev);
713 }
714
715 void cleanup_module(void)
716 {
717         struct vfc_dev **devp;
718
719         unregister_chrdev(VFC_MAJOR,vfcstr);
720
721         for (devp = vfc_dev_lst; *devp; devp++)
722                 deinit_vfc_device(*devp);
723
724         kfree(vfc_dev_lst);
725         return;
726 }
727 #endif
728
729 MODULE_LICENSE("GPL");
730