2 * Copyright (C) 2005-2007 Jiri Slaby <jirislaby@gmail.com>
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.
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
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/device.h>
17 #include <linux/pci.h>
19 #include <linux/poll.h>
20 #include <linux/interrupt.h>
21 #include <linux/cdev.h>
22 #include <linux/phantom.h>
24 #include <asm/atomic.h>
27 #define PHANTOM_VERSION "n0.9.5"
29 #define PHANTOM_MAX_MINORS 8
31 #define PHN_IRQCTL 0x4c /* irq control in caddr space */
35 static struct class *phantom_class;
36 static int phantom_major;
38 struct phantom_device {
46 wait_queue_head_t wait;
49 struct mutex open_lock;
50 spinlock_t ioctl_lock;
53 static unsigned char phantom_devices[PHANTOM_MAX_MINORS];
55 static int phantom_status(struct phantom_device *dev, unsigned long newstat)
57 pr_debug("phantom_status %lx %lx\n", dev->status, newstat);
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);
66 dev->status = newstat;
75 static long phantom_ioctl(struct file *file, unsigned int cmd,
78 struct phantom_device *dev = file->private_data;
81 void __user *argp = (void __user *)arg;
84 if (_IOC_TYPE(cmd) != PH_IOC_MAGIC ||
85 _IOC_NR(cmd) > PH_IOC_MAXNR)
90 if (copy_from_user(&r, argp, sizeof(r)))
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);
103 pr_debug("phantom: writing %x to %u\n", r.value, r.reg);
104 iowrite32(r.value, dev->iaddr + r.reg);
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);
111 if (copy_from_user(&rs, argp, sizeof(rs)))
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);
122 if (copy_from_user(&r, argp, sizeof(r)))
128 r.value = ioread32(dev->iaddr + r.reg);
130 if (copy_to_user(argp, &r, sizeof(r)))
134 if (copy_from_user(&rs, argp, sizeof(rs)))
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);
144 if (copy_to_user(argp, &rs, sizeof(rs)))
154 static int phantom_open(struct inode *inode, struct file *file)
156 struct phantom_device *dev = container_of(inode->i_cdev,
157 struct phantom_device, cdev);
159 nonseekable_open(inode, file);
161 if (mutex_lock_interruptible(&dev->open_lock))
165 mutex_unlock(&dev->open_lock);
169 file->private_data = dev;
172 mutex_unlock(&dev->open_lock);
177 static int phantom_release(struct inode *inode, struct file *file)
179 struct phantom_device *dev = file->private_data;
181 mutex_lock(&dev->open_lock);
184 phantom_status(dev, dev->status & ~PHB_RUNNING);
186 mutex_unlock(&dev->open_lock);
191 static unsigned int phantom_poll(struct file *file, poll_table *wait)
193 struct phantom_device *dev = file->private_data;
194 unsigned int mask = 0;
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));
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,
215 static irqreturn_t phantom_isr(int irq, void *data)
217 struct phantom_device *dev = data;
219 if (!(ioread32(dev->iaddr + PHN_CONTROL) & PHN_CTL_IRQ))
222 iowrite32(0, dev->iaddr);
223 iowrite32(0xc0, dev->iaddr);
225 atomic_inc(&dev->counter);
226 wake_up_interruptible(&dev->wait);
232 * Init and deinit driver
235 static unsigned int __devinit phantom_get_free(void)
239 for (i = 0; i < PHANTOM_MAX_MINORS; i++)
240 if (phantom_devices[i] == 0)
246 static int __devinit phantom_probe(struct pci_dev *pdev,
247 const struct pci_device_id *pci_id)
249 struct phantom_device *pht;
253 retval = pci_enable_device(pdev);
257 minor = phantom_get_free();
258 if (minor == PHANTOM_MAX_MINORS) {
259 dev_err(&pdev->dev, "too many devices found!\n");
264 phantom_devices[minor] = 1;
266 retval = pci_request_regions(pdev, "phantom");
271 pht = kzalloc(sizeof(*pht), GFP_KERNEL);
273 dev_err(&pdev->dev, "unable to allocate device\n");
277 pht->caddr = pci_iomap(pdev, 0, 0);
278 if (pht->caddr == NULL) {
279 dev_err(&pdev->dev, "can't remap conf space\n");
282 pht->iaddr = pci_iomap(pdev, 2, 0);
283 if (pht->iaddr == NULL) {
284 dev_err(&pdev->dev, "can't remap input space\n");
287 pht->oaddr = pci_iomap(pdev, 3, 0);
288 if (pht->oaddr == NULL) {
289 dev_err(&pdev->dev, "can't remap output space\n");
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;
299 iowrite32(0, pht->caddr + PHN_IRQCTL);
300 retval = request_irq(pdev->irq, phantom_isr,
301 IRQF_SHARED | IRQF_DISABLED, "phantom", pht);
303 dev_err(&pdev->dev, "can't establish ISR\n");
307 retval = cdev_add(&pht->cdev, MKDEV(phantom_major, minor), 1);
309 dev_err(&pdev->dev, "chardev registration failed\n");
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");
317 pci_set_drvdata(pdev, pht);
321 free_irq(pdev->irq, pht);
323 pci_iounmap(pdev, pht->oaddr);
325 pci_iounmap(pdev, pht->iaddr);
327 pci_iounmap(pdev, pht->caddr);
331 pci_release_regions(pdev);
333 phantom_devices[minor] = 0;
335 pci_disable_device(pdev);
340 static void __devexit phantom_remove(struct pci_dev *pdev)
342 struct phantom_device *pht = pci_get_drvdata(pdev);
343 unsigned int minor = MINOR(pht->cdev.dev);
345 device_destroy(phantom_class, MKDEV(phantom_major, minor));
347 cdev_del(&pht->cdev);
349 iowrite32(0, pht->caddr + PHN_IRQCTL);
350 free_irq(pdev->irq, pht);
352 pci_iounmap(pdev, pht->oaddr);
353 pci_iounmap(pdev, pht->iaddr);
354 pci_iounmap(pdev, pht->caddr);
358 pci_release_regions(pdev);
360 phantom_devices[minor] = 0;
362 pci_disable_device(pdev);
366 static int phantom_suspend(struct pci_dev *pdev, pm_message_t state)
368 struct phantom_device *dev = pci_get_drvdata(pdev);
370 iowrite32(0, dev->caddr + PHN_IRQCTL);
375 static int phantom_resume(struct pci_dev *pdev)
377 struct phantom_device *dev = pci_get_drvdata(pdev);
379 iowrite32(0, dev->caddr + PHN_IRQCTL);
384 #define phantom_suspend NULL
385 #define phantom_resume NULL
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 },
393 MODULE_DEVICE_TABLE(pci, phantom_pci_tbl);
395 static struct pci_driver phantom_pci_driver = {
397 .id_table = phantom_pci_tbl,
398 .probe = phantom_probe,
399 .remove = __devexit_p(phantom_remove),
400 .suspend = phantom_suspend,
401 .resume = phantom_resume
404 static ssize_t phantom_show_version(struct class *cls, char *buf)
406 return sprintf(buf, PHANTOM_VERSION "\n");
409 static CLASS_ATTR(version, 0444, phantom_show_version, NULL);
411 static int __init phantom_init(void)
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");
422 retval = class_create_file(phantom_class, &class_attr_version);
424 printk(KERN_ERR "phantom: can't create sysfs version file\n");
428 retval = alloc_chrdev_region(&dev, 0, PHANTOM_MAX_MINORS, "phantom");
430 printk(KERN_ERR "phantom: can't register character device\n");
433 phantom_major = MAJOR(dev);
435 retval = pci_register_driver(&phantom_pci_driver);
437 printk(KERN_ERR "phantom: can't register pci driver\n");
441 printk(KERN_INFO "Phantom Linux Driver, version " PHANTOM_VERSION ", "
446 unregister_chrdev_region(dev, PHANTOM_MAX_MINORS);
448 class_remove_file(phantom_class, &class_attr_version);
450 class_destroy(phantom_class);
455 static void __exit phantom_exit(void)
457 pci_unregister_driver(&phantom_pci_driver);
459 unregister_chrdev_region(MKDEV(phantom_major, 0), PHANTOM_MAX_MINORS);
461 class_remove_file(phantom_class, &class_attr_version);
462 class_destroy(phantom_class);
464 pr_debug("phantom: module successfully removed\n");
467 module_init(phantom_init);
468 module_exit(phantom_exit);
470 MODULE_AUTHOR("Jiri Slaby <jirislaby@gmail.com>");
471 MODULE_DESCRIPTION("Sensable Phantom driver");
472 MODULE_LICENSE("GPL");
473 MODULE_VERSION(PHANTOM_VERSION);