UIO: add automata sercos3 pci card support
[linux-2.6.git] / drivers / uio / uio_sercos3.c
1 /* sercos3: UIO driver for the Automata Sercos III PCI card
2
3    Copyright (C) 2008 Linutronix GmbH
4      Author: John Ogness <john.ogness@linutronix.de>
5
6    This is a straight-forward UIO driver, where interrupts are disabled
7    by the interrupt handler and re-enabled via a write to the UIO device
8    by the userspace-part.
9
10    The only part that may seem odd is the use of a logical OR when
11    storing and restoring enabled interrupts. This is done because the
12    userspace-part could directly modify the Interrupt Enable Register
13    at any time. To reduce possible conflicts, the kernel driver uses
14    a logical OR to make more controlled changes (rather than blindly
15    overwriting previous values).
16
17    Race conditions exist if the userspace-part directly modifies the
18    Interrupt Enable Register while in operation. The consequences are
19    that certain interrupts would fail to be enabled or disabled. For
20    this reason, the userspace-part should only directly modify the
21    Interrupt Enable Register at the beginning (to get things going).
22    The userspace-part can safely disable interrupts at any time using
23    a write to the UIO device.
24 */
25
26 #include <linux/device.h>
27 #include <linux/module.h>
28 #include <linux/pci.h>
29 #include <linux/uio_driver.h>
30 #include <linux/io.h>
31
32 /* ID's for SERCOS III PCI card (PLX 9030) */
33 #define SERCOS_SUB_VENDOR_ID  0x1971
34 #define SERCOS_SUB_SYSID_3530 0x3530
35 #define SERCOS_SUB_SYSID_3535 0x3535
36 #define SERCOS_SUB_SYSID_3780 0x3780
37
38 /* Interrupt Enable Register */
39 #define IER0_OFFSET 0x08
40
41 /* Interrupt Status Register */
42 #define ISR0_OFFSET 0x18
43
44 struct sercos3_priv {
45         u32 ier0_cache;
46         spinlock_t ier0_cache_lock;
47 };
48
49 /* this function assumes ier0_cache_lock is locked! */
50 static void sercos3_disable_interrupts(struct uio_info *info,
51                                        struct sercos3_priv *priv)
52 {
53         void __iomem *ier0 = info->mem[3].internal_addr + IER0_OFFSET;
54
55         /* add enabled interrupts to cache */
56         priv->ier0_cache |= ioread32(ier0);
57
58         /* disable interrupts */
59         iowrite32(0, ier0);
60 }
61
62 /* this function assumes ier0_cache_lock is locked! */
63 static void sercos3_enable_interrupts(struct uio_info *info,
64                                       struct sercos3_priv *priv)
65 {
66         void __iomem *ier0 = info->mem[3].internal_addr + IER0_OFFSET;
67
68         /* restore previously enabled interrupts */
69         iowrite32(ioread32(ier0) | priv->ier0_cache, ier0);
70         priv->ier0_cache = 0;
71 }
72
73 static irqreturn_t sercos3_handler(int irq, struct uio_info *info)
74 {
75         struct sercos3_priv *priv = info->priv;
76         void __iomem *isr0 = info->mem[3].internal_addr + ISR0_OFFSET;
77         void __iomem *ier0 = info->mem[3].internal_addr + IER0_OFFSET;
78
79         if (!(ioread32(isr0) & ioread32(ier0)))
80                 return IRQ_NONE;
81
82         spin_lock(&priv->ier0_cache_lock);
83         sercos3_disable_interrupts(info, priv);
84         spin_unlock(&priv->ier0_cache_lock);
85
86         return IRQ_HANDLED;
87 }
88
89 static int sercos3_irqcontrol(struct uio_info *info, s32 irq_on)
90 {
91         struct sercos3_priv *priv = info->priv;
92
93         spin_lock_irq(&priv->ier0_cache_lock);
94         if (irq_on)
95                 sercos3_enable_interrupts(info, priv);
96         else
97                 sercos3_disable_interrupts(info, priv);
98         spin_unlock_irq(&priv->ier0_cache_lock);
99
100         return 0;
101 }
102
103 static int sercos3_setup_iomem(struct pci_dev *dev, struct uio_info *info,
104                                int n, int pci_bar)
105 {
106         info->mem[n].addr = pci_resource_start(dev, pci_bar);
107         if (!info->mem[n].addr)
108                 return -1;
109         info->mem[n].internal_addr = ioremap(pci_resource_start(dev, pci_bar),
110                                              pci_resource_len(dev, pci_bar));
111         if (!info->mem[n].internal_addr)
112                 return -1;
113         info->mem[n].size = pci_resource_len(dev, pci_bar);
114         info->mem[n].memtype = UIO_MEM_PHYS;
115         return 0;
116 }
117
118 static int __devinit sercos3_pci_probe(struct pci_dev *dev,
119                                        const struct pci_device_id *id)
120 {
121         struct uio_info *info;
122         struct sercos3_priv *priv;
123         int i;
124
125         info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
126         if (!info)
127                 return -ENOMEM;
128
129         priv = kzalloc(sizeof(struct sercos3_priv), GFP_KERNEL);
130         if (!priv)
131                 goto out_free;
132
133         if (pci_enable_device(dev))
134                 goto out_free_priv;
135
136         if (pci_request_regions(dev, "sercos3"))
137                 goto out_disable;
138
139         /* we only need PCI BAR's 0, 2, 3, 4, 5 */
140         if (sercos3_setup_iomem(dev, info, 0, 0))
141                 goto out_unmap;
142         if (sercos3_setup_iomem(dev, info, 1, 2))
143                 goto out_unmap;
144         if (sercos3_setup_iomem(dev, info, 2, 3))
145                 goto out_unmap;
146         if (sercos3_setup_iomem(dev, info, 3, 4))
147                 goto out_unmap;
148         if (sercos3_setup_iomem(dev, info, 4, 5))
149                 goto out_unmap;
150
151         spin_lock_init(&priv->ier0_cache_lock);
152         info->priv = priv;
153         info->name = "Sercos_III_PCI";
154         info->version = "0.0.1";
155         info->irq = dev->irq;
156         info->irq_flags = IRQF_DISABLED | IRQF_SHARED;
157         info->handler = sercos3_handler;
158         info->irqcontrol = sercos3_irqcontrol;
159
160         pci_set_drvdata(dev, info);
161
162         if (uio_register_device(&dev->dev, info))
163                 goto out_unmap;
164
165         return 0;
166
167 out_unmap:
168         for (i = 0; i < 5; i++) {
169                 if (info->mem[i].internal_addr)
170                         iounmap(info->mem[i].internal_addr);
171         }
172         pci_release_regions(dev);
173 out_disable:
174         pci_disable_device(dev);
175 out_free_priv:
176         kfree(priv);
177 out_free:
178         kfree(info);
179         return -ENODEV;
180 }
181
182 static void sercos3_pci_remove(struct pci_dev *dev)
183 {
184         struct uio_info *info = pci_get_drvdata(dev);
185         int i;
186
187         uio_unregister_device(info);
188         pci_release_regions(dev);
189         pci_disable_device(dev);
190         pci_set_drvdata(dev, NULL);
191         for (i = 0; i < 5; i++) {
192                 if (info->mem[i].internal_addr)
193                         iounmap(info->mem[i].internal_addr);
194         }
195         kfree(info->priv);
196         kfree(info);
197 }
198
199 static struct pci_device_id sercos3_pci_ids[] __devinitdata = {
200         {
201                 .vendor =       PCI_VENDOR_ID_PLX,
202                 .device =       PCI_DEVICE_ID_PLX_9030,
203                 .subvendor =    SERCOS_SUB_VENDOR_ID,
204                 .subdevice =    SERCOS_SUB_SYSID_3530,
205         },
206         {
207                 .vendor =       PCI_VENDOR_ID_PLX,
208                 .device =       PCI_DEVICE_ID_PLX_9030,
209                 .subvendor =    SERCOS_SUB_VENDOR_ID,
210                 .subdevice =    SERCOS_SUB_SYSID_3535,
211         },
212         {
213                 .vendor =       PCI_VENDOR_ID_PLX,
214                 .device =       PCI_DEVICE_ID_PLX_9030,
215                 .subvendor =    SERCOS_SUB_VENDOR_ID,
216                 .subdevice =    SERCOS_SUB_SYSID_3780,
217         },
218         { 0, }
219 };
220
221 static struct pci_driver sercos3_pci_driver = {
222         .name = "sercos3",
223         .id_table = sercos3_pci_ids,
224         .probe = sercos3_pci_probe,
225         .remove = sercos3_pci_remove,
226 };
227
228 static int __init sercos3_init_module(void)
229 {
230         return pci_register_driver(&sercos3_pci_driver);
231 }
232
233 static void __exit sercos3_exit_module(void)
234 {
235         pci_unregister_driver(&sercos3_pci_driver);
236 }
237
238 module_init(sercos3_init_module);
239 module_exit(sercos3_exit_module);
240
241 MODULE_DESCRIPTION("UIO driver for the Automata Sercos III PCI card");
242 MODULE_AUTHOR("John Ogness <john.ogness@linutronix.de>");
243 MODULE_LICENSE("GPL v2");