Commit | Line | Data |
---|---|---|
fbb5858c | 1 | // SPDX-License-Identifier: GPL-2.0 |
beafc54c HK |
2 | /* |
3 | * drivers/uio/uio.c | |
4 | * | |
5 | * Copyright(C) 2005, Benedikt Spranger <b.spranger@linutronix.de> | |
6 | * Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de> | |
318af55d | 7 | * Copyright(C) 2006, Hans J. Koch <hjk@hansjkoch.de> |
beafc54c HK |
8 | * Copyright(C) 2006, Greg Kroah-Hartman <greg@kroah.com> |
9 | * | |
10 | * Userspace IO | |
11 | * | |
12 | * Base Functions | |
beafc54c HK |
13 | */ |
14 | ||
15 | #include <linux/module.h> | |
16 | #include <linux/init.h> | |
17 | #include <linux/poll.h> | |
18 | #include <linux/device.h> | |
5a0e3ad6 | 19 | #include <linux/slab.h> |
beafc54c HK |
20 | #include <linux/mm.h> |
21 | #include <linux/idr.h> | |
174cd4b1 | 22 | #include <linux/sched/signal.h> |
beafc54c HK |
23 | #include <linux/string.h> |
24 | #include <linux/kobject.h> | |
91960a46 | 25 | #include <linux/cdev.h> |
beafc54c HK |
26 | #include <linux/uio_driver.h> |
27 | ||
91960a46 | 28 | #define UIO_MAX_DEVICES (1U << MINORBITS) |
beafc54c | 29 | |
beafc54c | 30 | static int uio_major; |
91960a46 | 31 | static struct cdev *uio_cdev; |
beafc54c | 32 | static DEFINE_IDR(uio_idr); |
4f014691 | 33 | static const struct file_operations uio_fops; |
beafc54c | 34 | |
0d4a7bc1 JC |
35 | /* Protect idr accesses */ |
36 | static DEFINE_MUTEX(minor_lock); | |
37 | ||
beafc54c HK |
38 | /* |
39 | * attributes | |
40 | */ | |
41 | ||
81e7c6a6 GKH |
42 | struct uio_map { |
43 | struct kobject kobj; | |
44 | struct uio_mem *mem; | |
beafc54c | 45 | }; |
81e7c6a6 | 46 | #define to_map(map) container_of(map, struct uio_map, kobj) |
beafc54c | 47 | |
82057791 HK |
48 | static ssize_t map_name_show(struct uio_mem *mem, char *buf) |
49 | { | |
50 | if (unlikely(!mem->name)) | |
51 | mem->name = ""; | |
52 | ||
53 | return sprintf(buf, "%s\n", mem->name); | |
54 | } | |
55 | ||
4f808bcd | 56 | static ssize_t map_addr_show(struct uio_mem *mem, char *buf) |
beafc54c | 57 | { |
e0f1147c | 58 | return sprintf(buf, "%pa\n", &mem->addr); |
4f808bcd | 59 | } |
beafc54c | 60 | |
4f808bcd BP |
61 | static ssize_t map_size_show(struct uio_mem *mem, char *buf) |
62 | { | |
e0f1147c | 63 | return sprintf(buf, "%pa\n", &mem->size); |
beafc54c HK |
64 | } |
65 | ||
e2b39df1 HK |
66 | static ssize_t map_offset_show(struct uio_mem *mem, char *buf) |
67 | { | |
171058fb | 68 | return sprintf(buf, "0x%llx\n", (unsigned long long)mem->offs); |
e2b39df1 HK |
69 | } |
70 | ||
e70c412e | 71 | struct map_sysfs_entry { |
4f808bcd BP |
72 | struct attribute attr; |
73 | ssize_t (*show)(struct uio_mem *, char *); | |
74 | ssize_t (*store)(struct uio_mem *, const char *, size_t); | |
75 | }; | |
76 | ||
82057791 HK |
77 | static struct map_sysfs_entry name_attribute = |
78 | __ATTR(name, S_IRUGO, map_name_show, NULL); | |
e70c412e | 79 | static struct map_sysfs_entry addr_attribute = |
4f808bcd | 80 | __ATTR(addr, S_IRUGO, map_addr_show, NULL); |
e70c412e | 81 | static struct map_sysfs_entry size_attribute = |
4f808bcd | 82 | __ATTR(size, S_IRUGO, map_size_show, NULL); |
e70c412e | 83 | static struct map_sysfs_entry offset_attribute = |
e2b39df1 | 84 | __ATTR(offset, S_IRUGO, map_offset_show, NULL); |
beafc54c | 85 | |
81e7c6a6 | 86 | static struct attribute *attrs[] = { |
82057791 | 87 | &name_attribute.attr, |
4f808bcd | 88 | &addr_attribute.attr, |
81e7c6a6 | 89 | &size_attribute.attr, |
e2b39df1 | 90 | &offset_attribute.attr, |
81e7c6a6 | 91 | NULL, /* need to NULL terminate the list of attributes */ |
beafc54c HK |
92 | }; |
93 | ||
81e7c6a6 GKH |
94 | static void map_release(struct kobject *kobj) |
95 | { | |
96 | struct uio_map *map = to_map(kobj); | |
97 | kfree(map); | |
98 | } | |
99 | ||
4f808bcd BP |
100 | static ssize_t map_type_show(struct kobject *kobj, struct attribute *attr, |
101 | char *buf) | |
102 | { | |
103 | struct uio_map *map = to_map(kobj); | |
104 | struct uio_mem *mem = map->mem; | |
e70c412e | 105 | struct map_sysfs_entry *entry; |
4f808bcd | 106 | |
e70c412e | 107 | entry = container_of(attr, struct map_sysfs_entry, attr); |
4f808bcd BP |
108 | |
109 | if (!entry->show) | |
110 | return -EIO; | |
111 | ||
112 | return entry->show(mem, buf); | |
113 | } | |
114 | ||
52cf25d0 | 115 | static const struct sysfs_ops map_sysfs_ops = { |
4f808bcd BP |
116 | .show = map_type_show, |
117 | }; | |
118 | ||
beafc54c | 119 | static struct kobj_type map_attr_type = { |
81e7c6a6 | 120 | .release = map_release, |
e70c412e | 121 | .sysfs_ops = &map_sysfs_ops, |
81e7c6a6 | 122 | .default_attrs = attrs, |
beafc54c HK |
123 | }; |
124 | ||
e70c412e HK |
125 | struct uio_portio { |
126 | struct kobject kobj; | |
127 | struct uio_port *port; | |
128 | }; | |
129 | #define to_portio(portio) container_of(portio, struct uio_portio, kobj) | |
130 | ||
82057791 HK |
131 | static ssize_t portio_name_show(struct uio_port *port, char *buf) |
132 | { | |
133 | if (unlikely(!port->name)) | |
134 | port->name = ""; | |
135 | ||
136 | return sprintf(buf, "%s\n", port->name); | |
137 | } | |
138 | ||
e70c412e HK |
139 | static ssize_t portio_start_show(struct uio_port *port, char *buf) |
140 | { | |
141 | return sprintf(buf, "0x%lx\n", port->start); | |
142 | } | |
143 | ||
144 | static ssize_t portio_size_show(struct uio_port *port, char *buf) | |
145 | { | |
146 | return sprintf(buf, "0x%lx\n", port->size); | |
147 | } | |
148 | ||
149 | static ssize_t portio_porttype_show(struct uio_port *port, char *buf) | |
150 | { | |
151 | const char *porttypes[] = {"none", "x86", "gpio", "other"}; | |
152 | ||
153 | if ((port->porttype < 0) || (port->porttype > UIO_PORT_OTHER)) | |
154 | return -EINVAL; | |
155 | ||
156 | return sprintf(buf, "port_%s\n", porttypes[port->porttype]); | |
157 | } | |
158 | ||
159 | struct portio_sysfs_entry { | |
160 | struct attribute attr; | |
161 | ssize_t (*show)(struct uio_port *, char *); | |
162 | ssize_t (*store)(struct uio_port *, const char *, size_t); | |
163 | }; | |
164 | ||
82057791 HK |
165 | static struct portio_sysfs_entry portio_name_attribute = |
166 | __ATTR(name, S_IRUGO, portio_name_show, NULL); | |
e70c412e HK |
167 | static struct portio_sysfs_entry portio_start_attribute = |
168 | __ATTR(start, S_IRUGO, portio_start_show, NULL); | |
169 | static struct portio_sysfs_entry portio_size_attribute = | |
170 | __ATTR(size, S_IRUGO, portio_size_show, NULL); | |
171 | static struct portio_sysfs_entry portio_porttype_attribute = | |
172 | __ATTR(porttype, S_IRUGO, portio_porttype_show, NULL); | |
173 | ||
174 | static struct attribute *portio_attrs[] = { | |
82057791 | 175 | &portio_name_attribute.attr, |
e70c412e HK |
176 | &portio_start_attribute.attr, |
177 | &portio_size_attribute.attr, | |
178 | &portio_porttype_attribute.attr, | |
179 | NULL, | |
180 | }; | |
181 | ||
182 | static void portio_release(struct kobject *kobj) | |
183 | { | |
184 | struct uio_portio *portio = to_portio(kobj); | |
185 | kfree(portio); | |
186 | } | |
187 | ||
188 | static ssize_t portio_type_show(struct kobject *kobj, struct attribute *attr, | |
189 | char *buf) | |
190 | { | |
191 | struct uio_portio *portio = to_portio(kobj); | |
192 | struct uio_port *port = portio->port; | |
193 | struct portio_sysfs_entry *entry; | |
194 | ||
195 | entry = container_of(attr, struct portio_sysfs_entry, attr); | |
196 | ||
197 | if (!entry->show) | |
198 | return -EIO; | |
199 | ||
200 | return entry->show(port, buf); | |
201 | } | |
202 | ||
52cf25d0 | 203 | static const struct sysfs_ops portio_sysfs_ops = { |
e70c412e HK |
204 | .show = portio_type_show, |
205 | }; | |
206 | ||
207 | static struct kobj_type portio_attr_type = { | |
208 | .release = portio_release, | |
209 | .sysfs_ops = &portio_sysfs_ops, | |
210 | .default_attrs = portio_attrs, | |
211 | }; | |
212 | ||
c9dce927 | 213 | static ssize_t name_show(struct device *dev, |
beafc54c HK |
214 | struct device_attribute *attr, char *buf) |
215 | { | |
216 | struct uio_device *idev = dev_get_drvdata(dev); | |
57c5f4df XL |
217 | int ret; |
218 | ||
219 | mutex_lock(&idev->info_lock); | |
220 | if (!idev->info) { | |
221 | ret = -EINVAL; | |
222 | dev_err(dev, "the device has been unregistered\n"); | |
223 | goto out; | |
224 | } | |
225 | ||
226 | ret = sprintf(buf, "%s\n", idev->info->name); | |
227 | ||
228 | out: | |
229 | mutex_unlock(&idev->info_lock); | |
230 | return ret; | |
beafc54c | 231 | } |
c9dce927 | 232 | static DEVICE_ATTR_RO(name); |
beafc54c | 233 | |
c9dce927 | 234 | static ssize_t version_show(struct device *dev, |
beafc54c HK |
235 | struct device_attribute *attr, char *buf) |
236 | { | |
237 | struct uio_device *idev = dev_get_drvdata(dev); | |
57c5f4df XL |
238 | int ret; |
239 | ||
240 | mutex_lock(&idev->info_lock); | |
241 | if (!idev->info) { | |
242 | ret = -EINVAL; | |
243 | dev_err(dev, "the device has been unregistered\n"); | |
244 | goto out; | |
245 | } | |
246 | ||
247 | ret = sprintf(buf, "%s\n", idev->info->version); | |
248 | ||
249 | out: | |
250 | mutex_unlock(&idev->info_lock); | |
251 | return ret; | |
beafc54c | 252 | } |
c9dce927 | 253 | static DEVICE_ATTR_RO(version); |
beafc54c | 254 | |
c9dce927 | 255 | static ssize_t event_show(struct device *dev, |
beafc54c HK |
256 | struct device_attribute *attr, char *buf) |
257 | { | |
258 | struct uio_device *idev = dev_get_drvdata(dev); | |
70a9156b | 259 | return sprintf(buf, "%u\n", (unsigned int)atomic_read(&idev->event)); |
beafc54c | 260 | } |
c9dce927 | 261 | static DEVICE_ATTR_RO(event); |
beafc54c | 262 | |
c9dce927 GKH |
263 | static struct attribute *uio_attrs[] = { |
264 | &dev_attr_name.attr, | |
265 | &dev_attr_version.attr, | |
266 | &dev_attr_event.attr, | |
267 | NULL, | |
beafc54c | 268 | }; |
c9dce927 | 269 | ATTRIBUTE_GROUPS(uio); |
beafc54c | 270 | |
c66fdab6 EB |
271 | /* UIO class infrastructure */ |
272 | static struct class uio_class = { | |
273 | .name = "uio", | |
c9dce927 | 274 | .dev_groups = uio_groups, |
beafc54c HK |
275 | }; |
276 | ||
6011002c | 277 | static bool uio_class_registered; |
ae61cf5b | 278 | |
beafc54c HK |
279 | /* |
280 | * device functions | |
281 | */ | |
282 | static int uio_dev_add_attributes(struct uio_device *idev) | |
283 | { | |
284 | int ret; | |
e70c412e | 285 | int mi, pi; |
beafc54c | 286 | int map_found = 0; |
e70c412e | 287 | int portio_found = 0; |
beafc54c | 288 | struct uio_mem *mem; |
81e7c6a6 | 289 | struct uio_map *map; |
e70c412e HK |
290 | struct uio_port *port; |
291 | struct uio_portio *portio; | |
beafc54c | 292 | |
beafc54c HK |
293 | for (mi = 0; mi < MAX_UIO_MAPS; mi++) { |
294 | mem = &idev->info->mem[mi]; | |
295 | if (mem->size == 0) | |
296 | break; | |
297 | if (!map_found) { | |
298 | map_found = 1; | |
81e7c6a6 | 299 | idev->map_dir = kobject_create_and_add("maps", |
a93e7b33 | 300 | &idev->dev.kobj); |
0320a278 DC |
301 | if (!idev->map_dir) { |
302 | ret = -ENOMEM; | |
e70c412e | 303 | goto err_map; |
0320a278 | 304 | } |
beafc54c | 305 | } |
81e7c6a6 | 306 | map = kzalloc(sizeof(*map), GFP_KERNEL); |
0320a278 DC |
307 | if (!map) { |
308 | ret = -ENOMEM; | |
0d835390 | 309 | goto err_map; |
0320a278 | 310 | } |
f9cb074b | 311 | kobject_init(&map->kobj, &map_attr_type); |
81e7c6a6 GKH |
312 | map->mem = mem; |
313 | mem->map = map; | |
b2d6db58 | 314 | ret = kobject_add(&map->kobj, idev->map_dir, "map%d", mi); |
81e7c6a6 | 315 | if (ret) |
75f0aef6 | 316 | goto err_map_kobj; |
81e7c6a6 | 317 | ret = kobject_uevent(&map->kobj, KOBJ_ADD); |
beafc54c | 318 | if (ret) |
0d835390 | 319 | goto err_map_kobj; |
e70c412e HK |
320 | } |
321 | ||
322 | for (pi = 0; pi < MAX_UIO_PORT_REGIONS; pi++) { | |
323 | port = &idev->info->port[pi]; | |
324 | if (port->size == 0) | |
325 | break; | |
326 | if (!portio_found) { | |
327 | portio_found = 1; | |
328 | idev->portio_dir = kobject_create_and_add("portio", | |
a93e7b33 | 329 | &idev->dev.kobj); |
0320a278 DC |
330 | if (!idev->portio_dir) { |
331 | ret = -ENOMEM; | |
e70c412e | 332 | goto err_portio; |
0320a278 | 333 | } |
e70c412e HK |
334 | } |
335 | portio = kzalloc(sizeof(*portio), GFP_KERNEL); | |
0320a278 DC |
336 | if (!portio) { |
337 | ret = -ENOMEM; | |
0d835390 | 338 | goto err_portio; |
0320a278 | 339 | } |
e70c412e HK |
340 | kobject_init(&portio->kobj, &portio_attr_type); |
341 | portio->port = port; | |
342 | port->portio = portio; | |
343 | ret = kobject_add(&portio->kobj, idev->portio_dir, | |
344 | "port%d", pi); | |
345 | if (ret) | |
75f0aef6 | 346 | goto err_portio_kobj; |
e70c412e HK |
347 | ret = kobject_uevent(&portio->kobj, KOBJ_ADD); |
348 | if (ret) | |
0d835390 | 349 | goto err_portio_kobj; |
beafc54c HK |
350 | } |
351 | ||
352 | return 0; | |
353 | ||
e70c412e | 354 | err_portio: |
75f0aef6 CD |
355 | pi--; |
356 | err_portio_kobj: | |
357 | for (; pi >= 0; pi--) { | |
e70c412e HK |
358 | port = &idev->info->port[pi]; |
359 | portio = port->portio; | |
360 | kobject_put(&portio->kobj); | |
361 | } | |
362 | kobject_put(idev->portio_dir); | |
363 | err_map: | |
75f0aef6 CD |
364 | mi--; |
365 | err_map_kobj: | |
366 | for (; mi >= 0; mi--) { | |
beafc54c | 367 | mem = &idev->info->mem[mi]; |
81e7c6a6 | 368 | map = mem->map; |
c10997f6 | 369 | kobject_put(&map->kobj); |
beafc54c | 370 | } |
c10997f6 | 371 | kobject_put(idev->map_dir); |
a93e7b33 | 372 | dev_err(&idev->dev, "error creating sysfs files (%d)\n", ret); |
beafc54c HK |
373 | return ret; |
374 | } | |
375 | ||
376 | static void uio_dev_del_attributes(struct uio_device *idev) | |
377 | { | |
e70c412e | 378 | int i; |
beafc54c | 379 | struct uio_mem *mem; |
e70c412e HK |
380 | struct uio_port *port; |
381 | ||
382 | for (i = 0; i < MAX_UIO_MAPS; i++) { | |
383 | mem = &idev->info->mem[i]; | |
beafc54c HK |
384 | if (mem->size == 0) |
385 | break; | |
c10997f6 | 386 | kobject_put(&mem->map->kobj); |
beafc54c | 387 | } |
c10997f6 | 388 | kobject_put(idev->map_dir); |
e70c412e HK |
389 | |
390 | for (i = 0; i < MAX_UIO_PORT_REGIONS; i++) { | |
391 | port = &idev->info->port[i]; | |
392 | if (port->size == 0) | |
393 | break; | |
394 | kobject_put(&port->portio->kobj); | |
395 | } | |
396 | kobject_put(idev->portio_dir); | |
beafc54c HK |
397 | } |
398 | ||
399 | static int uio_get_minor(struct uio_device *idev) | |
400 | { | |
beafc54c | 401 | int retval = -ENOMEM; |
beafc54c HK |
402 | |
403 | mutex_lock(&minor_lock); | |
6d770931 TH |
404 | retval = idr_alloc(&uio_idr, idev, 0, UIO_MAX_DEVICES, GFP_KERNEL); |
405 | if (retval >= 0) { | |
406 | idev->minor = retval; | |
5ed0505c | 407 | retval = 0; |
6d770931 | 408 | } else if (retval == -ENOSPC) { |
a93e7b33 | 409 | dev_err(&idev->dev, "too many uio devices\n"); |
c6edc42f | 410 | retval = -EINVAL; |
c6edc42f | 411 | } |
beafc54c HK |
412 | mutex_unlock(&minor_lock); |
413 | return retval; | |
414 | } | |
415 | ||
416 | static void uio_free_minor(struct uio_device *idev) | |
417 | { | |
0d4a7bc1 | 418 | mutex_lock(&minor_lock); |
beafc54c | 419 | idr_remove(&uio_idr, idev->minor); |
0d4a7bc1 | 420 | mutex_unlock(&minor_lock); |
beafc54c HK |
421 | } |
422 | ||
423 | /** | |
424 | * uio_event_notify - trigger an interrupt event | |
425 | * @info: UIO device capabilities | |
426 | */ | |
427 | void uio_event_notify(struct uio_info *info) | |
428 | { | |
429 | struct uio_device *idev = info->uio_dev; | |
430 | ||
431 | atomic_inc(&idev->event); | |
432 | wake_up_interruptible(&idev->wait); | |
433 | kill_fasync(&idev->async_queue, SIGIO, POLL_IN); | |
434 | } | |
435 | EXPORT_SYMBOL_GPL(uio_event_notify); | |
436 | ||
437 | /** | |
438 | * uio_interrupt - hardware interrupt handler | |
439 | * @irq: IRQ number, can be UIO_IRQ_CYCLIC for cyclic timer | |
440 | * @dev_id: Pointer to the devices uio_device structure | |
441 | */ | |
442 | static irqreturn_t uio_interrupt(int irq, void *dev_id) | |
443 | { | |
444 | struct uio_device *idev = (struct uio_device *)dev_id; | |
57c5f4df XL |
445 | irqreturn_t ret; |
446 | ||
57c5f4df | 447 | ret = idev->info->handler(irq, idev->info); |
beafc54c HK |
448 | if (ret == IRQ_HANDLED) |
449 | uio_event_notify(idev->info); | |
450 | ||
451 | return ret; | |
452 | } | |
453 | ||
454 | struct uio_listener { | |
455 | struct uio_device *dev; | |
456 | s32 event_count; | |
457 | }; | |
458 | ||
459 | static int uio_open(struct inode *inode, struct file *filep) | |
460 | { | |
461 | struct uio_device *idev; | |
462 | struct uio_listener *listener; | |
463 | int ret = 0; | |
464 | ||
0d4a7bc1 | 465 | mutex_lock(&minor_lock); |
beafc54c | 466 | idev = idr_find(&uio_idr, iminor(inode)); |
0d4a7bc1 | 467 | mutex_unlock(&minor_lock); |
fbc8a81d JC |
468 | if (!idev) { |
469 | ret = -ENODEV; | |
470 | goto out; | |
471 | } | |
beafc54c | 472 | |
a93e7b33 HM |
473 | get_device(&idev->dev); |
474 | ||
fbc8a81d JC |
475 | if (!try_module_get(idev->owner)) { |
476 | ret = -ENODEV; | |
a93e7b33 | 477 | goto err_module_get; |
fbc8a81d | 478 | } |
610ad506 | 479 | |
beafc54c | 480 | listener = kmalloc(sizeof(*listener), GFP_KERNEL); |
610ad506 UKK |
481 | if (!listener) { |
482 | ret = -ENOMEM; | |
483 | goto err_alloc_listener; | |
484 | } | |
beafc54c HK |
485 | |
486 | listener->dev = idev; | |
487 | listener->event_count = atomic_read(&idev->event); | |
488 | filep->private_data = listener; | |
489 | ||
543af586 | 490 | mutex_lock(&idev->info_lock); |
57c5f4df XL |
491 | if (!idev->info) { |
492 | mutex_unlock(&idev->info_lock); | |
493 | ret = -EINVAL; | |
1e09cdd5 | 494 | goto err_infoopen; |
57c5f4df XL |
495 | } |
496 | ||
54557665 | 497 | if (idev->info->open) |
beafc54c | 498 | ret = idev->info->open(idev->info, inode); |
543af586 | 499 | mutex_unlock(&idev->info_lock); |
a93e7b33 HM |
500 | if (ret) |
501 | goto err_infoopen; | |
502 | ||
610ad506 UKK |
503 | return 0; |
504 | ||
505 | err_infoopen: | |
610ad506 | 506 | kfree(listener); |
610ad506 | 507 | |
0d4a7bc1 | 508 | err_alloc_listener: |
610ad506 | 509 | module_put(idev->owner); |
beafc54c | 510 | |
a93e7b33 HM |
511 | err_module_get: |
512 | put_device(&idev->dev); | |
513 | ||
fbc8a81d | 514 | out: |
beafc54c HK |
515 | return ret; |
516 | } | |
517 | ||
518 | static int uio_fasync(int fd, struct file *filep, int on) | |
519 | { | |
520 | struct uio_listener *listener = filep->private_data; | |
521 | struct uio_device *idev = listener->dev; | |
522 | ||
523 | return fasync_helper(fd, filep, on, &idev->async_queue); | |
524 | } | |
525 | ||
526 | static int uio_release(struct inode *inode, struct file *filep) | |
527 | { | |
528 | int ret = 0; | |
529 | struct uio_listener *listener = filep->private_data; | |
530 | struct uio_device *idev = listener->dev; | |
531 | ||
543af586 | 532 | mutex_lock(&idev->info_lock); |
a93e7b33 | 533 | if (idev->info && idev->info->release) |
beafc54c | 534 | ret = idev->info->release(idev->info, inode); |
543af586 | 535 | mutex_unlock(&idev->info_lock); |
610ad506 UKK |
536 | |
537 | module_put(idev->owner); | |
beafc54c | 538 | kfree(listener); |
a93e7b33 | 539 | put_device(&idev->dev); |
beafc54c HK |
540 | return ret; |
541 | } | |
542 | ||
afc9a42b | 543 | static __poll_t uio_poll(struct file *filep, poll_table *wait) |
beafc54c HK |
544 | { |
545 | struct uio_listener *listener = filep->private_data; | |
546 | struct uio_device *idev = listener->dev; | |
a93e7b33 | 547 | __poll_t ret = 0; |
beafc54c | 548 | |
543af586 | 549 | mutex_lock(&idev->info_lock); |
a93e7b33 HM |
550 | if (!idev->info || !idev->info->irq) |
551 | ret = -EIO; | |
543af586 | 552 | mutex_unlock(&idev->info_lock); |
a93e7b33 HM |
553 | |
554 | if (ret) | |
555 | return ret; | |
beafc54c HK |
556 | |
557 | poll_wait(filep, &idev->wait, wait); | |
558 | if (listener->event_count != atomic_read(&idev->event)) | |
a9a08845 | 559 | return EPOLLIN | EPOLLRDNORM; |
beafc54c HK |
560 | return 0; |
561 | } | |
562 | ||
563 | static ssize_t uio_read(struct file *filep, char __user *buf, | |
564 | size_t count, loff_t *ppos) | |
565 | { | |
566 | struct uio_listener *listener = filep->private_data; | |
567 | struct uio_device *idev = listener->dev; | |
568 | DECLARE_WAITQUEUE(wait, current); | |
a93e7b33 | 569 | ssize_t retval = 0; |
beafc54c HK |
570 | s32 event_count; |
571 | ||
beafc54c HK |
572 | if (count != sizeof(s32)) |
573 | return -EINVAL; | |
574 | ||
575 | add_wait_queue(&idev->wait, &wait); | |
576 | ||
577 | do { | |
b5570ca7 ZZ |
578 | mutex_lock(&idev->info_lock); |
579 | if (!idev->info || !idev->info->irq) { | |
580 | retval = -EIO; | |
581 | mutex_unlock(&idev->info_lock); | |
582 | break; | |
583 | } | |
584 | mutex_unlock(&idev->info_lock); | |
585 | ||
beafc54c HK |
586 | set_current_state(TASK_INTERRUPTIBLE); |
587 | ||
588 | event_count = atomic_read(&idev->event); | |
589 | if (event_count != listener->event_count) { | |
edce5e6f | 590 | __set_current_state(TASK_RUNNING); |
beafc54c HK |
591 | if (copy_to_user(buf, &event_count, count)) |
592 | retval = -EFAULT; | |
593 | else { | |
594 | listener->event_count = event_count; | |
595 | retval = count; | |
596 | } | |
597 | break; | |
598 | } | |
599 | ||
600 | if (filep->f_flags & O_NONBLOCK) { | |
601 | retval = -EAGAIN; | |
602 | break; | |
603 | } | |
604 | ||
605 | if (signal_pending(current)) { | |
606 | retval = -ERESTARTSYS; | |
607 | break; | |
608 | } | |
609 | schedule(); | |
610 | } while (1); | |
611 | ||
612 | __set_current_state(TASK_RUNNING); | |
613 | remove_wait_queue(&idev->wait, &wait); | |
614 | ||
615 | return retval; | |
616 | } | |
617 | ||
328a14e7 HK |
618 | static ssize_t uio_write(struct file *filep, const char __user *buf, |
619 | size_t count, loff_t *ppos) | |
620 | { | |
621 | struct uio_listener *listener = filep->private_data; | |
622 | struct uio_device *idev = listener->dev; | |
623 | ssize_t retval; | |
624 | s32 irq_on; | |
625 | ||
b34e9a15 XL |
626 | if (count != sizeof(s32)) |
627 | return -EINVAL; | |
628 | ||
629 | if (copy_from_user(&irq_on, buf, count)) | |
630 | return -EFAULT; | |
631 | ||
543af586 | 632 | mutex_lock(&idev->info_lock); |
57c5f4df XL |
633 | if (!idev->info) { |
634 | retval = -EINVAL; | |
635 | goto out; | |
636 | } | |
637 | ||
54557665 | 638 | if (!idev->info->irq) { |
81daa406 HM |
639 | retval = -EIO; |
640 | goto out; | |
641 | } | |
328a14e7 | 642 | |
81daa406 HM |
643 | if (!idev->info->irqcontrol) { |
644 | retval = -ENOSYS; | |
645 | goto out; | |
646 | } | |
328a14e7 | 647 | |
328a14e7 HK |
648 | retval = idev->info->irqcontrol(idev->info, irq_on); |
649 | ||
81daa406 | 650 | out: |
543af586 | 651 | mutex_unlock(&idev->info_lock); |
328a14e7 HK |
652 | return retval ? retval : sizeof(s32); |
653 | } | |
654 | ||
beafc54c HK |
655 | static int uio_find_mem_index(struct vm_area_struct *vma) |
656 | { | |
beafc54c HK |
657 | struct uio_device *idev = vma->vm_private_data; |
658 | ||
f0c554fd HD |
659 | if (vma->vm_pgoff < MAX_UIO_MAPS) { |
660 | if (idev->info->mem[vma->vm_pgoff].size == 0) | |
beafc54c | 661 | return -1; |
f0c554fd | 662 | return (int)vma->vm_pgoff; |
beafc54c HK |
663 | } |
664 | return -1; | |
665 | } | |
666 | ||
9b85e95a | 667 | static vm_fault_t uio_vma_fault(struct vm_fault *vmf) |
beafc54c | 668 | { |
11bac800 | 669 | struct uio_device *idev = vmf->vma->vm_private_data; |
a18b630d | 670 | struct page *page; |
02683ffd | 671 | unsigned long offset; |
e6418fcc | 672 | void *addr; |
79c6f4b8 | 673 | vm_fault_t ret = 0; |
57c5f4df | 674 | int mi; |
beafc54c | 675 | |
57c5f4df XL |
676 | mutex_lock(&idev->info_lock); |
677 | if (!idev->info) { | |
678 | ret = VM_FAULT_SIGBUS; | |
679 | goto out; | |
680 | } | |
681 | ||
682 | mi = uio_find_mem_index(vmf->vma); | |
683 | if (mi < 0) { | |
684 | ret = VM_FAULT_SIGBUS; | |
685 | goto out; | |
686 | } | |
beafc54c | 687 | |
02683ffd AH |
688 | /* |
689 | * We need to subtract mi because userspace uses offset = N*PAGE_SIZE | |
690 | * to use mem[N]. | |
691 | */ | |
692 | offset = (vmf->pgoff - mi) << PAGE_SHIFT; | |
693 | ||
e6418fcc | 694 | addr = (void *)(unsigned long)idev->info->mem[mi].addr + offset; |
beafc54c | 695 | if (idev->info->mem[mi].memtype == UIO_MEM_LOGICAL) |
e6418fcc | 696 | page = virt_to_page(addr); |
beafc54c | 697 | else |
e6418fcc | 698 | page = vmalloc_to_page(addr); |
beafc54c | 699 | get_page(page); |
a18b630d | 700 | vmf->page = page; |
57c5f4df XL |
701 | |
702 | out: | |
703 | mutex_unlock(&idev->info_lock); | |
704 | ||
705 | return ret; | |
beafc54c HK |
706 | } |
707 | ||
7294151d | 708 | static const struct vm_operations_struct uio_logical_vm_ops = { |
a18b630d | 709 | .fault = uio_vma_fault, |
beafc54c HK |
710 | }; |
711 | ||
7294151d UKK |
712 | static int uio_mmap_logical(struct vm_area_struct *vma) |
713 | { | |
714 | vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; | |
715 | vma->vm_ops = &uio_logical_vm_ops; | |
7294151d UKK |
716 | return 0; |
717 | } | |
718 | ||
719 | static const struct vm_operations_struct uio_physical_vm_ops = { | |
720 | #ifdef CONFIG_HAVE_IOREMAP_PROT | |
721 | .access = generic_access_phys, | |
722 | #endif | |
723 | }; | |
724 | ||
beafc54c HK |
725 | static int uio_mmap_physical(struct vm_area_struct *vma) |
726 | { | |
727 | struct uio_device *idev = vma->vm_private_data; | |
728 | int mi = uio_find_mem_index(vma); | |
7314e613 | 729 | struct uio_mem *mem; |
57c5f4df | 730 | |
beafc54c HK |
731 | if (mi < 0) |
732 | return -EINVAL; | |
7314e613 | 733 | mem = idev->info->mem + mi; |
beafc54c | 734 | |
b6550287 LT |
735 | if (mem->addr & ~PAGE_MASK) |
736 | return -ENODEV; | |
b29f680c | 737 | if (vma->vm_end - vma->vm_start > mem->size) |
7314e613 | 738 | return -EINVAL; |
7294151d | 739 | |
7314e613 | 740 | vma->vm_ops = &uio_physical_vm_ops; |
bfddabfa SH |
741 | if (idev->info->mem[mi].memtype == UIO_MEM_PHYS) |
742 | vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); | |
beafc54c | 743 | |
7314e613 LT |
744 | /* |
745 | * We cannot use the vm_iomap_memory() helper here, | |
746 | * because vma->vm_pgoff is the map index we looked | |
747 | * up above in uio_find_mem_index(), rather than an | |
748 | * actual page offset into the mmap. | |
749 | * | |
750 | * So we just do the physical mmap without a page | |
751 | * offset. | |
752 | */ | |
beafc54c HK |
753 | return remap_pfn_range(vma, |
754 | vma->vm_start, | |
7314e613 | 755 | mem->addr >> PAGE_SHIFT, |
beafc54c HK |
756 | vma->vm_end - vma->vm_start, |
757 | vma->vm_page_prot); | |
758 | } | |
759 | ||
beafc54c HK |
760 | static int uio_mmap(struct file *filep, struct vm_area_struct *vma) |
761 | { | |
762 | struct uio_listener *listener = filep->private_data; | |
763 | struct uio_device *idev = listener->dev; | |
764 | int mi; | |
765 | unsigned long requested_pages, actual_pages; | |
766 | int ret = 0; | |
767 | ||
768 | if (vma->vm_end < vma->vm_start) | |
769 | return -EINVAL; | |
770 | ||
771 | vma->vm_private_data = idev; | |
772 | ||
57c5f4df XL |
773 | mutex_lock(&idev->info_lock); |
774 | if (!idev->info) { | |
775 | ret = -EINVAL; | |
776 | goto out; | |
777 | } | |
778 | ||
beafc54c | 779 | mi = uio_find_mem_index(vma); |
57c5f4df XL |
780 | if (mi < 0) { |
781 | ret = -EINVAL; | |
782 | goto out; | |
783 | } | |
beafc54c | 784 | |
52c2dad9 | 785 | requested_pages = vma_pages(vma); |
6da2d377 IA |
786 | actual_pages = ((idev->info->mem[mi].addr & ~PAGE_MASK) |
787 | + idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT; | |
57c5f4df XL |
788 | if (requested_pages > actual_pages) { |
789 | ret = -EINVAL; | |
790 | goto out; | |
791 | } | |
beafc54c HK |
792 | |
793 | if (idev->info->mmap) { | |
beafc54c | 794 | ret = idev->info->mmap(idev->info, vma); |
57c5f4df | 795 | goto out; |
beafc54c HK |
796 | } |
797 | ||
798 | switch (idev->info->mem[mi].memtype) { | |
bfddabfa SH |
799 | case UIO_MEM_IOVA: |
800 | case UIO_MEM_PHYS: | |
801 | ret = uio_mmap_physical(vma); | |
802 | break; | |
803 | case UIO_MEM_LOGICAL: | |
804 | case UIO_MEM_VIRTUAL: | |
805 | ret = uio_mmap_logical(vma); | |
806 | break; | |
807 | default: | |
808 | ret = -EINVAL; | |
beafc54c | 809 | } |
57c5f4df | 810 | |
bfddabfa | 811 | out: |
57c5f4df | 812 | mutex_unlock(&idev->info_lock); |
e7de2590 | 813 | return ret; |
beafc54c HK |
814 | } |
815 | ||
4f014691 | 816 | static const struct file_operations uio_fops = { |
beafc54c HK |
817 | .owner = THIS_MODULE, |
818 | .open = uio_open, | |
819 | .release = uio_release, | |
820 | .read = uio_read, | |
328a14e7 | 821 | .write = uio_write, |
beafc54c HK |
822 | .mmap = uio_mmap, |
823 | .poll = uio_poll, | |
824 | .fasync = uio_fasync, | |
6038f373 | 825 | .llseek = noop_llseek, |
beafc54c HK |
826 | }; |
827 | ||
828 | static int uio_major_init(void) | |
829 | { | |
91960a46 EB |
830 | static const char name[] = "uio"; |
831 | struct cdev *cdev = NULL; | |
832 | dev_t uio_dev = 0; | |
833 | int result; | |
834 | ||
835 | result = alloc_chrdev_region(&uio_dev, 0, UIO_MAX_DEVICES, name); | |
836 | if (result) | |
837 | goto out; | |
838 | ||
839 | result = -ENOMEM; | |
840 | cdev = cdev_alloc(); | |
841 | if (!cdev) | |
842 | goto out_unregister; | |
843 | ||
844 | cdev->owner = THIS_MODULE; | |
845 | cdev->ops = &uio_fops; | |
846 | kobject_set_name(&cdev->kobj, "%s", name); | |
847 | ||
848 | result = cdev_add(cdev, uio_dev, UIO_MAX_DEVICES); | |
849 | if (result) | |
850 | goto out_put; | |
851 | ||
852 | uio_major = MAJOR(uio_dev); | |
853 | uio_cdev = cdev; | |
d80df1ce | 854 | return 0; |
91960a46 EB |
855 | out_put: |
856 | kobject_put(&cdev->kobj); | |
857 | out_unregister: | |
858 | unregister_chrdev_region(uio_dev, UIO_MAX_DEVICES); | |
d80df1ce WG |
859 | out: |
860 | return result; | |
beafc54c HK |
861 | } |
862 | ||
863 | static void uio_major_cleanup(void) | |
864 | { | |
91960a46 EB |
865 | unregister_chrdev_region(MKDEV(uio_major, 0), UIO_MAX_DEVICES); |
866 | cdev_del(uio_cdev); | |
beafc54c HK |
867 | } |
868 | ||
869 | static int init_uio_class(void) | |
870 | { | |
3d4f9d76 | 871 | int ret; |
beafc54c HK |
872 | |
873 | /* This is the first time in here, set everything up properly */ | |
874 | ret = uio_major_init(); | |
875 | if (ret) | |
876 | goto exit; | |
877 | ||
c66fdab6 EB |
878 | ret = class_register(&uio_class); |
879 | if (ret) { | |
880 | printk(KERN_ERR "class_register failed for uio\n"); | |
881 | goto err_class_register; | |
beafc54c | 882 | } |
ae61cf5b AB |
883 | |
884 | uio_class_registered = true; | |
885 | ||
beafc54c HK |
886 | return 0; |
887 | ||
c66fdab6 | 888 | err_class_register: |
beafc54c HK |
889 | uio_major_cleanup(); |
890 | exit: | |
891 | return ret; | |
892 | } | |
893 | ||
3d4f9d76 | 894 | static void release_uio_class(void) |
beafc54c | 895 | { |
ae61cf5b | 896 | uio_class_registered = false; |
c66fdab6 | 897 | class_unregister(&uio_class); |
beafc54c | 898 | uio_major_cleanup(); |
beafc54c HK |
899 | } |
900 | ||
a93e7b33 HM |
901 | static void uio_device_release(struct device *dev) |
902 | { | |
903 | struct uio_device *idev = dev_get_drvdata(dev); | |
904 | ||
905 | kfree(idev); | |
906 | } | |
907 | ||
beafc54c HK |
908 | /** |
909 | * uio_register_device - register a new userspace IO device | |
910 | * @owner: module that creates the new device | |
911 | * @parent: parent device | |
912 | * @info: UIO device capabilities | |
913 | * | |
914 | * returns zero on success or a negative error code. | |
915 | */ | |
916 | int __uio_register_device(struct module *owner, | |
917 | struct device *parent, | |
918 | struct uio_info *info) | |
919 | { | |
920 | struct uio_device *idev; | |
921 | int ret = 0; | |
922 | ||
ae61cf5b AB |
923 | if (!uio_class_registered) |
924 | return -EPROBE_DEFER; | |
925 | ||
beafc54c HK |
926 | if (!parent || !info || !info->name || !info->version) |
927 | return -EINVAL; | |
928 | ||
929 | info->uio_dev = NULL; | |
930 | ||
a93e7b33 | 931 | idev = kzalloc(sizeof(*idev), GFP_KERNEL); |
beafc54c | 932 | if (!idev) { |
e6789cd3 | 933 | return -ENOMEM; |
beafc54c HK |
934 | } |
935 | ||
936 | idev->owner = owner; | |
937 | idev->info = info; | |
543af586 | 938 | mutex_init(&idev->info_lock); |
beafc54c HK |
939 | init_waitqueue_head(&idev->wait); |
940 | atomic_set(&idev->event, 0); | |
941 | ||
942 | ret = uio_get_minor(idev); | |
1a392b3d LJ |
943 | if (ret) { |
944 | kfree(idev); | |
e6789cd3 | 945 | return ret; |
1a392b3d | 946 | } |
beafc54c | 947 | |
221a1f4a | 948 | device_initialize(&idev->dev); |
a93e7b33 HM |
949 | idev->dev.devt = MKDEV(uio_major, idev->minor); |
950 | idev->dev.class = &uio_class; | |
951 | idev->dev.parent = parent; | |
952 | idev->dev.release = uio_device_release; | |
953 | dev_set_drvdata(&idev->dev, idev); | |
954 | ||
955 | ret = dev_set_name(&idev->dev, "uio%d", idev->minor); | |
956 | if (ret) | |
957 | goto err_device_create; | |
958 | ||
221a1f4a | 959 | ret = device_add(&idev->dev); |
a93e7b33 | 960 | if (ret) |
beafc54c | 961 | goto err_device_create; |
beafc54c HK |
962 | |
963 | ret = uio_dev_add_attributes(idev); | |
964 | if (ret) | |
965 | goto err_uio_dev_add_attributes; | |
966 | ||
43279819 DC |
967 | info->uio_dev = idev; |
968 | ||
6427a765 | 969 | if (info->irq && (info->irq != UIO_IRQ_CUSTOM)) { |
a087146c BR |
970 | /* |
971 | * Note that we deliberately don't use devm_request_irq | |
972 | * here. The parent module can unregister the UIO device | |
973 | * and call pci_disable_msi, which requires that this | |
974 | * irq has been freed. However, the device may have open | |
975 | * FDs at the time of unregister and therefore may not be | |
976 | * freed until they are released. | |
977 | */ | |
3d27c4de XL |
978 | ret = request_irq(info->irq, uio_interrupt, |
979 | info->irq_flags, info->name, idev); | |
43279819 DC |
980 | if (ret) { |
981 | info->uio_dev = NULL; | |
beafc54c | 982 | goto err_request_irq; |
43279819 | 983 | } |
beafc54c HK |
984 | } |
985 | ||
986 | return 0; | |
987 | ||
988 | err_request_irq: | |
989 | uio_dev_del_attributes(idev); | |
990 | err_uio_dev_add_attributes: | |
221a1f4a | 991 | device_del(&idev->dev); |
beafc54c HK |
992 | err_device_create: |
993 | uio_free_minor(idev); | |
221a1f4a | 994 | put_device(&idev->dev); |
beafc54c HK |
995 | return ret; |
996 | } | |
997 | EXPORT_SYMBOL_GPL(__uio_register_device); | |
998 | ||
86a78b1c AA |
999 | static void devm_uio_unregister_device(struct device *dev, void *res) |
1000 | { | |
1001 | uio_unregister_device(*(struct uio_info **)res); | |
1002 | } | |
1003 | ||
1004 | /** | |
1005 | * devm_uio_register_device - Resource managed uio_register_device() | |
1006 | * @owner: module that creates the new device | |
1007 | * @parent: parent device | |
1008 | * @info: UIO device capabilities | |
1009 | * | |
1010 | * returns zero on success or a negative error code. | |
1011 | */ | |
1012 | int __devm_uio_register_device(struct module *owner, | |
1013 | struct device *parent, | |
1014 | struct uio_info *info) | |
1015 | { | |
1016 | struct uio_info **ptr; | |
1017 | int ret; | |
1018 | ||
1019 | ptr = devres_alloc(devm_uio_unregister_device, sizeof(*ptr), | |
1020 | GFP_KERNEL); | |
1021 | if (!ptr) | |
1022 | return -ENOMEM; | |
1023 | ||
1024 | *ptr = info; | |
1025 | ret = __uio_register_device(owner, parent, info); | |
1026 | if (ret) { | |
1027 | devres_free(ptr); | |
1028 | return ret; | |
1029 | } | |
1030 | ||
1031 | devres_add(parent, ptr); | |
1032 | ||
1033 | return 0; | |
1034 | } | |
1035 | EXPORT_SYMBOL_GPL(__devm_uio_register_device); | |
1036 | ||
beafc54c HK |
1037 | /** |
1038 | * uio_unregister_device - unregister a industrial IO device | |
1039 | * @info: UIO device capabilities | |
1040 | * | |
1041 | */ | |
1042 | void uio_unregister_device(struct uio_info *info) | |
1043 | { | |
1044 | struct uio_device *idev; | |
1045 | ||
1046 | if (!info || !info->uio_dev) | |
1047 | return; | |
1048 | ||
1049 | idev = info->uio_dev; | |
1050 | ||
1051 | uio_free_minor(idev); | |
1052 | ||
57c5f4df | 1053 | mutex_lock(&idev->info_lock); |
beafc54c HK |
1054 | uio_dev_del_attributes(idev); |
1055 | ||
9ff2c132 SH |
1056 | if (info->irq && info->irq != UIO_IRQ_CUSTOM) |
1057 | free_irq(info->irq, idev); | |
a087146c | 1058 | |
a93e7b33 | 1059 | idev->info = NULL; |
543af586 | 1060 | mutex_unlock(&idev->info_lock); |
a93e7b33 | 1061 | |
b5570ca7 ZZ |
1062 | wake_up_interruptible(&idev->wait); |
1063 | kill_fasync(&idev->async_queue, SIGIO, POLL_HUP); | |
1064 | ||
a93e7b33 | 1065 | device_unregister(&idev->dev); |
beafc54c HK |
1066 | |
1067 | return; | |
1068 | } | |
1069 | EXPORT_SYMBOL_GPL(uio_unregister_device); | |
1070 | ||
1071 | static int __init uio_init(void) | |
1072 | { | |
3d4f9d76 | 1073 | return init_uio_class(); |
beafc54c HK |
1074 | } |
1075 | ||
1076 | static void __exit uio_exit(void) | |
1077 | { | |
3d4f9d76 | 1078 | release_uio_class(); |
e2ef9393 | 1079 | idr_destroy(&uio_idr); |
beafc54c HK |
1080 | } |
1081 | ||
1082 | module_init(uio_init) | |
1083 | module_exit(uio_exit) | |
1084 | MODULE_LICENSE("GPL v2"); |