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/smp_lock.h>
  24 #include <linux/delay.h>
  25 #include <linux/spinlock.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         down(&dev->device_lock_sem);
  59 }
  60
  61 void vfc_unlock_device(struct vfc_dev *dev)
  62 {
  63         up(&dev->device_lock_sem);
  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         init_MUTEX(&dev->device_lock_sem);
 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                         kfree(buffer);
 253                         return -EFAULT;
 254                 }
 255                 vfc_unlock_device(dev);
 256
 257                 break;
 258         case VFC_I2C_RECV:
 259                 if (copy_from_user(&inout, argp, sizeof(inout)))
 260                         return -EFAULT;
 261
 262                 buffer = kzalloc(inout.len, GFP_KERNEL);
 263                 if (buffer == NULL)
 264                         return -ENOMEM;
 265
 266                 vfc_lock_device(dev);
 267                 inout.ret=
 268                         vfc_i2c_recvbuf(dev,inout.addr & 0xff
 269                                         ,buffer,inout.len);
 270                 vfc_unlock_device(dev);
 271
 272                 if (copy_to_user(inout.buffer, buffer, inout.len)) {
 273                         kfree(buffer);
 274                         return -EFAULT;
 275                 }
 276                 if (copy_to_user(argp,&inout,sizeof(inout))) {
 277                         kfree(buffer);
 278                         return -EFAULT;
 279                 }
 280                 kfree(buffer);
 281                 break;
 282         default:
 283                 return -EINVAL;
 284         };
 285
 286         return 0;
 287 }
 288
 289 int vfc_capture_start(struct vfc_dev *dev)
 290 {
 291         vfc_captstat_reset(dev);
 292         dev->control_reg = sbus_readl(&dev->regs->control);
 293         if((dev->control_reg & VFC_STATUS_CAPTURE)) {
 294                 printk(KERN_ERR "vfc%d: vfc capture status not reset\n",
 295                        dev->instance);
 296                 return -EIO;
 297         }
 298
 299         vfc_lock_device(dev);
 300         dev->control_reg &= ~VFC_CONTROL_CAPTURE;
 301         sbus_writel(dev->control_reg, &dev->regs->control);
 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         vfc_unlock_device(dev);
 307
 308         return 0;
 309 }
 310
 311 int vfc_capture_poll(struct vfc_dev *dev)
 312 {
 313         int timeout = 1000;
 314
 315         while (!timeout--) {
 316                 if (sbus_readl(&dev->regs->control) & VFC_STATUS_CAPTURE)
 317                         break;
 318                 vfc_i2c_delay_no_busy(dev, 100);
 319         }
 320         if(!timeout) {
 321                 printk(KERN_WARNING "vfc%d: capture timed out\n",
 322                        dev->instance);
 323                 return -ETIMEDOUT;
 324         }
 325         return 0;
 326 }
 327
 328
 329
 330 static int vfc_set_control_ioctl(struct inode *inode, struct file *file,
 331                           struct vfc_dev *dev, unsigned long arg)
 332 {
 333         int setcmd, ret = 0;
 334
 335         if (copy_from_user(&setcmd,(void __user *)arg,sizeof(unsigned int)))
 336                 return -EFAULT;
 337
 338         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSCTRL) arg=0x%x\n",
 339                                 dev->instance,setcmd));
 340
 341         switch(setcmd) {
 342         case MEMPRST:
 343                 vfc_lock_device(dev);
 344                 vfc_memptr_reset(dev);
 345                 vfc_unlock_device(dev);
 346                 ret=0;
 347                 break;
 348         case CAPTRCMD:
 349                 vfc_capture_start(dev);
 350                 vfc_capture_poll(dev);
 351                 break;
 352         case DIAGMODE:
 353                 if(capable(CAP_SYS_ADMIN)) {
 354                         vfc_lock_device(dev);
 355                         dev->control_reg |= VFC_CONTROL_DIAGMODE;
 356                         sbus_writel(dev->control_reg, &dev->regs->control);
 357                         vfc_unlock_device(dev);
 358                         ret = 0;
 359                 } else {
 360                         ret = -EPERM;
 361                 }
 362                 break;
 363         case NORMMODE:
 364                 vfc_lock_device(dev);
 365                 dev->control_reg &= ~VFC_CONTROL_DIAGMODE;
 366                 sbus_writel(dev->control_reg, &dev->regs->control);
 367                 vfc_unlock_device(dev);
 368                 ret = 0;
 369                 break;
 370         case CAPTRSTR:
 371                 vfc_capture_start(dev);
 372                 ret = 0;
 373                 break;
 374         case CAPTRWAIT:
 375                 vfc_capture_poll(dev);
 376                 ret = 0;
 377                 break;
 378         default:
 379                 ret = -EINVAL;
 380                 break;
 381         };
 382
 383         return ret;
 384 }
 385
 386
 387 int vfc_port_change_ioctl(struct inode *inode, struct file *file,
 388                           struct vfc_dev *dev, unsigned long arg)
 389 {
 390         int ret = 0;
 391         int cmd;
 392
 393         if(copy_from_user(&cmd, (void __user *)arg, sizeof(unsigned int))) {
 394                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
 395                                         "vfc_port_change_ioctl\n",
 396                                         dev->instance));
 397                 return -EFAULT;
 398         }
 399
 400         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCPORTCHG) arg=0x%x\n",
 401                                 dev->instance, cmd));
 402
 403         switch(cmd) {
 404         case 1:
 405         case 2:
 406                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x72;
 407                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x52;
 408                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0x36;
 409                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0x18;
 410                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) = VFC_SAA9051_BP2;
 411                 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_CT | VFC_SAA9051_SS3;
 412                 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0x3e;
 413                 break;
 414         case 3:
 415                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_START) = 0x3a;
 416                 VFC_SAA9051_SA(dev,VFC_SAA9051_HSY_STOP) = 0x17;
 417                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_START) = 0xfa;
 418                 VFC_SAA9051_SA(dev,VFC_SAA9051_HC_STOP) = 0xde;
 419                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) =
 420                         VFC_SAA9051_BY | VFC_SAA9051_PF | VFC_SAA9051_BP2;
 421                 VFC_SAA9051_SA(dev,VFC_SAA9051_C3) = VFC_SAA9051_YC;
 422                 VFC_SAA9051_SA(dev,VFC_SAA9051_SECAM_DELAY) = 0;
 423                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
 424                         ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
 425                 break;
 426         default:
 427                 ret = -EINVAL;
 428                 return ret;
 429                 break;
 430         }
 431
 432         switch(cmd) {
 433         case 1:
 434                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |=
 435                         (VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
 436                 break;
 437         case 2:
 438                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) &=
 439                         ~(VFC_SAA9051_SS0 | VFC_SAA9051_SS1);
 440                 VFC_SAA9051_SA(dev,VFC_SAA9051_C2) |= VFC_SAA9051_SS0;
 441                 break;
 442         case 3:
 443                 break;
 444         default:
 445                 ret = -EINVAL;
 446                 return ret;
 447                 break;
 448         }
 449         VFC_SAA9051_SA(dev,VFC_SAA9051_C3) &= ~(VFC_SAA9051_SS2);
 450         ret=vfc_update_saa9051(dev);
 451         udelay(500);
 452         VFC_SAA9051_SA(dev,VFC_SAA9051_C3) |= (VFC_SAA9051_SS2);
 453         ret=vfc_update_saa9051(dev);
 454         return ret;
 455 }
 456
 457 int vfc_set_video_ioctl(struct inode *inode, struct file *file,
 458                         struct vfc_dev *dev, unsigned long arg)
 459 {
 460         int ret = 0;
 461         int cmd;
 462
 463         if(copy_from_user(&cmd, (void __user *)arg, sizeof(unsigned int))) {
 464                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
 465                                         "vfc_set_video_ioctl\n",
 466                                         dev->instance));
 467                 return ret;
 468         }
 469
 470         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCSVID) arg=0x%x\n",
 471                                 dev->instance, cmd));
 472         switch(cmd) {
 473         case STD_NTSC:
 474                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~VFC_SAA9051_ALT;
 475                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_YPN |
 476                         VFC_SAA9051_CCFR0 | VFC_SAA9051_CCFR1 | VFC_SAA9051_FS;
 477                 ret = vfc_update_saa9051(dev);
 478                 break;
 479         case STD_PAL:
 480                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_YPN |
 481                                                         VFC_SAA9051_CCFR1 |
 482                                                         VFC_SAA9051_CCFR0 |
 483                                                         VFC_SAA9051_FS);
 484                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_ALT;
 485                 ret = vfc_update_saa9051(dev);
 486                 break;
 487
 488         case COLOR_ON:
 489                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) |= VFC_SAA9051_CO;
 490                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) &=
 491                         ~(VFC_SAA9051_BY | VFC_SAA9051_PF);
 492                 ret = vfc_update_saa9051(dev);
 493                 break;
 494         case MONO:
 495                 VFC_SAA9051_SA(dev,VFC_SAA9051_C1) &= ~(VFC_SAA9051_CO);
 496                 VFC_SAA9051_SA(dev,VFC_SAA9051_HORIZ_PEAK) |=
 497                         (VFC_SAA9051_BY | VFC_SAA9051_PF);
 498                 ret = vfc_update_saa9051(dev);
 499                 break;
 500         default:
 501                 ret = -EINVAL;
 502                 break;
 503         };
 504
 505         return ret;
 506 }
 507
 508 int vfc_get_video_ioctl(struct inode *inode, struct file *file,
 509                         struct vfc_dev *dev, unsigned long arg)
 510 {
 511         int ret = 0;
 512         unsigned int status = NO_LOCK;
 513         unsigned char buf[1];
 514
 515         if(vfc_i2c_recvbuf(dev, VFC_SAA9051_ADDR, buf, 1)) {
 516                 printk(KERN_ERR "vfc%d: Unable to get status\n",
 517                        dev->instance);
 518                 return -EIO;
 519         }
 520
 521         if(buf[0] & VFC_SAA9051_HLOCK) {
 522                 status = NO_LOCK;
 523         } else if(buf[0] & VFC_SAA9051_FD) {
 524                 if(buf[0] & VFC_SAA9051_CD)
 525                         status = NTSC_COLOR;
 526                 else
 527                         status = NTSC_NOCOLOR;
 528         } else {
 529                 if(buf[0] & VFC_SAA9051_CD)
 530                         status = PAL_COLOR;
 531                 else
 532                         status = PAL_NOCOLOR;
 533         }
 534         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGVID) returning status 0x%x; "
 535                                 "buf[0]=%x\n", dev->instance, status, buf[0]));
 536
 537         if (copy_to_user((void __user *)arg,&status,sizeof(unsigned int))) {
 538                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer to "
 539                                         "vfc_get_video_ioctl\n",
 540                                         dev->instance));
 541                 return ret;
 542         }
 543         return ret;
 544 }
 545
 546 static int vfc_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 547               unsigned long arg)
 548 {
 549         int ret = 0;
 550         unsigned int tmp;
 551         struct vfc_dev *dev;
 552         void __user *argp = (void __user *)arg;
 553
 554         dev = vfc_get_dev_ptr(iminor(inode));
 555         if(dev == NULL)
 556                 return -ENODEV;
 557
 558         switch(cmd & 0x0000ffff) {
 559         case VFCGCTRL:
 560 #if 0
 561                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCGCTRL)\n", dev->instance));
 562 #endif
 563                 tmp = sbus_readl(&dev->regs->control);
 564                 if(copy_to_user(argp, &tmp, sizeof(unsigned int))) {
 565                         ret = -EFAULT;
 566                         break;
 567                 }
 568                 ret = 0;
 569                 break;
 570         case VFCSCTRL:
 571                 ret = vfc_set_control_ioctl(inode, file, dev, arg);
 572                 break;
 573         case VFCGVID:
 574                 ret = vfc_get_video_ioctl(inode, file, dev, arg);
 575                 break;
 576         case VFCSVID:
 577                 ret = vfc_set_video_ioctl(inode, file, dev, arg);
 578                 break;
 579         case VFCHUE:
 580                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCHUE)\n", dev->instance));
 581                 if(copy_from_user(&tmp,argp,sizeof(unsigned int))) {
 582                         VFC_IOCTL_DEBUG_PRINTK(("vfc%d: User passed bogus pointer "
 583                                                 "to IOCTL(VFCHUE)", dev->instance));
 584                         ret = -EFAULT;
 585                 } else {
 586                         VFC_SAA9051_SA(dev,VFC_SAA9051_HUE) = tmp;
 587                         vfc_update_saa9051(dev);
 588                         ret = 0;
 589                 }
 590                 break;
 591         case VFCPORTCHG:
 592                 ret = vfc_port_change_ioctl(inode, file, dev, arg);
 593                 break;
 594         case VFCRDINFO:
 595                 ret = -EINVAL;
 596                 VFC_IOCTL_DEBUG_PRINTK(("vfc%d: IOCTL(VFCRDINFO)\n", dev->instance));
 597                 break;
 598         default:
 599                 ret = vfc_debug(vfc_get_dev_ptr(iminor(inode)), cmd, argp);
 600                 break;
 601         };
 602
 603         return ret;
 604 }
 605
 606 static int vfc_mmap(struct file *file, struct vm_area_struct *vma)
 607 {
 608         unsigned int map_size, ret, map_offset;
 609         struct vfc_dev *dev;
 610
 611         dev = vfc_get_dev_ptr(iminor(file->f_path.dentry->d_inode));
 612         if(dev == NULL)
 613                 return -ENODEV;
 614
 615         map_size = vma->vm_end - vma->vm_start;
 616         if(map_size > sizeof(struct vfc_regs))
 617                 map_size = sizeof(struct vfc_regs);
 618
 619         vma->vm_flags |=
 620                 (VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
 621         map_offset = (unsigned int) (long)dev->phys_regs;
 622         ret = io_remap_pfn_range(vma, vma->vm_start,
 623                                   MK_IOSPACE_PFN(dev->which_io,
 624                                         map_offset >> PAGE_SHIFT),
 625                                   map_size, vma->vm_page_prot);
 626
 627         if(ret)
 628                 return -EAGAIN;
 629
 630         return 0;
 631 }
 632
 633
 634 static const struct file_operations vfc_fops = {
 635         .owner =        THIS_MODULE,
 636         .llseek =       no_llseek,
 637         .ioctl =        vfc_ioctl,
 638         .mmap =         vfc_mmap,
 639         .open =         vfc_open,
 640         .release =      vfc_release,
 641 };
 642
 643 static int vfc_probe(void)
 644 {
 645         struct sbus_bus *sbus;
 646         struct sbus_dev *sdev = NULL;
 647         int ret;
 648         int instance = 0, cards = 0;
 649
 650         for_all_sbusdev(sdev, sbus) {
 651                 if (strcmp(sdev->prom_name, "vfc") == 0) {
 652                         cards++;
 653                         continue;
 654                 }
 655         }
 656
 657         if (!cards)
 658                 return -ENODEV;
 659
 660         vfc_dev_lst = kmalloc(sizeof(struct vfc_dev *) *
 661                                                  (cards+1),
 662                                                  GFP_KERNEL);
 663         if (vfc_dev_lst == NULL)
 664                 return -ENOMEM;
 665         memset(vfc_dev_lst, 0, sizeof(struct vfc_dev *) * (cards + 1));
 666         vfc_dev_lst[cards] = NULL;
 667
 668         ret = register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
 669         if(ret) {
 670                 printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
 671                 kfree(vfc_dev_lst);
 672                 return -EIO;
 673         }
 674         instance = 0;
 675         for_all_sbusdev(sdev, sbus) {
 676                 if (strcmp(sdev->prom_name, "vfc") == 0) {
 677                         vfc_dev_lst[instance]=(struct vfc_dev *)
 678                                 kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
 679                         if (vfc_dev_lst[instance] == NULL)
 680                                 return -ENOMEM;
 681                         ret = init_vfc_device(sdev,
 682                                               vfc_dev_lst[instance],
 683                                               instance);
 684                         if(ret) {
 685                                 printk(KERN_ERR "Unable to initialize"
 686                                        " vfc%d device\n",
 687                                        instance);
 688                         } else {
 689                         }
 690
 691                         instance++;
 692                         continue;
 693                 }
 694         }
 695
 696         return 0;
 697 }
 698
 699 #ifdef MODULE
 700 int init_module(void)
 701 #else
 702 int vfc_init(void)
 703 #endif
 704 {
 705         return vfc_probe();
 706 }
 707
 708 #ifdef MODULE
 709 static void deinit_vfc_device(struct vfc_dev *dev)
 710 {
 711         if(dev == NULL)
 712                 return;
 713         sbus_iounmap(dev->regs, sizeof(struct vfc_regs));
 714         kfree(dev);
 715 }
 716
 717 void cleanup_module(void)
 718 {
 719         struct vfc_dev **devp;
 720
 721         unregister_chrdev(VFC_MAJOR,vfcstr);
 722
 723         for (devp = vfc_dev_lst; *devp; devp++)
 724                 deinit_vfc_device(*devp);
 725
 726         kfree(vfc_dev_lst);
 727         return;
 728 }
 729 #endif
 730
 731 MODULE_LICENSE("GPL");
 732