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                         vfc_unlock_device(dev);
 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 = kcalloc(cards + 1, sizeof(struct vfc_dev*), GFP_KERNEL);
 661         if (vfc_dev_lst == NULL)
 662                 return -ENOMEM;
 663         vfc_dev_lst[cards] = NULL;
 664
 665         ret = register_chrdev(VFC_MAJOR, vfcstr, &vfc_fops);
 666         if(ret) {
 667                 printk(KERN_ERR "Unable to get major number %d\n", VFC_MAJOR);
 668                 kfree(vfc_dev_lst);
 669                 return -EIO;
 670         }
 671         instance = 0;
 672         for_all_sbusdev(sdev, sbus) {
 673                 if (strcmp(sdev->prom_name, "vfc") == 0) {
 674                         vfc_dev_lst[instance]=(struct vfc_dev *)
 675                                 kmalloc(sizeof(struct vfc_dev), GFP_KERNEL);
 676                         if (vfc_dev_lst[instance] == NULL)
 677                                 return -ENOMEM;
 678                         ret = init_vfc_device(sdev,
 679                                               vfc_dev_lst[instance],
 680                                               instance);
 681                         if(ret) {
 682                                 printk(KERN_ERR "Unable to initialize"
 683                                        " vfc%d device\n",
 684                                        instance);
 685                         } else {
 686                         }
 687
 688                         instance++;
 689                         continue;
 690                 }
 691         }
 692
 693         return 0;
 694 }
 695
 696 #ifdef MODULE
 697 int init_module(void)
 698 #else
 699 int vfc_init(void)
 700 #endif
 701 {
 702         return vfc_probe();
 703 }
 704
 705 #ifdef MODULE
 706 static void deinit_vfc_device(struct vfc_dev *dev)
 707 {
 708         if(dev == NULL)
 709                 return;
 710         sbus_iounmap(dev->regs, sizeof(struct vfc_regs));
 711         kfree(dev);
 712 }
 713
 714 void cleanup_module(void)
 715 {
 716         struct vfc_dev **devp;
 717
 718         unregister_chrdev(VFC_MAJOR,vfcstr);
 719
 720         for (devp = vfc_dev_lst; *devp; devp++)
 721                 deinit_vfc_device(*devp);
 722
 723         kfree(vfc_dev_lst);
 724         return;
 725 }
 726 #endif
 727
 728 MODULE_LICENSE("GPL");
 729