Root/
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 a 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. |
13 | */ |
14 | |
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> |
20 | #include <linux/fs.h> |
21 | #include <linux/poll.h> |
22 | #include <linux/interrupt.h> |
23 | #include <linux/cdev.h> |
24 | #include <linux/slab.h> |
25 | #include <linux/phantom.h> |
26 | #include <linux/sched.h> |
27 | #include <linux/smp_lock.h> |
28 | |
29 | #include <asm/atomic.h> |
30 | #include <asm/io.h> |
31 | |
32 | #define PHANTOM_VERSION "n0.9.8" |
33 | |
34 | #define PHANTOM_MAX_MINORS 8 |
35 | |
36 | #define PHN_IRQCTL 0x4c /* irq control in caddr space */ |
37 | |
38 | #define PHB_RUNNING 1 |
39 | #define PHB_NOT_OH 2 |
40 | |
41 | static struct class *phantom_class; |
42 | static int phantom_major; |
43 | |
44 | struct phantom_device { |
45 | unsigned int opened; |
46 | void __iomem *caddr; |
47 | u32 __iomem *iaddr; |
48 | u32 __iomem *oaddr; |
49 | unsigned long status; |
50 | atomic_t counter; |
51 | |
52 | wait_queue_head_t wait; |
53 | struct cdev cdev; |
54 | |
55 | struct mutex open_lock; |
56 | spinlock_t regs_lock; |
57 | |
58 | /* used in NOT_OH mode */ |
59 | struct phm_regs oregs; |
60 | u32 ctl_reg; |
61 | }; |
62 | |
63 | static unsigned char phantom_devices[PHANTOM_MAX_MINORS]; |
64 | |
65 | static int phantom_status(struct phantom_device *dev, unsigned long newstat) |
66 | { |
67 | pr_debug("phantom_status %lx %lx\n", dev->status, newstat); |
68 | |
69 | if (!(dev->status & PHB_RUNNING) && (newstat & PHB_RUNNING)) { |
70 | atomic_set(&dev->counter, 0); |
71 | iowrite32(PHN_CTL_IRQ, dev->iaddr + PHN_CONTROL); |
72 | iowrite32(0x43, dev->caddr + PHN_IRQCTL); |
73 | ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */ |
74 | } else if ((dev->status & PHB_RUNNING) && !(newstat & PHB_RUNNING)) { |
75 | iowrite32(0, dev->caddr + PHN_IRQCTL); |
76 | ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */ |
77 | } |
78 | |
79 | dev->status = newstat; |
80 | |
81 | return 0; |
82 | } |
83 | |
84 | /* |
85 | * File ops |
86 | */ |
87 | |
88 | static long phantom_ioctl(struct file *file, unsigned int cmd, |
89 | unsigned long arg) |
90 | { |
91 | struct phantom_device *dev = file->private_data; |
92 | struct phm_regs rs; |
93 | struct phm_reg r; |
94 | void __user *argp = (void __user *)arg; |
95 | unsigned long flags; |
96 | unsigned int i; |
97 | |
98 | switch (cmd) { |
99 | case PHN_SETREG: |
100 | case PHN_SET_REG: |
101 | if (copy_from_user(&r, argp, sizeof(r))) |
102 | return -EFAULT; |
103 | |
104 | if (r.reg > 7) |
105 | return -EINVAL; |
106 | |
107 | spin_lock_irqsave(&dev->regs_lock, flags); |
108 | if (r.reg == PHN_CONTROL && (r.value & PHN_CTL_IRQ) && |
109 | phantom_status(dev, dev->status | PHB_RUNNING)){ |
110 | spin_unlock_irqrestore(&dev->regs_lock, flags); |
111 | return -ENODEV; |
112 | } |
113 | |
114 | pr_debug("phantom: writing %x to %u\n", r.value, r.reg); |
115 | |
116 | /* preserve amp bit (don't allow to change it when in NOT_OH) */ |
117 | if (r.reg == PHN_CONTROL && (dev->status & PHB_NOT_OH)) { |
118 | r.value &= ~PHN_CTL_AMP; |
119 | r.value |= dev->ctl_reg & PHN_CTL_AMP; |
120 | dev->ctl_reg = r.value; |
121 | } |
122 | |
123 | iowrite32(r.value, dev->iaddr + r.reg); |
124 | ioread32(dev->iaddr); /* PCI posting */ |
125 | |
126 | if (r.reg == PHN_CONTROL && !(r.value & PHN_CTL_IRQ)) |
127 | phantom_status(dev, dev->status & ~PHB_RUNNING); |
128 | spin_unlock_irqrestore(&dev->regs_lock, flags); |
129 | break; |
130 | case PHN_SETREGS: |
131 | case PHN_SET_REGS: |
132 | if (copy_from_user(&rs, argp, sizeof(rs))) |
133 | return -EFAULT; |
134 | |
135 | pr_debug("phantom: SRS %u regs %x\n", rs.count, rs.mask); |
136 | spin_lock_irqsave(&dev->regs_lock, flags); |
137 | if (dev->status & PHB_NOT_OH) |
138 | memcpy(&dev->oregs, &rs, sizeof(rs)); |
139 | else { |
140 | u32 m = min(rs.count, 8U); |
141 | for (i = 0; i < m; i++) |
142 | if (rs.mask & BIT(i)) |
143 | iowrite32(rs.values[i], dev->oaddr + i); |
144 | ioread32(dev->iaddr); /* PCI posting */ |
145 | } |
146 | spin_unlock_irqrestore(&dev->regs_lock, flags); |
147 | break; |
148 | case PHN_GETREG: |
149 | case PHN_GET_REG: |
150 | if (copy_from_user(&r, argp, sizeof(r))) |
151 | return -EFAULT; |
152 | |
153 | if (r.reg > 7) |
154 | return -EINVAL; |
155 | |
156 | r.value = ioread32(dev->iaddr + r.reg); |
157 | |
158 | if (copy_to_user(argp, &r, sizeof(r))) |
159 | return -EFAULT; |
160 | break; |
161 | case PHN_GETREGS: |
162 | case PHN_GET_REGS: { |
163 | u32 m; |
164 | |
165 | if (copy_from_user(&rs, argp, sizeof(rs))) |
166 | return -EFAULT; |
167 | |
168 | m = min(rs.count, 8U); |
169 | |
170 | pr_debug("phantom: GRS %u regs %x\n", rs.count, rs.mask); |
171 | spin_lock_irqsave(&dev->regs_lock, flags); |
172 | for (i = 0; i < m; i++) |
173 | if (rs.mask & BIT(i)) |
174 | rs.values[i] = ioread32(dev->iaddr + i); |
175 | atomic_set(&dev->counter, 0); |
176 | spin_unlock_irqrestore(&dev->regs_lock, flags); |
177 | |
178 | if (copy_to_user(argp, &rs, sizeof(rs))) |
179 | return -EFAULT; |
180 | break; |
181 | } case PHN_NOT_OH: |
182 | spin_lock_irqsave(&dev->regs_lock, flags); |
183 | if (dev->status & PHB_RUNNING) { |
184 | printk(KERN_ERR "phantom: you need to set NOT_OH " |
185 | "before you start the device!\n"); |
186 | spin_unlock_irqrestore(&dev->regs_lock, flags); |
187 | return -EINVAL; |
188 | } |
189 | dev->status |= PHB_NOT_OH; |
190 | spin_unlock_irqrestore(&dev->regs_lock, flags); |
191 | break; |
192 | default: |
193 | return -ENOTTY; |
194 | } |
195 | |
196 | return 0; |
197 | } |
198 | |
199 | #ifdef CONFIG_COMPAT |
200 | static long phantom_compat_ioctl(struct file *filp, unsigned int cmd, |
201 | unsigned long arg) |
202 | { |
203 | if (_IOC_NR(cmd) <= 3 && _IOC_SIZE(cmd) == sizeof(compat_uptr_t)) { |
204 | cmd &= ~(_IOC_SIZEMASK << _IOC_SIZESHIFT); |
205 | cmd |= sizeof(void *) << _IOC_SIZESHIFT; |
206 | } |
207 | return phantom_ioctl(filp, cmd, (unsigned long)compat_ptr(arg)); |
208 | } |
209 | #else |
210 | #define phantom_compat_ioctl NULL |
211 | #endif |
212 | |
213 | static int phantom_open(struct inode *inode, struct file *file) |
214 | { |
215 | struct phantom_device *dev = container_of(inode->i_cdev, |
216 | struct phantom_device, cdev); |
217 | |
218 | lock_kernel(); |
219 | nonseekable_open(inode, file); |
220 | |
221 | if (mutex_lock_interruptible(&dev->open_lock)) { |
222 | unlock_kernel(); |
223 | return -ERESTARTSYS; |
224 | } |
225 | |
226 | if (dev->opened) { |
227 | mutex_unlock(&dev->open_lock); |
228 | unlock_kernel(); |
229 | return -EINVAL; |
230 | } |
231 | |
232 | WARN_ON(dev->status & PHB_NOT_OH); |
233 | |
234 | file->private_data = dev; |
235 | |
236 | atomic_set(&dev->counter, 0); |
237 | dev->opened++; |
238 | mutex_unlock(&dev->open_lock); |
239 | unlock_kernel(); |
240 | return 0; |
241 | } |
242 | |
243 | static int phantom_release(struct inode *inode, struct file *file) |
244 | { |
245 | struct phantom_device *dev = file->private_data; |
246 | |
247 | mutex_lock(&dev->open_lock); |
248 | |
249 | dev->opened = 0; |
250 | phantom_status(dev, dev->status & ~PHB_RUNNING); |
251 | dev->status &= ~PHB_NOT_OH; |
252 | |
253 | mutex_unlock(&dev->open_lock); |
254 | |
255 | return 0; |
256 | } |
257 | |
258 | static unsigned int phantom_poll(struct file *file, poll_table *wait) |
259 | { |
260 | struct phantom_device *dev = file->private_data; |
261 | unsigned int mask = 0; |
262 | |
263 | pr_debug("phantom_poll: %d\n", atomic_read(&dev->counter)); |
264 | poll_wait(file, &dev->wait, wait); |
265 | |
266 | if (!(dev->status & PHB_RUNNING)) |
267 | mask = POLLERR; |
268 | else if (atomic_read(&dev->counter)) |
269 | mask = POLLIN | POLLRDNORM; |
270 | |
271 | pr_debug("phantom_poll end: %x/%d\n", mask, atomic_read(&dev->counter)); |
272 | |
273 | return mask; |
274 | } |
275 | |
276 | static const struct file_operations phantom_file_ops = { |
277 | .open = phantom_open, |
278 | .release = phantom_release, |
279 | .unlocked_ioctl = phantom_ioctl, |
280 | .compat_ioctl = phantom_compat_ioctl, |
281 | .poll = phantom_poll, |
282 | }; |
283 | |
284 | static irqreturn_t phantom_isr(int irq, void *data) |
285 | { |
286 | struct phantom_device *dev = data; |
287 | unsigned int i; |
288 | u32 ctl; |
289 | |
290 | spin_lock(&dev->regs_lock); |
291 | ctl = ioread32(dev->iaddr + PHN_CONTROL); |
292 | if (!(ctl & PHN_CTL_IRQ)) { |
293 | spin_unlock(&dev->regs_lock); |
294 | return IRQ_NONE; |
295 | } |
296 | |
297 | iowrite32(0, dev->iaddr); |
298 | iowrite32(0xc0, dev->iaddr); |
299 | |
300 | if (dev->status & PHB_NOT_OH) { |
301 | struct phm_regs *r = &dev->oregs; |
302 | u32 m = min(r->count, 8U); |
303 | |
304 | for (i = 0; i < m; i++) |
305 | if (r->mask & BIT(i)) |
306 | iowrite32(r->values[i], dev->oaddr + i); |
307 | |
308 | dev->ctl_reg ^= PHN_CTL_AMP; |
309 | iowrite32(dev->ctl_reg, dev->iaddr + PHN_CONTROL); |
310 | } |
311 | spin_unlock(&dev->regs_lock); |
312 | |
313 | ioread32(dev->iaddr); /* PCI posting */ |
314 | |
315 | atomic_inc(&dev->counter); |
316 | wake_up_interruptible(&dev->wait); |
317 | |
318 | return IRQ_HANDLED; |
319 | } |
320 | |
321 | /* |
322 | * Init and deinit driver |
323 | */ |
324 | |
325 | static unsigned int __devinit phantom_get_free(void) |
326 | { |
327 | unsigned int i; |
328 | |
329 | for (i = 0; i < PHANTOM_MAX_MINORS; i++) |
330 | if (phantom_devices[i] == 0) |
331 | break; |
332 | |
333 | return i; |
334 | } |
335 | |
336 | static int __devinit phantom_probe(struct pci_dev *pdev, |
337 | const struct pci_device_id *pci_id) |
338 | { |
339 | struct phantom_device *pht; |
340 | unsigned int minor; |
341 | int retval; |
342 | |
343 | retval = pci_enable_device(pdev); |
344 | if (retval) |
345 | goto err; |
346 | |
347 | minor = phantom_get_free(); |
348 | if (minor == PHANTOM_MAX_MINORS) { |
349 | dev_err(&pdev->dev, "too many devices found!\n"); |
350 | retval = -EIO; |
351 | goto err_dis; |
352 | } |
353 | |
354 | phantom_devices[minor] = 1; |
355 | |
356 | retval = pci_request_regions(pdev, "phantom"); |
357 | if (retval) |
358 | goto err_null; |
359 | |
360 | retval = -ENOMEM; |
361 | pht = kzalloc(sizeof(*pht), GFP_KERNEL); |
362 | if (pht == NULL) { |
363 | dev_err(&pdev->dev, "unable to allocate device\n"); |
364 | goto err_reg; |
365 | } |
366 | |
367 | pht->caddr = pci_iomap(pdev, 0, 0); |
368 | if (pht->caddr == NULL) { |
369 | dev_err(&pdev->dev, "can't remap conf space\n"); |
370 | goto err_fr; |
371 | } |
372 | pht->iaddr = pci_iomap(pdev, 2, 0); |
373 | if (pht->iaddr == NULL) { |
374 | dev_err(&pdev->dev, "can't remap input space\n"); |
375 | goto err_unmc; |
376 | } |
377 | pht->oaddr = pci_iomap(pdev, 3, 0); |
378 | if (pht->oaddr == NULL) { |
379 | dev_err(&pdev->dev, "can't remap output space\n"); |
380 | goto err_unmi; |
381 | } |
382 | |
383 | mutex_init(&pht->open_lock); |
384 | spin_lock_init(&pht->regs_lock); |
385 | init_waitqueue_head(&pht->wait); |
386 | cdev_init(&pht->cdev, &phantom_file_ops); |
387 | pht->cdev.owner = THIS_MODULE; |
388 | |
389 | iowrite32(0, pht->caddr + PHN_IRQCTL); |
390 | ioread32(pht->caddr + PHN_IRQCTL); /* PCI posting */ |
391 | retval = request_irq(pdev->irq, phantom_isr, |
392 | IRQF_SHARED | IRQF_DISABLED, "phantom", pht); |
393 | if (retval) { |
394 | dev_err(&pdev->dev, "can't establish ISR\n"); |
395 | goto err_unmo; |
396 | } |
397 | |
398 | retval = cdev_add(&pht->cdev, MKDEV(phantom_major, minor), 1); |
399 | if (retval) { |
400 | dev_err(&pdev->dev, "chardev registration failed\n"); |
401 | goto err_irq; |
402 | } |
403 | |
404 | if (IS_ERR(device_create(phantom_class, &pdev->dev, |
405 | MKDEV(phantom_major, minor), NULL, |
406 | "phantom%u", minor))) |
407 | dev_err(&pdev->dev, "can't create device\n"); |
408 | |
409 | pci_set_drvdata(pdev, pht); |
410 | |
411 | return 0; |
412 | err_irq: |
413 | free_irq(pdev->irq, pht); |
414 | err_unmo: |
415 | pci_iounmap(pdev, pht->oaddr); |
416 | err_unmi: |
417 | pci_iounmap(pdev, pht->iaddr); |
418 | err_unmc: |
419 | pci_iounmap(pdev, pht->caddr); |
420 | err_fr: |
421 | kfree(pht); |
422 | err_reg: |
423 | pci_release_regions(pdev); |
424 | err_null: |
425 | phantom_devices[minor] = 0; |
426 | err_dis: |
427 | pci_disable_device(pdev); |
428 | err: |
429 | return retval; |
430 | } |
431 | |
432 | static void __devexit phantom_remove(struct pci_dev *pdev) |
433 | { |
434 | struct phantom_device *pht = pci_get_drvdata(pdev); |
435 | unsigned int minor = MINOR(pht->cdev.dev); |
436 | |
437 | device_destroy(phantom_class, MKDEV(phantom_major, minor)); |
438 | |
439 | cdev_del(&pht->cdev); |
440 | |
441 | iowrite32(0, pht->caddr + PHN_IRQCTL); |
442 | ioread32(pht->caddr + PHN_IRQCTL); /* PCI posting */ |
443 | free_irq(pdev->irq, pht); |
444 | |
445 | pci_iounmap(pdev, pht->oaddr); |
446 | pci_iounmap(pdev, pht->iaddr); |
447 | pci_iounmap(pdev, pht->caddr); |
448 | |
449 | kfree(pht); |
450 | |
451 | pci_release_regions(pdev); |
452 | |
453 | phantom_devices[minor] = 0; |
454 | |
455 | pci_disable_device(pdev); |
456 | } |
457 | |
458 | #ifdef CONFIG_PM |
459 | static int phantom_suspend(struct pci_dev *pdev, pm_message_t state) |
460 | { |
461 | struct phantom_device *dev = pci_get_drvdata(pdev); |
462 | |
463 | iowrite32(0, dev->caddr + PHN_IRQCTL); |
464 | ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */ |
465 | |
466 | synchronize_irq(pdev->irq); |
467 | |
468 | return 0; |
469 | } |
470 | |
471 | static int phantom_resume(struct pci_dev *pdev) |
472 | { |
473 | struct phantom_device *dev = pci_get_drvdata(pdev); |
474 | |
475 | iowrite32(0, dev->caddr + PHN_IRQCTL); |
476 | |
477 | return 0; |
478 | } |
479 | #else |
480 | #define phantom_suspend NULL |
481 | #define phantom_resume NULL |
482 | #endif |
483 | |
484 | static struct pci_device_id phantom_pci_tbl[] __devinitdata = { |
485 | { .vendor = PCI_VENDOR_ID_PLX, .device = PCI_DEVICE_ID_PLX_9050, |
486 | .subvendor = PCI_VENDOR_ID_PLX, .subdevice = PCI_DEVICE_ID_PLX_9050, |
487 | .class = PCI_CLASS_BRIDGE_OTHER << 8, .class_mask = 0xffff00 }, |
488 | { 0, } |
489 | }; |
490 | MODULE_DEVICE_TABLE(pci, phantom_pci_tbl); |
491 | |
492 | static struct pci_driver phantom_pci_driver = { |
493 | .name = "phantom", |
494 | .id_table = phantom_pci_tbl, |
495 | .probe = phantom_probe, |
496 | .remove = __devexit_p(phantom_remove), |
497 | .suspend = phantom_suspend, |
498 | .resume = phantom_resume |
499 | }; |
500 | |
501 | static CLASS_ATTR_STRING(version, 0444, PHANTOM_VERSION); |
502 | |
503 | static int __init phantom_init(void) |
504 | { |
505 | int retval; |
506 | dev_t dev; |
507 | |
508 | phantom_class = class_create(THIS_MODULE, "phantom"); |
509 | if (IS_ERR(phantom_class)) { |
510 | retval = PTR_ERR(phantom_class); |
511 | printk(KERN_ERR "phantom: can't register phantom class\n"); |
512 | goto err; |
513 | } |
514 | retval = class_create_file(phantom_class, &class_attr_version.attr); |
515 | if (retval) { |
516 | printk(KERN_ERR "phantom: can't create sysfs version file\n"); |
517 | goto err_class; |
518 | } |
519 | |
520 | retval = alloc_chrdev_region(&dev, 0, PHANTOM_MAX_MINORS, "phantom"); |
521 | if (retval) { |
522 | printk(KERN_ERR "phantom: can't register character device\n"); |
523 | goto err_attr; |
524 | } |
525 | phantom_major = MAJOR(dev); |
526 | |
527 | retval = pci_register_driver(&phantom_pci_driver); |
528 | if (retval) { |
529 | printk(KERN_ERR "phantom: can't register pci driver\n"); |
530 | goto err_unchr; |
531 | } |
532 | |
533 | printk(KERN_INFO "Phantom Linux Driver, version " PHANTOM_VERSION ", " |
534 | "init OK\n"); |
535 | |
536 | return 0; |
537 | err_unchr: |
538 | unregister_chrdev_region(dev, PHANTOM_MAX_MINORS); |
539 | err_attr: |
540 | class_remove_file(phantom_class, &class_attr_version.attr); |
541 | err_class: |
542 | class_destroy(phantom_class); |
543 | err: |
544 | return retval; |
545 | } |
546 | |
547 | static void __exit phantom_exit(void) |
548 | { |
549 | pci_unregister_driver(&phantom_pci_driver); |
550 | |
551 | unregister_chrdev_region(MKDEV(phantom_major, 0), PHANTOM_MAX_MINORS); |
552 | |
553 | class_remove_file(phantom_class, &class_attr_version.attr); |
554 | class_destroy(phantom_class); |
555 | |
556 | pr_debug("phantom: module successfully removed\n"); |
557 | } |
558 | |
559 | module_init(phantom_init); |
560 | module_exit(phantom_exit); |
561 | |
562 | MODULE_AUTHOR("Jiri Slaby <jirislaby@gmail.com>"); |
563 | MODULE_DESCRIPTION("Sensable Phantom driver (PCI devices)"); |
564 | MODULE_LICENSE("GPL"); |
565 | MODULE_VERSION(PHANTOM_VERSION); |
566 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9