drivers/misc/phantom.c

   1 /*
   2  *  Copyright (C) 2005-2007 Jiri Slaby <jirislaby@gmail.com>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  You need an userspace library to cooperate with this driver. It (and other
  10  *  info) may be obtained here:
  11  *  http://www.fi.muni.cz/~xslaby/phantom.html
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/device.h>
  17 #include <linux/pci.h>
  18 #include <linux/fs.h>
  19 #include <linux/poll.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/cdev.h>
  22 #include <linux/phantom.h>
  23
  24 #include <asm/atomic.h>
  25 #include <asm/io.h>
  26
  27 #define PHANTOM_VERSION         "n0.9.5"
  28
  29 #define PHANTOM_MAX_MINORS      8
  30
  31 #define PHN_IRQCTL              0x4c    /* irq control in caddr space */
  32
  33 #define PHB_RUNNING             1
  34
  35 static struct class *phantom_class;
  36 static int phantom_major;
  37
  38 struct phantom_device {
  39         unsigned int opened;
  40         void __iomem *caddr;
  41         u32 __iomem *iaddr;
  42         u32 __iomem *oaddr;
  43         unsigned long status;
  44         atomic_t counter;
  45
  46         wait_queue_head_t wait;
  47         struct cdev cdev;
  48
  49         struct mutex open_lock;
  50         spinlock_t ioctl_lock;
  51 };
  52
  53 static unsigned char phantom_devices[PHANTOM_MAX_MINORS];
  54
  55 static int phantom_status(struct phantom_device *dev, unsigned long newstat)
  56 {
  57         pr_debug("phantom_status %lx %lx\n", dev->status, newstat);
  58
  59         if (!(dev->status & PHB_RUNNING) && (newstat & PHB_RUNNING)) {
  60                 atomic_set(&dev->counter, 0);
  61                 iowrite32(PHN_CTL_IRQ, dev->iaddr + PHN_CONTROL);
  62                 iowrite32(0x43, dev->caddr + PHN_IRQCTL);
  63         } else if ((dev->status & PHB_RUNNING) && !(newstat & PHB_RUNNING))
  64                 iowrite32(0, dev->caddr + PHN_IRQCTL);
  65
  66         dev->status = newstat;
  67
  68         return 0;
  69 }
  70
  71 /*
  72  * File ops
  73  */
  74
  75 static long phantom_ioctl(struct file *file, unsigned int cmd,
  76                 unsigned long arg)
  77 {
  78         struct phantom_device *dev = file->private_data;
  79         struct phm_regs rs;
  80         struct phm_reg r;
  81         void __user *argp = (void __user *)arg;
  82         unsigned int i;
  83
  84         if (_IOC_TYPE(cmd) != PH_IOC_MAGIC ||
  85                         _IOC_NR(cmd) > PH_IOC_MAXNR)
  86                 return -ENOTTY;
  87
  88         switch (cmd) {
  89         case PHN_SET_REG:
  90                 if (copy_from_user(&r, argp, sizeof(r)))
  91                         return -EFAULT;
  92
  93                 if (r.reg > 7)
  94                         return -EINVAL;
  95
  96                 spin_lock(&dev->ioctl_lock);
  97                 if (r.reg == PHN_CONTROL && (r.value & PHN_CTL_IRQ) &&
  98                                 phantom_status(dev, dev->status | PHB_RUNNING)){
  99                         spin_unlock(&dev->ioctl_lock);
 100                         return -ENODEV;
 101                 }
 102
 103                 pr_debug("phantom: writing %x to %u\n", r.value, r.reg);
 104                 iowrite32(r.value, dev->iaddr + r.reg);
 105
 106                 if (r.reg == PHN_CONTROL && !(r.value & PHN_CTL_IRQ))
 107                         phantom_status(dev, dev->status & ~PHB_RUNNING);
 108                 spin_unlock(&dev->ioctl_lock);
 109                 break;
 110         case PHN_SET_REGS:
 111                 if (copy_from_user(&rs, argp, sizeof(rs)))
 112                         return -EFAULT;
 113
 114                 pr_debug("phantom: SRS %u regs %x\n", rs.count, rs.mask);
 115                 spin_lock(&dev->ioctl_lock);
 116                 for (i = 0; i < min(rs.count, 8U); i++)
 117                         if ((1 << i) & rs.mask)
 118                                 iowrite32(rs.values[i], dev->oaddr + i);
 119                 spin_unlock(&dev->ioctl_lock);
 120                 break;
 121         case PHN_GET_REG:
 122                 if (copy_from_user(&r, argp, sizeof(r)))
 123                         return -EFAULT;
 124
 125                 if (r.reg > 7)
 126                         return -EINVAL;
 127
 128                 r.value = ioread32(dev->iaddr + r.reg);
 129
 130                 if (copy_to_user(argp, &r, sizeof(r)))
 131                         return -EFAULT;
 132                 break;
 133         case PHN_GET_REGS:
 134                 if (copy_from_user(&rs, argp, sizeof(rs)))
 135                         return -EFAULT;
 136
 137                 pr_debug("phantom: GRS %u regs %x\n", rs.count, rs.mask);
 138                 spin_lock(&dev->ioctl_lock);
 139                 for (i = 0; i < min(rs.count, 8U); i++)
 140                         if ((1 << i) & rs.mask)
 141                                 rs.values[i] = ioread32(dev->iaddr + i);
 142                 spin_unlock(&dev->ioctl_lock);
 143
 144                 if (copy_to_user(argp, &rs, sizeof(rs)))
 145                         return -EFAULT;
 146                 break;
 147         default:
 148                 return -ENOTTY;
 149         }
 150
 151         return 0;
 152 }
 153
 154 static int phantom_open(struct inode *inode, struct file *file)
 155 {
 156         struct phantom_device *dev = container_of(inode->i_cdev,
 157                         struct phantom_device, cdev);
 158
 159         nonseekable_open(inode, file);
 160
 161         if (mutex_lock_interruptible(&dev->open_lock))
 162                 return -ERESTARTSYS;
 163
 164         if (dev->opened) {
 165                 mutex_unlock(&dev->open_lock);
 166                 return -EINVAL;
 167         }
 168
 169         file->private_data = dev;
 170
 171         dev->opened++;
 172         mutex_unlock(&dev->open_lock);
 173
 174         return 0;
 175 }
 176
 177 static int phantom_release(struct inode *inode, struct file *file)
 178 {
 179         struct phantom_device *dev = file->private_data;
 180
 181         mutex_lock(&dev->open_lock);
 182
 183         dev->opened = 0;
 184         phantom_status(dev, dev->status & ~PHB_RUNNING);
 185
 186         mutex_unlock(&dev->open_lock);
 187
 188         return 0;
 189 }
 190
 191 static unsigned int phantom_poll(struct file *file, poll_table *wait)
 192 {
 193         struct phantom_device *dev = file->private_data;
 194         unsigned int mask = 0;
 195
 196         pr_debug("phantom_poll: %d\n", atomic_read(&dev->counter));
 197         poll_wait(file, &dev->wait, wait);
 198         if (atomic_read(&dev->counter)) {
 199                 mask = POLLIN | POLLRDNORM;
 200                 atomic_dec(&dev->counter);
 201         } else if ((dev->status & PHB_RUNNING) == 0)
 202                 mask = POLLIN | POLLRDNORM | POLLERR;
 203         pr_debug("phantom_poll end: %x/%d\n", mask, atomic_read(&dev->counter));
 204
 205         return mask;
 206 }
 207
 208 static struct file_operations phantom_file_ops = {
 209         .open = phantom_open,
 210         .release = phantom_release,
 211         .unlocked_ioctl = phantom_ioctl,
 212         .poll = phantom_poll,
 213 };
 214
 215 static irqreturn_t phantom_isr(int irq, void *data)
 216 {
 217         struct phantom_device *dev = data;
 218
 219         if (!(ioread32(dev->iaddr + PHN_CONTROL) & PHN_CTL_IRQ))
 220                 return IRQ_NONE;
 221
 222         iowrite32(0, dev->iaddr);
 223         iowrite32(0xc0, dev->iaddr);
 224
 225         atomic_inc(&dev->counter);
 226         wake_up_interruptible(&dev->wait);
 227
 228         return IRQ_HANDLED;
 229 }
 230
 231 /*
 232  * Init and deinit driver
 233  */
 234
 235 static unsigned int __devinit phantom_get_free(void)
 236 {
 237         unsigned int i;
 238
 239         for (i = 0; i < PHANTOM_MAX_MINORS; i++)
 240                 if (phantom_devices[i] == 0)
 241                         break;
 242
 243         return i;
 244 }
 245
 246 static int __devinit phantom_probe(struct pci_dev *pdev,
 247         const struct pci_device_id *pci_id)
 248 {
 249         struct phantom_device *pht;
 250         unsigned int minor;
 251         int retval;
 252
 253         retval = pci_enable_device(pdev);
 254         if (retval)
 255                 goto err;
 256
 257         minor = phantom_get_free();
 258         if (minor == PHANTOM_MAX_MINORS) {
 259                 dev_err(&pdev->dev, "too many devices found!\n");
 260                 retval = -EIO;
 261                 goto err_dis;
 262         }
 263
 264         phantom_devices[minor] = 1;
 265
 266         retval = pci_request_regions(pdev, "phantom");
 267         if (retval)
 268                 goto err_null;
 269
 270         retval = -ENOMEM;
 271         pht = kzalloc(sizeof(*pht), GFP_KERNEL);
 272         if (pht == NULL) {
 273                 dev_err(&pdev->dev, "unable to allocate device\n");
 274                 goto err_reg;
 275         }
 276
 277         pht->caddr = pci_iomap(pdev, 0, 0);
 278         if (pht->caddr == NULL) {
 279                 dev_err(&pdev->dev, "can't remap conf space\n");
 280                 goto err_fr;
 281         }
 282         pht->iaddr = pci_iomap(pdev, 2, 0);
 283         if (pht->iaddr == NULL) {
 284                 dev_err(&pdev->dev, "can't remap input space\n");
 285                 goto err_unmc;
 286         }
 287         pht->oaddr = pci_iomap(pdev, 3, 0);
 288         if (pht->oaddr == NULL) {
 289                 dev_err(&pdev->dev, "can't remap output space\n");
 290                 goto err_unmi;
 291         }
 292
 293         mutex_init(&pht->open_lock);
 294         spin_lock_init(&pht->ioctl_lock);
 295         init_waitqueue_head(&pht->wait);
 296         cdev_init(&pht->cdev, &phantom_file_ops);
 297         pht->cdev.owner = THIS_MODULE;
 298
 299         iowrite32(0, pht->caddr + PHN_IRQCTL);
 300         retval = request_irq(pdev->irq, phantom_isr,
 301                         IRQF_SHARED | IRQF_DISABLED, "phantom", pht);
 302         if (retval) {
 303                 dev_err(&pdev->dev, "can't establish ISR\n");
 304                 goto err_unmo;
 305         }
 306
 307         retval = cdev_add(&pht->cdev, MKDEV(phantom_major, minor), 1);
 308         if (retval) {
 309                 dev_err(&pdev->dev, "chardev registration failed\n");
 310                 goto err_irq;
 311         }
 312
 313         if (IS_ERR(device_create(phantom_class, &pdev->dev, MKDEV(phantom_major,
 314                         minor), "phantom%u", minor)))
 315                 dev_err(&pdev->dev, "can't create device\n");
 316
 317         pci_set_drvdata(pdev, pht);
 318
 319         return 0;
 320 err_irq:
 321         free_irq(pdev->irq, pht);
 322 err_unmo:
 323         pci_iounmap(pdev, pht->oaddr);
 324 err_unmi:
 325         pci_iounmap(pdev, pht->iaddr);
 326 err_unmc:
 327         pci_iounmap(pdev, pht->caddr);
 328 err_fr:
 329         kfree(pht);
 330 err_reg:
 331         pci_release_regions(pdev);
 332 err_null:
 333         phantom_devices[minor] = 0;
 334 err_dis:
 335         pci_disable_device(pdev);
 336 err:
 337         return retval;
 338 }
 339
 340 static void __devexit phantom_remove(struct pci_dev *pdev)
 341 {
 342         struct phantom_device *pht = pci_get_drvdata(pdev);
 343         unsigned int minor = MINOR(pht->cdev.dev);
 344
 345         device_destroy(phantom_class, MKDEV(phantom_major, minor));
 346
 347         cdev_del(&pht->cdev);
 348
 349         iowrite32(0, pht->caddr + PHN_IRQCTL);
 350         free_irq(pdev->irq, pht);
 351
 352         pci_iounmap(pdev, pht->oaddr);
 353         pci_iounmap(pdev, pht->iaddr);
 354         pci_iounmap(pdev, pht->caddr);
 355
 356         kfree(pht);
 357
 358         pci_release_regions(pdev);
 359
 360         phantom_devices[minor] = 0;
 361
 362         pci_disable_device(pdev);
 363 }
 364
 365 #ifdef CONFIG_PM
 366 static int phantom_suspend(struct pci_dev *pdev, pm_message_t state)
 367 {
 368         struct phantom_device *dev = pci_get_drvdata(pdev);
 369
 370         iowrite32(0, dev->caddr + PHN_IRQCTL);
 371
 372         return 0;
 373 }
 374
 375 static int phantom_resume(struct pci_dev *pdev)
 376 {
 377         struct phantom_device *dev = pci_get_drvdata(pdev);
 378
 379         iowrite32(0, dev->caddr + PHN_IRQCTL);
 380
 381         return 0;
 382 }
 383 #else
 384 #define phantom_suspend NULL
 385 #define phantom_resume  NULL
 386 #endif
 387
 388 static struct pci_device_id phantom_pci_tbl[] __devinitdata = {
 389         { PCI_DEVICE(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050),
 390                 .class = PCI_CLASS_BRIDGE_OTHER << 8, .class_mask = 0xffff00 },
 391         { 0, }
 392 };
 393 MODULE_DEVICE_TABLE(pci, phantom_pci_tbl);
 394
 395 static struct pci_driver phantom_pci_driver = {
 396         .name = "phantom",
 397         .id_table = phantom_pci_tbl,
 398         .probe = phantom_probe,
 399         .remove = __devexit_p(phantom_remove),
 400         .suspend = phantom_suspend,
 401         .resume = phantom_resume
 402 };
 403
 404 static ssize_t phantom_show_version(struct class *cls, char *buf)
 405 {
 406         return sprintf(buf, PHANTOM_VERSION "\n");
 407 }
 408
 409 static CLASS_ATTR(version, 0444, phantom_show_version, NULL);
 410
 411 static int __init phantom_init(void)
 412 {
 413         int retval;
 414         dev_t dev;
 415
 416         phantom_class = class_create(THIS_MODULE, "phantom");
 417         if (IS_ERR(phantom_class)) {
 418                 retval = PTR_ERR(phantom_class);
 419                 printk(KERN_ERR "phantom: can't register phantom class\n");
 420                 goto err;
 421         }
 422         retval = class_create_file(phantom_class, &class_attr_version);
 423         if (retval) {
 424                 printk(KERN_ERR "phantom: can't create sysfs version file\n");
 425                 goto err_class;
 426         }
 427
 428         retval = alloc_chrdev_region(&dev, 0, PHANTOM_MAX_MINORS, "phantom");
 429         if (retval) {
 430                 printk(KERN_ERR "phantom: can't register character device\n");
 431                 goto err_attr;
 432         }
 433         phantom_major = MAJOR(dev);
 434
 435         retval = pci_register_driver(&phantom_pci_driver);
 436         if (retval) {
 437                 printk(KERN_ERR "phantom: can't register pci driver\n");
 438                 goto err_unchr;
 439         }
 440
 441         printk(KERN_INFO "Phantom Linux Driver, version " PHANTOM_VERSION ", "
 442                         "init OK\n");
 443
 444         return 0;
 445 err_unchr:
 446         unregister_chrdev_region(dev, PHANTOM_MAX_MINORS);
 447 err_attr:
 448         class_remove_file(phantom_class, &class_attr_version);
 449 err_class:
 450         class_destroy(phantom_class);
 451 err:
 452         return retval;
 453 }
 454
 455 static void __exit phantom_exit(void)
 456 {
 457         pci_unregister_driver(&phantom_pci_driver);
 458
 459         unregister_chrdev_region(MKDEV(phantom_major, 0), PHANTOM_MAX_MINORS);
 460
 461         class_remove_file(phantom_class, &class_attr_version);
 462         class_destroy(phantom_class);
 463
 464         pr_debug("phantom: module successfully removed\n");
 465 }
 466
 467 module_init(phantom_init);
 468 module_exit(phantom_exit);
 469
 470 MODULE_AUTHOR("Jiri Slaby <jirislaby@gmail.com>");
 471 MODULE_DESCRIPTION("Sensable Phantom driver");
 472 MODULE_LICENSE("GPL");
 473 MODULE_VERSION(PHANTOM_VERSION);