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
12 * or alternatively, you might use OpenHaptics provided by Sensable.
15 #include <linux/compat.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/device.h>
19 #include <linux/pci.h>
21 #include <linux/poll.h>
22 #include <linux/interrupt.h>
23 #include <linux/cdev.h>
24 #include <linux/phantom.h>
26 #include <asm/atomic.h>
29 #define PHANTOM_VERSION "n0.9.8"
31 #define PHANTOM_MAX_MINORS 8
33 #define PHN_IRQCTL 0x4c /* irq control in caddr space */
38 static struct class *phantom_class
;
39 static int phantom_major
;
41 struct phantom_device
{
49 wait_queue_head_t wait
;
52 struct mutex open_lock
;
55 /* used in NOT_OH mode */
56 struct phm_regs oregs
;
60 static unsigned char phantom_devices
[PHANTOM_MAX_MINORS
];
62 static int phantom_status(struct phantom_device
*dev
, unsigned long newstat
)
64 pr_debug("phantom_status %lx %lx\n", dev
->status
, newstat
);
66 if (!(dev
->status
& PHB_RUNNING
) && (newstat
& PHB_RUNNING
)) {
67 atomic_set(&dev
->counter
, 0);
68 iowrite32(PHN_CTL_IRQ
, dev
->iaddr
+ PHN_CONTROL
);
69 iowrite32(0x43, dev
->caddr
+ PHN_IRQCTL
);
70 ioread32(dev
->caddr
+ PHN_IRQCTL
); /* PCI posting */
71 } else if ((dev
->status
& PHB_RUNNING
) && !(newstat
& PHB_RUNNING
)) {
72 iowrite32(0, dev
->caddr
+ PHN_IRQCTL
);
73 ioread32(dev
->caddr
+ PHN_IRQCTL
); /* PCI posting */
76 dev
->status
= newstat
;
85 static long phantom_ioctl(struct file
*file
, unsigned int cmd
,
88 struct phantom_device
*dev
= file
->private_data
;
91 void __user
*argp
= (void __user
*)arg
;
98 if (copy_from_user(&r
, argp
, sizeof(r
)))
104 spin_lock_irqsave(&dev
->regs_lock
, flags
);
105 if (r
.reg
== PHN_CONTROL
&& (r
.value
& PHN_CTL_IRQ
) &&
106 phantom_status(dev
, dev
->status
| PHB_RUNNING
)){
107 spin_unlock_irqrestore(&dev
->regs_lock
, flags
);
111 pr_debug("phantom: writing %x to %u\n", r
.value
, r
.reg
);
113 /* preserve amp bit (don't allow to change it when in NOT_OH) */
114 if (r
.reg
== PHN_CONTROL
&& (dev
->status
& PHB_NOT_OH
)) {
115 r
.value
&= ~PHN_CTL_AMP
;
116 r
.value
|= dev
->ctl_reg
& PHN_CTL_AMP
;
117 dev
->ctl_reg
= r
.value
;
120 iowrite32(r
.value
, dev
->iaddr
+ r
.reg
);
121 ioread32(dev
->iaddr
); /* PCI posting */
123 if (r
.reg
== PHN_CONTROL
&& !(r
.value
& PHN_CTL_IRQ
))
124 phantom_status(dev
, dev
->status
& ~PHB_RUNNING
);
125 spin_unlock_irqrestore(&dev
->regs_lock
, flags
);
129 if (copy_from_user(&rs
, argp
, sizeof(rs
)))
132 pr_debug("phantom: SRS %u regs %x\n", rs
.count
, rs
.mask
);
133 spin_lock_irqsave(&dev
->regs_lock
, flags
);
134 if (dev
->status
& PHB_NOT_OH
)
135 memcpy(&dev
->oregs
, &rs
, sizeof(rs
));
137 u32 m
= min(rs
.count
, 8U);
138 for (i
= 0; i
< m
; i
++)
139 if (rs
.mask
& BIT(i
))
140 iowrite32(rs
.values
[i
], dev
->oaddr
+ i
);
141 ioread32(dev
->iaddr
); /* PCI posting */
143 spin_unlock_irqrestore(&dev
->regs_lock
, flags
);
147 if (copy_from_user(&r
, argp
, sizeof(r
)))
153 r
.value
= ioread32(dev
->iaddr
+ r
.reg
);
155 if (copy_to_user(argp
, &r
, sizeof(r
)))
162 if (copy_from_user(&rs
, argp
, sizeof(rs
)))
165 m
= min(rs
.count
, 8U);
167 pr_debug("phantom: GRS %u regs %x\n", rs
.count
, rs
.mask
);
168 spin_lock_irqsave(&dev
->regs_lock
, flags
);
169 for (i
= 0; i
< m
; i
++)
170 if (rs
.mask
& BIT(i
))
171 rs
.values
[i
] = ioread32(dev
->iaddr
+ i
);
172 spin_unlock_irqrestore(&dev
->regs_lock
, flags
);
174 if (copy_to_user(argp
, &rs
, sizeof(rs
)))
178 spin_lock_irqsave(&dev
->regs_lock
, flags
);
179 if (dev
->status
& PHB_RUNNING
) {
180 printk(KERN_ERR
"phantom: you need to set NOT_OH "
181 "before you start the device!\n");
182 spin_unlock_irqrestore(&dev
->regs_lock
, flags
);
185 dev
->status
|= PHB_NOT_OH
;
186 spin_unlock_irqrestore(&dev
->regs_lock
, flags
);
196 static long phantom_compat_ioctl(struct file
*filp
, unsigned int cmd
,
199 if (_IOC_NR(cmd
) <= 3 && _IOC_SIZE(cmd
) == sizeof(compat_uptr_t
)) {
200 cmd
&= ~(_IOC_SIZEMASK
<< _IOC_SIZESHIFT
);
201 cmd
|= sizeof(void *) << _IOC_SIZESHIFT
;
203 return phantom_ioctl(filp
, cmd
, (unsigned long)compat_ptr(arg
));
206 #define phantom_compat_ioctl NULL
209 static int phantom_open(struct inode
*inode
, struct file
*file
)
211 struct phantom_device
*dev
= container_of(inode
->i_cdev
,
212 struct phantom_device
, cdev
);
214 nonseekable_open(inode
, file
);
216 if (mutex_lock_interruptible(&dev
->open_lock
))
220 mutex_unlock(&dev
->open_lock
);
224 WARN_ON(dev
->status
& PHB_NOT_OH
);
226 file
->private_data
= dev
;
228 atomic_set(&dev
->counter
, 0);
230 mutex_unlock(&dev
->open_lock
);
235 static int phantom_release(struct inode
*inode
, struct file
*file
)
237 struct phantom_device
*dev
= file
->private_data
;
239 mutex_lock(&dev
->open_lock
);
242 phantom_status(dev
, dev
->status
& ~PHB_RUNNING
);
243 dev
->status
&= ~PHB_NOT_OH
;
245 mutex_unlock(&dev
->open_lock
);
250 static unsigned int phantom_poll(struct file
*file
, poll_table
*wait
)
252 struct phantom_device
*dev
= file
->private_data
;
253 unsigned int mask
= 0;
255 pr_debug("phantom_poll: %d\n", atomic_read(&dev
->counter
));
256 poll_wait(file
, &dev
->wait
, wait
);
257 if (atomic_read(&dev
->counter
)) {
258 mask
= POLLIN
| POLLRDNORM
;
259 atomic_dec(&dev
->counter
);
260 } else if ((dev
->status
& PHB_RUNNING
) == 0)
261 mask
= POLLIN
| POLLRDNORM
| POLLERR
;
262 pr_debug("phantom_poll end: %x/%d\n", mask
, atomic_read(&dev
->counter
));
267 static struct file_operations phantom_file_ops
= {
268 .open
= phantom_open
,
269 .release
= phantom_release
,
270 .unlocked_ioctl
= phantom_ioctl
,
271 .compat_ioctl
= phantom_compat_ioctl
,
272 .poll
= phantom_poll
,
275 static irqreturn_t
phantom_isr(int irq
, void *data
)
277 struct phantom_device
*dev
= data
;
281 spin_lock(&dev
->regs_lock
);
282 ctl
= ioread32(dev
->iaddr
+ PHN_CONTROL
);
283 if (!(ctl
& PHN_CTL_IRQ
)) {
284 spin_unlock(&dev
->regs_lock
);
288 iowrite32(0, dev
->iaddr
);
289 iowrite32(0xc0, dev
->iaddr
);
291 if (dev
->status
& PHB_NOT_OH
) {
292 struct phm_regs
*r
= &dev
->oregs
;
293 u32 m
= min(r
->count
, 8U);
295 for (i
= 0; i
< m
; i
++)
296 if (r
->mask
& BIT(i
))
297 iowrite32(r
->values
[i
], dev
->oaddr
+ i
);
299 dev
->ctl_reg
^= PHN_CTL_AMP
;
300 iowrite32(dev
->ctl_reg
, dev
->iaddr
+ PHN_CONTROL
);
302 spin_unlock(&dev
->regs_lock
);
304 ioread32(dev
->iaddr
); /* PCI posting */
306 atomic_inc(&dev
->counter
);
307 wake_up_interruptible(&dev
->wait
);
313 * Init and deinit driver
316 static unsigned int __devinit
phantom_get_free(void)
320 for (i
= 0; i
< PHANTOM_MAX_MINORS
; i
++)
321 if (phantom_devices
[i
] == 0)
327 static int __devinit
phantom_probe(struct pci_dev
*pdev
,
328 const struct pci_device_id
*pci_id
)
330 struct phantom_device
*pht
;
334 retval
= pci_enable_device(pdev
);
338 minor
= phantom_get_free();
339 if (minor
== PHANTOM_MAX_MINORS
) {
340 dev_err(&pdev
->dev
, "too many devices found!\n");
345 phantom_devices
[minor
] = 1;
347 retval
= pci_request_regions(pdev
, "phantom");
352 pht
= kzalloc(sizeof(*pht
), GFP_KERNEL
);
354 dev_err(&pdev
->dev
, "unable to allocate device\n");
358 pht
->caddr
= pci_iomap(pdev
, 0, 0);
359 if (pht
->caddr
== NULL
) {
360 dev_err(&pdev
->dev
, "can't remap conf space\n");
363 pht
->iaddr
= pci_iomap(pdev
, 2, 0);
364 if (pht
->iaddr
== NULL
) {
365 dev_err(&pdev
->dev
, "can't remap input space\n");
368 pht
->oaddr
= pci_iomap(pdev
, 3, 0);
369 if (pht
->oaddr
== NULL
) {
370 dev_err(&pdev
->dev
, "can't remap output space\n");
374 mutex_init(&pht
->open_lock
);
375 spin_lock_init(&pht
->regs_lock
);
376 init_waitqueue_head(&pht
->wait
);
377 cdev_init(&pht
->cdev
, &phantom_file_ops
);
378 pht
->cdev
.owner
= THIS_MODULE
;
380 iowrite32(0, pht
->caddr
+ PHN_IRQCTL
);
381 ioread32(pht
->caddr
+ PHN_IRQCTL
); /* PCI posting */
382 retval
= request_irq(pdev
->irq
, phantom_isr
,
383 IRQF_SHARED
| IRQF_DISABLED
, "phantom", pht
);
385 dev_err(&pdev
->dev
, "can't establish ISR\n");
389 retval
= cdev_add(&pht
->cdev
, MKDEV(phantom_major
, minor
), 1);
391 dev_err(&pdev
->dev
, "chardev registration failed\n");
395 if (IS_ERR(device_create(phantom_class
, &pdev
->dev
, MKDEV(phantom_major
,
396 minor
), "phantom%u", minor
)))
397 dev_err(&pdev
->dev
, "can't create device\n");
399 pci_set_drvdata(pdev
, pht
);
403 free_irq(pdev
->irq
, pht
);
405 pci_iounmap(pdev
, pht
->oaddr
);
407 pci_iounmap(pdev
, pht
->iaddr
);
409 pci_iounmap(pdev
, pht
->caddr
);
413 pci_release_regions(pdev
);
415 phantom_devices
[minor
] = 0;
417 pci_disable_device(pdev
);
422 static void __devexit
phantom_remove(struct pci_dev
*pdev
)
424 struct phantom_device
*pht
= pci_get_drvdata(pdev
);
425 unsigned int minor
= MINOR(pht
->cdev
.dev
);
427 device_destroy(phantom_class
, MKDEV(phantom_major
, minor
));
429 cdev_del(&pht
->cdev
);
431 iowrite32(0, pht
->caddr
+ PHN_IRQCTL
);
432 ioread32(pht
->caddr
+ PHN_IRQCTL
); /* PCI posting */
433 free_irq(pdev
->irq
, pht
);
435 pci_iounmap(pdev
, pht
->oaddr
);
436 pci_iounmap(pdev
, pht
->iaddr
);
437 pci_iounmap(pdev
, pht
->caddr
);
441 pci_release_regions(pdev
);
443 phantom_devices
[minor
] = 0;
445 pci_disable_device(pdev
);
449 static int phantom_suspend(struct pci_dev
*pdev
, pm_message_t state
)
451 struct phantom_device
*dev
= pci_get_drvdata(pdev
);
453 iowrite32(0, dev
->caddr
+ PHN_IRQCTL
);
454 ioread32(dev
->caddr
+ PHN_IRQCTL
); /* PCI posting */
456 synchronize_irq(pdev
->irq
);
461 static int phantom_resume(struct pci_dev
*pdev
)
463 struct phantom_device
*dev
= pci_get_drvdata(pdev
);
465 iowrite32(0, dev
->caddr
+ PHN_IRQCTL
);
470 #define phantom_suspend NULL
471 #define phantom_resume NULL
474 static struct pci_device_id phantom_pci_tbl
[] __devinitdata
= {
475 { .vendor
= PCI_VENDOR_ID_PLX
, .device
= PCI_DEVICE_ID_PLX_9050
,
476 .subvendor
= PCI_VENDOR_ID_PLX
, .subdevice
= PCI_DEVICE_ID_PLX_9050
,
477 .class = PCI_CLASS_BRIDGE_OTHER
<< 8, .class_mask
= 0xffff00 },
480 MODULE_DEVICE_TABLE(pci
, phantom_pci_tbl
);
482 static struct pci_driver phantom_pci_driver
= {
484 .id_table
= phantom_pci_tbl
,
485 .probe
= phantom_probe
,
486 .remove
= __devexit_p(phantom_remove
),
487 .suspend
= phantom_suspend
,
488 .resume
= phantom_resume
491 static ssize_t
phantom_show_version(struct class *cls
, char *buf
)
493 return sprintf(buf
, PHANTOM_VERSION
"\n");
496 static CLASS_ATTR(version
, 0444, phantom_show_version
, NULL
);
498 static int __init
phantom_init(void)
503 phantom_class
= class_create(THIS_MODULE
, "phantom");
504 if (IS_ERR(phantom_class
)) {
505 retval
= PTR_ERR(phantom_class
);
506 printk(KERN_ERR
"phantom: can't register phantom class\n");
509 retval
= class_create_file(phantom_class
, &class_attr_version
);
511 printk(KERN_ERR
"phantom: can't create sysfs version file\n");
515 retval
= alloc_chrdev_region(&dev
, 0, PHANTOM_MAX_MINORS
, "phantom");
517 printk(KERN_ERR
"phantom: can't register character device\n");
520 phantom_major
= MAJOR(dev
);
522 retval
= pci_register_driver(&phantom_pci_driver
);
524 printk(KERN_ERR
"phantom: can't register pci driver\n");
528 printk(KERN_INFO
"Phantom Linux Driver, version " PHANTOM_VERSION
", "
533 unregister_chrdev_region(dev
, PHANTOM_MAX_MINORS
);
535 class_remove_file(phantom_class
, &class_attr_version
);
537 class_destroy(phantom_class
);
542 static void __exit
phantom_exit(void)
544 pci_unregister_driver(&phantom_pci_driver
);
546 unregister_chrdev_region(MKDEV(phantom_major
, 0), PHANTOM_MAX_MINORS
);
548 class_remove_file(phantom_class
, &class_attr_version
);
549 class_destroy(phantom_class
);
551 pr_debug("phantom: module successfully removed\n");
554 module_init(phantom_init
);
555 module_exit(phantom_exit
);
557 MODULE_AUTHOR("Jiri Slaby <jirislaby@gmail.com>");
558 MODULE_DESCRIPTION("Sensable Phantom driver");
559 MODULE_LICENSE("GPL");
560 MODULE_VERSION(PHANTOM_VERSION
);