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
;
52 static unsigned char phantom_devices
[PHANTOM_MAX_MINORS
];
54 static int phantom_status(struct phantom_device
*dev
, unsigned long newstat
)
56 pr_debug("phantom_status %lx %lx\n", dev
->status
, newstat
);
58 if (!(dev
->status
& PHB_RUNNING
) && (newstat
& PHB_RUNNING
)) {
59 atomic_set(&dev
->counter
, 0);
60 iowrite32(PHN_CTL_IRQ
, dev
->iaddr
+ PHN_CONTROL
);
61 iowrite32(0x43, dev
->caddr
+ PHN_IRQCTL
);
62 } else if ((dev
->status
& PHB_RUNNING
) && !(newstat
& PHB_RUNNING
))
63 iowrite32(0, dev
->caddr
+ PHN_IRQCTL
);
65 dev
->status
= newstat
;
74 static int phantom_ioctl(struct inode
*inode
, struct file
*file
, u_int cmd
,
77 struct phantom_device
*dev
= file
->private_data
;
80 void __user
*argp
= (void __user
*)arg
;
83 if (_IOC_TYPE(cmd
) != PH_IOC_MAGIC
||
84 _IOC_NR(cmd
) > PH_IOC_MAXNR
)
89 if (copy_from_user(&r
, argp
, sizeof(r
)))
95 if (r
.reg
== PHN_CONTROL
&& (r
.value
& PHN_CTL_IRQ
) &&
96 phantom_status(dev
, dev
->status
| PHB_RUNNING
))
99 pr_debug("phantom: writing %x to %u\n", r
.value
, r
.reg
);
100 iowrite32(r
.value
, dev
->iaddr
+ r
.reg
);
102 if (r
.reg
== PHN_CONTROL
&& !(r
.value
& PHN_CTL_IRQ
))
103 phantom_status(dev
, dev
->status
& ~PHB_RUNNING
);
106 if (copy_from_user(&rs
, argp
, sizeof(rs
)))
109 pr_debug("phantom: SRS %u regs %x\n", rs
.count
, rs
.mask
);
110 for (i
= 0; i
< min(rs
.count
, 8U); i
++)
111 if ((1 << i
) & rs
.mask
)
112 iowrite32(rs
.values
[i
], dev
->oaddr
+ i
);
115 if (copy_from_user(&r
, argp
, sizeof(r
)))
121 r
.value
= ioread32(dev
->iaddr
+ r
.reg
);
123 if (copy_to_user(argp
, &r
, sizeof(r
)))
127 if (copy_from_user(&rs
, argp
, sizeof(rs
)))
130 pr_debug("phantom: GRS %u regs %x\n", rs
.count
, rs
.mask
);
131 for (i
= 0; i
< min(rs
.count
, 8U); i
++)
132 if ((1 << i
) & rs
.mask
)
133 rs
.values
[i
] = ioread32(dev
->iaddr
+ i
);
135 if (copy_to_user(argp
, &rs
, sizeof(rs
)))
145 static int phantom_open(struct inode
*inode
, struct file
*file
)
147 struct phantom_device
*dev
= container_of(inode
->i_cdev
,
148 struct phantom_device
, cdev
);
150 nonseekable_open(inode
, file
);
152 if (mutex_lock_interruptible(&dev
->open_lock
))
156 mutex_unlock(&dev
->open_lock
);
160 file
->private_data
= dev
;
163 mutex_unlock(&dev
->open_lock
);
168 static int phantom_release(struct inode
*inode
, struct file
*file
)
170 struct phantom_device
*dev
= file
->private_data
;
172 mutex_lock(&dev
->open_lock
);
175 phantom_status(dev
, dev
->status
& ~PHB_RUNNING
);
177 mutex_unlock(&dev
->open_lock
);
182 static unsigned int phantom_poll(struct file
*file
, poll_table
*wait
)
184 struct phantom_device
*dev
= file
->private_data
;
185 unsigned int mask
= 0;
187 pr_debug("phantom_poll: %d\n", atomic_read(&dev
->counter
));
188 poll_wait(file
, &dev
->wait
, wait
);
189 if (atomic_read(&dev
->counter
)) {
190 mask
= POLLIN
| POLLRDNORM
;
191 atomic_dec(&dev
->counter
);
192 } else if ((dev
->status
& PHB_RUNNING
) == 0)
193 mask
= POLLIN
| POLLRDNORM
| POLLERR
;
194 pr_debug("phantom_poll end: %x/%d\n", mask
, atomic_read(&dev
->counter
));
199 static struct file_operations phantom_file_ops
= {
200 .open
= phantom_open
,
201 .release
= phantom_release
,
202 .ioctl
= phantom_ioctl
,
203 .poll
= phantom_poll
,
206 static irqreturn_t
phantom_isr(int irq
, void *data
)
208 struct phantom_device
*dev
= data
;
210 if (!(ioread32(dev
->iaddr
+ PHN_CONTROL
) & PHN_CTL_IRQ
))
213 iowrite32(0, dev
->iaddr
);
214 iowrite32(0xc0, dev
->iaddr
);
216 atomic_inc(&dev
->counter
);
217 wake_up_interruptible(&dev
->wait
);
223 * Init and deinit driver
226 static unsigned int __devinit
phantom_get_free(void)
230 for (i
= 0; i
< PHANTOM_MAX_MINORS
; i
++)
231 if (phantom_devices
[i
] == 0)
237 static int __devinit
phantom_probe(struct pci_dev
*pdev
,
238 const struct pci_device_id
*pci_id
)
240 struct phantom_device
*pht
;
244 retval
= pci_enable_device(pdev
);
248 minor
= phantom_get_free();
249 if (minor
== PHANTOM_MAX_MINORS
) {
250 dev_err(&pdev
->dev
, "too many devices found!\n");
255 phantom_devices
[minor
] = 1;
257 retval
= pci_request_regions(pdev
, "phantom");
262 pht
= kzalloc(sizeof(*pht
), GFP_KERNEL
);
264 dev_err(&pdev
->dev
, "unable to allocate device\n");
268 pht
->caddr
= pci_iomap(pdev
, 0, 0);
269 if (pht
->caddr
== NULL
) {
270 dev_err(&pdev
->dev
, "can't remap conf space\n");
273 pht
->iaddr
= pci_iomap(pdev
, 2, 0);
274 if (pht
->iaddr
== NULL
) {
275 dev_err(&pdev
->dev
, "can't remap input space\n");
278 pht
->oaddr
= pci_iomap(pdev
, 3, 0);
279 if (pht
->oaddr
== NULL
) {
280 dev_err(&pdev
->dev
, "can't remap output space\n");
284 mutex_init(&pht
->open_lock
);
285 init_waitqueue_head(&pht
->wait
);
286 cdev_init(&pht
->cdev
, &phantom_file_ops
);
287 pht
->cdev
.owner
= THIS_MODULE
;
289 iowrite32(0, pht
->caddr
+ PHN_IRQCTL
);
290 retval
= request_irq(pdev
->irq
, phantom_isr
,
291 IRQF_SHARED
| IRQF_DISABLED
, "phantom", pht
);
293 dev_err(&pdev
->dev
, "can't establish ISR\n");
297 retval
= cdev_add(&pht
->cdev
, MKDEV(phantom_major
, minor
), 1);
299 dev_err(&pdev
->dev
, "chardev registration failed\n");
303 if (IS_ERR(device_create(phantom_class
, &pdev
->dev
, MKDEV(phantom_major
,
304 minor
), "phantom%u", minor
)))
305 dev_err(&pdev
->dev
, "can't create device\n");
307 pci_set_drvdata(pdev
, pht
);
311 free_irq(pdev
->irq
, pht
);
313 pci_iounmap(pdev
, pht
->oaddr
);
315 pci_iounmap(pdev
, pht
->iaddr
);
317 pci_iounmap(pdev
, pht
->caddr
);
321 pci_release_regions(pdev
);
323 phantom_devices
[minor
] = 0;
325 pci_disable_device(pdev
);
330 static void __devexit
phantom_remove(struct pci_dev
*pdev
)
332 struct phantom_device
*pht
= pci_get_drvdata(pdev
);
333 unsigned int minor
= MINOR(pht
->cdev
.dev
);
335 device_destroy(phantom_class
, MKDEV(phantom_major
, minor
));
337 cdev_del(&pht
->cdev
);
339 iowrite32(0, pht
->caddr
+ PHN_IRQCTL
);
340 free_irq(pdev
->irq
, pht
);
342 pci_iounmap(pdev
, pht
->oaddr
);
343 pci_iounmap(pdev
, pht
->iaddr
);
344 pci_iounmap(pdev
, pht
->caddr
);
348 pci_release_regions(pdev
);
350 phantom_devices
[minor
] = 0;
352 pci_disable_device(pdev
);
356 static int phantom_suspend(struct pci_dev
*pdev
, pm_message_t state
)
358 struct phantom_device
*dev
= pci_get_drvdata(pdev
);
360 iowrite32(0, dev
->caddr
+ PHN_IRQCTL
);
365 static int phantom_resume(struct pci_dev
*pdev
)
367 struct phantom_device
*dev
= pci_get_drvdata(pdev
);
369 iowrite32(0, dev
->caddr
+ PHN_IRQCTL
);
374 #define phantom_suspend NULL
375 #define phantom_resume NULL
378 static struct pci_device_id phantom_pci_tbl
[] __devinitdata
= {
379 { PCI_DEVICE(PCI_VENDOR_ID_PLX
, PCI_DEVICE_ID_PLX_9050
),
380 .class = PCI_CLASS_BRIDGE_OTHER
<< 8, .class_mask
= 0xffff00 },
383 MODULE_DEVICE_TABLE(pci
, phantom_pci_tbl
);
385 static struct pci_driver phantom_pci_driver
= {
387 .id_table
= phantom_pci_tbl
,
388 .probe
= phantom_probe
,
389 .remove
= __devexit_p(phantom_remove
),
390 .suspend
= phantom_suspend
,
391 .resume
= phantom_resume
394 static ssize_t
phantom_show_version(struct class *cls
, char *buf
)
396 return sprintf(buf
, PHANTOM_VERSION
"\n");
399 static CLASS_ATTR(version
, 0444, phantom_show_version
, NULL
);
401 static int __init
phantom_init(void)
406 phantom_class
= class_create(THIS_MODULE
, "phantom");
407 if (IS_ERR(phantom_class
)) {
408 retval
= PTR_ERR(phantom_class
);
409 printk(KERN_ERR
"phantom: can't register phantom class\n");
412 retval
= class_create_file(phantom_class
, &class_attr_version
);
414 printk(KERN_ERR
"phantom: can't create sysfs version file\n");
418 retval
= alloc_chrdev_region(&dev
, 0, PHANTOM_MAX_MINORS
, "phantom");
420 printk(KERN_ERR
"phantom: can't register character device\n");
423 phantom_major
= MAJOR(dev
);
425 retval
= pci_register_driver(&phantom_pci_driver
);
427 printk(KERN_ERR
"phantom: can't register pci driver\n");
431 printk(KERN_INFO
"Phantom Linux Driver, version " PHANTOM_VERSION
", "
436 unregister_chrdev_region(dev
, PHANTOM_MAX_MINORS
);
438 class_remove_file(phantom_class
, &class_attr_version
);
440 class_destroy(phantom_class
);
445 static void __exit
phantom_exit(void)
447 pci_unregister_driver(&phantom_pci_driver
);
449 unregister_chrdev_region(MKDEV(phantom_major
, 0), PHANTOM_MAX_MINORS
);
451 class_remove_file(phantom_class
, &class_attr_version
);
452 class_destroy(phantom_class
);
454 pr_debug("phantom: module successfully removed\n");
457 module_init(phantom_init
);
458 module_exit(phantom_exit
);
460 MODULE_AUTHOR("Jiri Slaby <jirislaby@gmail.com>");
461 MODULE_DESCRIPTION("Sensable Phantom driver");
462 MODULE_LICENSE("GPL");
463 MODULE_VERSION(PHANTOM_VERSION
);