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
  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 struct file_operations vfc_fops;
  47 static devfs_handle_t devfs_handle;  /*  For the directory  */
  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         init_waitqueue_head(&dev->poll_wait);
 141         dev->busy=0;
 142         return 0;
 143 }
 144
 145 int init_vfc_device(struct sbus_dev *sdev,struct vfc_dev *dev, int instance)
 146 {
 147         char devname[8];
 148
 149         if(dev == NULL) {
 150                 printk(KERN_ERR "VFC: Bogus pointer passed\n");
 151                 return -ENOMEM;
 152         }
 153         printk("Initializing vfc%d\n",instance);
 154         dev->regs = NULL;
 155         dev->regs = (volatile struct vfc_regs *)
 156                 sbus_ioremap(&sdev->resource[0], 0,
 157                              sizeof(struct vfc_regs), vfcstr);
 158         dev->which_io = sdev->reg_addrs[0].which_io;
 159         dev->phys_regs = (struct vfc_regs *) sdev->reg_addrs[0].phys_addr;
 160         if (dev->regs == NULL)
 161                 return -EIO;
 162
 163         printk("vfc%d: registers mapped at phys_addr: 0x%lx\n    virt_addr: 0x%lx\n",
 164                instance,(unsigned long)sdev->reg_addrs[0].phys_addr,(unsigned long)dev->regs);
 165
 166         if (init_vfc_devstruct(dev, instance))
 167                 return -EINVAL;
 168         if (init_vfc_hw(dev))
 169                 return -EIO;
 170
 171         sprintf (devname, "%d", instance);
 172         dev->de = devfs_register (devfs_handle, devname, DEVFS_FL_DEFAULT,
 173                                   VFC_MAJOR, instance,
 174                                   S_IFCHR | S_IRUSR | S_IWUSR,
 175                                   &vfc_fops, NULL);
 176         return 0;
 177 }
 178
 179
 180 struct vfc_dev *vfc_get_dev_ptr(int instance)
 181 {
 182         return vfc_dev_lst[instance];
 183 }
 184
 185 static spinlock_t vfc_dev_lock = SPIN_LOCK_UNLOCKED;
 186
 187 static int vfc_open(struct inode *inode, struct file *file)
 188 {
 189         struct vfc_dev *dev;
 190
 191         spin_lock(&vfc_dev_lock);
 192         dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
 193         if (dev == NULL) {
 194                 spin_unlock(&vfc_dev_lock);
 195                 return -ENODEV;
 196         }
 197         if (dev->busy) {
 198                 spin_unlock(&vfc_dev_lock);
 199                 return -EBUSY;
 200         }
 201
 202         dev->busy = 1;
 203         spin_unlock(&vfc_dev_lock);
 204
 205         vfc_lock_device(dev);
 206
 207         vfc_csr_init(dev);
 208         vfc_pcf8584_init(dev);
 209         vfc_init_i2c_bus(dev);
 210         vfc_saa9051_init(dev);
 211         vfc_memptr_reset(dev);
 212         vfc_captstat_reset(dev);
 213
 214         vfc_unlock_device(dev);
 215         return 0;
 216 }
 217
 218 static int vfc_release(struct inode *inode,struct file *file)
 219 {
 220         struct vfc_dev *dev;
 221
 222         spin_lock(&vfc_dev_lock);
 223         dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
 224         if (!dev || !dev->busy) {
 225                 spin_unlock(&vfc_dev_lock);
 226                 return -EINVAL;
 227         }
 228         dev->busy = 0;
 229         spin_unlock(&vfc_dev_lock);
 230         return 0;
 231 }
 232
 233 static int vfc_debug(struct vfc_dev *dev, int cmd, unsigned long arg)
 234 {
 235         struct vfc_debug_inout inout;
 236         unsigned char *buffer;
 237
 238         if (!capable(CAP_SYS_ADMIN))
 239                 return -EPERM;
 240
 241         switch(cmd) {
 242         case VFC_I2C_SEND:
 243                 if(copy_from_user(&inout, (void *)arg, sizeof(inout)))
 244                         return -EFAULT;
 245
 246                 buffer = kmalloc(inout.len*sizeof(char), GFP_KERNEL);
 247                 if (buffer == NULL)
 248                         return -ENOMEM;
 249
 250                 if(copy_from_user(buffer, inout.buffer,
 251                                   inout.len*sizeof(char))) {
 252                         kfree(buffer);
 253                         return -EFAULT;
 254                 }
 255
 256
 257                 vfc_lock_device(dev);
 258                 inout.ret=
 259                         vfc_i2c_sendbuf(dev,inout.addr & 0xff,
 260                                         inout.buffer,inout.len);
 261
 262                 if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
 263                         kfree(buffer);
 264                         return -EFAULT;
 265                 }
 266                 vfc_unlock_device(dev);
 267
 268                 break;
 269         case VFC_I2C_RECV:
 270                 if (copy_from_user(&inout, (void *)arg, sizeof(inout)))
 271                         return -EFAULT;
 272
 273                 buffer = kmalloc(inout.len, GFP_KERNEL);
 274                 if (buffer == NULL)
 275                         return -ENOMEM;
 276
 277                 memset(buffer,0,inout.len*sizeof(char));
 278                 vfc_lock_device(dev);
 279                 inout.ret=
 280                         vfc_i2c_recvbuf(dev,inout.addr & 0xff
 281                                         ,buffer,inout.len);
 282                 vfc_unlock_device(dev);
 283
 284                 if (copy_to_user(inout.buffer, buffer, inout.len)) {
 285                         kfree(buffer);
 286                         return -EFAULT;
 287                 }
 288                 if (copy_to_user((void *)arg,&inout,sizeof(inout))) {
 289                         kfree(buffer);
 290                         return -EFAULT;
 291                 }
 292                 kfree(buffer);
 293                 break;
 294         default:
 295                 return -EINVAL;
 296         };
 297
 298         return 0;
 299 }
 300
 301 int vfc_capture_start(struct vfc_dev *dev)
 302 {
 303         vfc_captstat_reset(dev);
 304         dev->control_reg = sbus_readl(&dev->regs->control);
 305         if((dev->control_reg & VFC_STATUS_CAPTURE)) {
 306                 printk(KERN_ERR "vfc%d: vfc capture status not reset\n",
 307                        dev->instance);
 308                 return -EIO;
 309         }
 310
 311         vfc_lock_device(dev);
 312         dev->control_reg &= ~VFC_CONTROL_CAPTURE;
 313         sbus_writel(dev->control_reg, &dev->regs->control);
 314         dev->control_reg |= VFC_CONTROL_CAPTURE;
 315         sbus_writel(dev->control_reg, &dev->regs->control);
 316         dev->control_reg &= ~VFC_CONTROL_CAPTURE;
 317         sbus_writel(dev->control_reg, &dev->regs->control);
 318         vfc_unlock_device(dev);
 319
 320         return 0;
 321 }
 322
 323 int vfc_capture_poll(struct vfc_dev *dev)
 324 {
 325         int timeout = 1000;
 326
 327         while (!timeout--) {
 328                 if (dev->regs->control & VFC_STATUS_CAPTURE)
 329                         break;
 330                 vfc_i2c_delay_no_busy(dev, 100);
 331         }
 332         if(!timeout) {
 333                 printk(KERN_WARNING "vfc%d: capture timed out\n",
 334                        dev->instance);
 335                 return -ETIMEDOUT;
 336         }
 337         return 0;
 338 }
 339
 340
 341
 342 static int vfc_set_control_ioctl(struct inode *inode, struct file *file,
 343                           struct vfc_dev *dev, unsigned long arg)
 344 {
 345         int setcmd, ret = 0;
 346
 347         if (copy_from_user(&setcmd,(void *)arg,sizeof(unsigned int)))
 348                 return -EFAULT;
 349
 350         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%x\n",
 351                                 dev->instance,setcmd));
 352
 353         switch(setcmd) {
 354         case MEMPRST:
 355                 vfc_lock_device(dev);
 356                 vfc_memptr_reset(dev);
 357                 vfc_unlock_device(dev);
 358                 ret=0;
 359                 break;
 360         case CAPTRCMD:
 361                 vfc_capture_start(dev);
 362                 vfc_capture_poll(dev);
 363                 break;
 364         case DIAGMODE:
 365                 if(capable(CAP_SYS_ADMIN)) {
 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                 } else {
 372                         ret = -EPERM;
 373                 }
 374                 break;
 375         case NORMMODE:
 376                 vfc_lock_device(dev);
 377                 dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
 378                 sbus_writel(dev->control_reg, &dev->regs->control);
 379                 vfc_unlock_device(dev);
 380                 ret = 0;
 381                 break;
 382         case CAPTRSTR:
 383                 vfc_capture_start(dev);
 384                 ret = 0;
 385                 break;
 386         case CAPTRWAIT:
 387                 vfc_capture_poll(dev);
 388                 ret = 0;
 389                 break;
 390         default:
 391                 ret = -EINVAL;
 392                 break;
 393         };
 394
 395         return ret;
 396 }
 397
 398
 399 int vfc_port_change_ioctl(struct inode *inode, struct file *file,
 400                           struct vfc_dev *dev, unsigned long arg)
 401 {
 402         int ret = 0;
 403         int cmd;
 404
 405         if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
 406                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
 407                                         "vfc_port_change_ioctl\n",
 408                                         dev->instance));
 409                 return -EFAULT;
 410         }
 411
 412         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%x\n",
 413                                 dev->instance, cmd));
 414
 415         switch(cmd) {
 416         case 1:
 417         case 2:
 418                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72;
 419                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52;
 420                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36;
 421                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18;
 422                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2;
 423                 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3;
 424                 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e;
 425                 break;
 426         case 3:
 427                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a;
 428                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17;
 429                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa;
 430                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde;
 431                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) =
 432                         VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2;
 433                 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC;
 434                 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0;
 435                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
 436                         ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
 437                 break;
 438         default:
 439                 ret = -EINVAL;
 440                 return ret;
 441                 break;
 442         }
 443
 444         switch(cmd) {
 445         case 1:
 446                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |=
 447                         (VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
 448                 break;
 449         case 2:
 450                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
 451                         ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
 452                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0;
 453                 break;
 454         case 3:
 455                 break;
 456         default:
 457                 ret = -EINVAL;
 458                 return ret;
 459                 break;
 460         }
 461         VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2);
 462         ret=vfc_update_saa9051(dev);
 463         udelay(500);
 464         VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2);
 465         ret=vfc_update_saa9051(dev);
 466         return ret;
 467 }
 468
 469 int vfc_set_video_ioctl(struct inode *inode, struct file *file,
 470                         struct vfc_dev *dev, unsigned long arg)
 471 {
 472         int ret = 0;
 473         int cmd;
 474
 475         if(copy_from_user(&cmd, (void *)arg, sizeof(unsigned int))) {
 476                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
 477                                         "vfc_set_video_ioctl\n",
 478                                         dev->instance));
 479                 return ret;
 480         }
 481
 482         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%x\n",
 483                                 dev->instance, cmd));
 484         switch(cmd) {
 485         case STD_NTSC:
 486                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT;
 487                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN |
 488                         VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS;
 489                 ret = vfc_update_saa9051(dev);
 490                 break;
 491         case STD_PAL:
 492                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN |
 493                                                         VFC_SAA9051_CCFR1 |
 494                                                         VFC_SAA9051_CCFR0 |
 495                                                         VFC_SAA9051_FS);
 496                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT;
 497                 ret = vfc_update_saa9051(dev);
 498                 break;
 499
 500         case COLOR_ON:
 501                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO;
 502                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &=
 503                         ~(VFC_SAA9051_BY | VFC_SAA9051_PF);
 504                 ret = vfc_update_saa9051(dev);
 505                 break;
 506         case MONO:
 507                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO);
 508                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |=
 509                         (VFC_SAA9051_BY | VFC_SAA9051_PF);
 510                 ret = vfc_update_saa9051(dev);
 511                 break;
 512         default:
 513                 ret = -EINVAL;
 514                 break;
 515         };
 516
 517         return ret;
 518 }
 519
 520 int vfc_get_video_ioctl(struct inode *inode, struct file *file,
 521                         struct vfc_dev *dev, unsigned long arg)
 522 {
 523         int ret = 0;
 524         unsigned int status = NO_LOCK;
 525         unsigned char buf[1];
 526
 527         if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) {
 528                 printk(KERN_ERR "vfc%d: Unable to get status\n",
 529                        dev->instance);
 530                 return -EIO;
 531         }
 532
 533         if(buf[0] & VFC_SAA9051_HLOCK) {
 534                 status = NO_LOCK;
 535         } else if(buf[0] & VFC_SAA9051_FD) {
 536                 if(buf[0] & VFC_SAA9051_CD)
 537                         status = NTSC_COLOR;
 538                 else
 539                         status = NTSC_NOCOLOR;
 540         } else {
 541                 if(buf[0] & VFC_SAA9051_CD)
 542                         status = PAL_COLOR;
 543                 else
 544                         status = PAL_NOCOLOR;
 545         }
 546         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; "
 547                                 "buf[0]=%x\n", dev->instance, status, buf[0]));
 548
 549         if (copy_to_user((void *)arg,&status,sizeof(unsigned int))) {
 550                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
 551                                         "vfc_get_video_ioctl\n",
 552                                         dev->instance));
 553                 return ret;
 554         }
 555         return ret;
 556 }
 557
 558 static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 559               unsigned long arg)
 560 {
 561         int ret = 0;
 562         unsigned int tmp;
 563         struct vfc_dev *dev;
 564
 565         dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
 566         if(dev == NULL)
 567                 return -ENODEV;
 568
 569         switch(cmd & 0x0000ffff) {
 570         case VFCGCTRL:
 571 #if 0
 572                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)\n", dev->instance));
 573 #endif
 574                 tmp = sbus_readl(&dev->regs->control);
 575                 if(copy_to_user((void *)arg, &tmp, sizeof(unsigned int))) {
 576                         ret = -EFAULT;
 577                         break;
 578                 }
 579                 ret = 0;
 580                 break;
 581         case VFCSCTRL:
 582                 ret = vfc_set_control_ioctl(inode, file, dev, arg);
 583                 break;
 584         case VFCGVID:
 585                 ret = vfc_get_video_ioctl(inode, file, dev, arg);
 586                 break;
 587         case VFCSVID:
 588                 ret = vfc_set_video_ioctl(inode, file, dev, arg);
 589                 break;
 590         case VFCHUE:
 591                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)\n", dev->instance));
 592                 if(copy_from_user(&tmp,(void *)arg,sizeof(unsigned int))) {
 593                         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer "
 594                                                 "to IOCTL(VFCHUE)", dev->instance));
 595                         ret = -EFAULT;
 596                 } else {
 597                         VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp;
 598                         vfc_update_saa9051(dev);
 599                         ret = 0;
 600                 }
 601                 break;
 602         case VFCPORTCHG:
 603                 ret = vfc_port_change_ioctl(inode, file, dev, arg);
 604                 break;
 605         case VFCRDINFO:
 606                 ret = -EINVAL;
 607                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)\n", dev->instance));
 608                 break;
 609         default:
 610                 ret = vfc_debug(vfc_get_dev_ptr(MINOR(inode->i_rdev)),
 611                                 cmd, arg);
 612                 break;
 613         };
 614
 615         return ret;
 616 }
 617
 618 static int vfc_mmap(struct inode *inode, struct file *file,
 619                     struct vm_area_struct *vma)
 620 {
 621         unsigned int map_size, ret, map_offset;
 622         struct vfc_dev *dev;
 623
 624         dev = vfc_get_dev_ptr(MINOR(inode->i_rdev));
 625         if(dev == NULL)
 626                 return -ENODEV;
 627
 628         map_size = vma->vm_end - vma->vm_start;
 629         if(map_size > sizeof(struct vfc_regs))
 630                 map_size = sizeof(struct vfc_regs);
 631
 632         vma->vm_flags |=
 633                 (VM_SHM | VM_LOCKED | VM_IO | VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
 634         map_offset = (unsigned int) (long)dev->phys_regs;
 635         ret = io_remap_page_range(vma->vm_start, map_offset, map_size,
 636                                   vma->vm_page_prot, dev->which_io);
 637
 638         if(ret)
 639                 return -EAGAIN;
 640
 641         return 0;
 642 }
 643
 644
 645 static struct file_operations vfc_fops = {
 646         owner:          THIS_MODULE,
 647         llseek:         no_llseek,
 648         ioctl:          vfc_ioctl,
 649         mmap:           vfc_mmap,
 650         open:           vfc_open,
 651         release:        vfc_release,
 652 };
 653
 654 static int vfc_probe(void)
 655 {
 656         struct sbus_bus *sbus;
 657         struct sbus_dev *sdev = NULL;
 658         int ret;
 659         int instance = 0, cards = 0;
 660
 661         for_all_sbusdev(sdev, sbus) {
 662                 if (strcmp(sdev->prom_name, "vfc") == 0) {
 663                         cards++;
 664                         continue;
 665                 }
 666         }
 667
 668         if (!cards)
 669                 return -ENODEV;
 670
 671         vfc_dev_lst = (struct vfc_dev **)kmalloc(sizeof(struct vfc_dev *) *
 672                                                  (cards+1),
 673                                                  GFP_KERNEL);
 674         if (vfc_dev_lst == NULL)
 675                 return -ENOMEM;
 676         memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1));
 677         vfc_dev_lst[cards] = NULL;
 678
 679         ret = devfs_register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
 680         if(ret) {
 681                 printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
 682                 kfree(vfc_dev_lst);
 683                 return -EIO;
 684         }
 685         devfs_handle = devfs_mk_dir (NULL, "vfc", NULL);
 686
 687         instance = 0;
 688         for_all_sbusdev(sdev, sbus) {
 689                 if (strcmp(sdev->prom_name, "vfc") == 0) {
 690                         vfc_dev_lst[instance]=(struct vfc_dev *)
 691                                 kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
 692                         if (vfc_dev_lst[instance] == NULL)
 693                                 return -ENOMEM;
 694                         ret = init_vfc_device(sdev,
 695                                               vfc_dev_lst[instance],
 696                                               instance);
 697                         if(ret) {
 698                                 printk(KERN_ERR "Unable to initialize"
 699                                        " vfc%d device\n",
 700                                        instance);
 701                         } else {
 702                         }
 703
 704                         instance++;
 705                         continue;
 706                 }
 707         }
 708
 709         return 0;
 710 }
 711
 712 #ifdef MODULE
 713 int init_module(void)
 714 #else
 715 int vfc_init(void)
 716 #endif
 717 {
 718         return vfc_probe();
 719 }
 720
 721 #ifdef MODULE
 722 static void deinit_vfc_device(struct vfc_dev *dev)
 723 {
 724         if(dev == NULL)
 725                 return;
 726         devfs_unregister (dev->de);
 727         sbus_iounmap((unsigned long)dev->regs, sizeof(struct vfc_regs));
 728         kfree(dev);
 729 }
 730
 731 void cleanup_module(void)
 732 {
 733         struct vfc_dev **devp;
 734
 735         devfs_unregister_chrdev(VFC_MAJOR,vfcstr);
 736
 737         for (devp = vfc_dev_lst; *devp; devp++)
 738                 deinit_vfc_device(*devp);
 739
 740         devfs_unregister (devfs_handle);
 741         kfree(vfc_dev_lst);
 742         return;
 743 }
 744 #endif
 745
 746 MODULE_LICENSE("GPL");