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