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