1/* 2 * Raw serio device providing access to a raw byte stream from underlying 3 * serio port. Closely emulates behavior of pre-2.6 /dev/psaux device 4 * 5 * Copyright (c) 2004 Dmitry Torokhov 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License version 2 as published by 9 * the Free Software Foundation. 10 */ 11 12#include <linux/sched.h> 13#include <linux/slab.h> 14#include <linux/smp_lock.h> 15#include <linux/poll.h> 16#include <linux/module.h> 17#include <linux/serio.h> 18#include <linux/init.h> 19#include <linux/major.h> 20#include <linux/device.h> 21#include <linux/miscdevice.h> 22#include <linux/wait.h> 23#include <linux/mutex.h> 24 25#define DRIVER_DESC "Raw serio driver" 26 27MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>"); 28MODULE_DESCRIPTION(DRIVER_DESC); 29MODULE_LICENSE("GPL"); 30 31#define SERIO_RAW_QUEUE_LEN 64 32struct serio_raw { 33 unsigned char queue[SERIO_RAW_QUEUE_LEN]; 34 unsigned int tail, head; 35 36 char name[16]; 37 unsigned int refcnt; 38 struct serio *serio; 39 struct miscdevice dev; 40 wait_queue_head_t wait; 41 struct list_head list; 42 struct list_head node; 43}; 44 45struct serio_raw_list { 46 struct fasync_struct *fasync; 47 struct serio_raw *serio_raw; 48 struct list_head node; 49}; 50 51static DEFINE_MUTEX(serio_raw_mutex); 52static LIST_HEAD(serio_raw_list); 53static unsigned int serio_raw_no; 54 55/********************************************************************* 56 * Interface with userspace (file operations) * 57 *********************************************************************/ 58 59static int serio_raw_fasync(int fd, struct file *file, int on) 60{ 61 struct serio_raw_list *list = file->private_data; 62 63 return fasync_helper(fd, file, on, &list->fasync); 64} 65 66static struct serio_raw *serio_raw_locate(int minor) 67{ 68 struct serio_raw *serio_raw; 69 70 list_for_each_entry(serio_raw, &serio_raw_list, node) { 71 if (serio_raw->dev.minor == minor) 72 return serio_raw; 73 } 74 75 return NULL; 76} 77 78static int serio_raw_open(struct inode *inode, struct file *file) 79{ 80 struct serio_raw *serio_raw; 81 struct serio_raw_list *list; 82 int retval = 0; 83 84 retval = mutex_lock_interruptible(&serio_raw_mutex); 85 if (retval) 86 return retval; 87 88 serio_raw = serio_raw_locate(iminor(inode)); 89 if (!serio_raw) { 90 retval = -ENODEV; 91 goto out; 92 } 93 94 if (!serio_raw->serio) { 95 retval = -ENODEV; 96 goto out; 97 } 98 99 list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL); 100 if (!list) { 101 retval = -ENOMEM; 102 goto out; 103 } 104 105 list->serio_raw = serio_raw; 106 file->private_data = list; 107 108 serio_raw->refcnt++; 109 list_add_tail(&list->node, &serio_raw->list); 110 111out: 112 mutex_unlock(&serio_raw_mutex); 113 return retval; 114} 115 116static int serio_raw_cleanup(struct serio_raw *serio_raw) 117{ 118 if (--serio_raw->refcnt == 0) { 119 misc_deregister(&serio_raw->dev); 120 list_del_init(&serio_raw->node); 121 kfree(serio_raw); 122 123 return 1; 124 } 125 126 return 0; 127} 128 129static int serio_raw_release(struct inode *inode, struct file *file) 130{ 131 struct serio_raw_list *list = file->private_data; 132 struct serio_raw *serio_raw = list->serio_raw; 133 134 mutex_lock(&serio_raw_mutex); 135 136 serio_raw_cleanup(serio_raw); 137 138 mutex_unlock(&serio_raw_mutex); 139 return 0; 140} 141 142static int serio_raw_fetch_byte(struct serio_raw *serio_raw, char *c) 143{ 144 unsigned long flags; 145 int empty; 146 147 spin_lock_irqsave(&serio_raw->serio->lock, flags); 148 149 empty = serio_raw->head == serio_raw->tail; 150 if (!empty) { 151 *c = serio_raw->queue[serio_raw->tail]; 152 serio_raw->tail = (serio_raw->tail + 1) % SERIO_RAW_QUEUE_LEN; 153 } 154 155 spin_unlock_irqrestore(&serio_raw->serio->lock, flags); 156 157 return !empty; 158} 159 160static ssize_t serio_raw_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos) 161{ 162 struct serio_raw_list *list = file->private_data; 163 struct serio_raw *serio_raw = list->serio_raw; 164 char uninitialized_var(c); 165 ssize_t retval = 0; 166 167 if (!serio_raw->serio) 168 return -ENODEV; 169 170 if (serio_raw->head == serio_raw->tail && (file->f_flags & O_NONBLOCK)) 171 return -EAGAIN; 172 173 retval = wait_event_interruptible(list->serio_raw->wait, 174 serio_raw->head != serio_raw->tail || !serio_raw->serio); 175 if (retval) 176 return retval; 177 178 if (!serio_raw->serio) 179 return -ENODEV; 180 181 while (retval < count && serio_raw_fetch_byte(serio_raw, &c)) { 182 if (put_user(c, buffer++)) 183 return -EFAULT; 184 retval++; 185 } 186 187 return retval; 188} 189 190static ssize_t serio_raw_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos) 191{ 192 struct serio_raw_list *list = file->private_data; 193 ssize_t written = 0; 194 int retval; 195 unsigned char c; 196 197 retval = mutex_lock_interruptible(&serio_raw_mutex); 198 if (retval) 199 return retval; 200 201 if (!list->serio_raw->serio) { 202 retval = -ENODEV; 203 goto out; 204 } 205 206 if (count > 32) 207 count = 32; 208 209 while (count--) { 210 if (get_user(c, buffer++)) { 211 retval = -EFAULT; 212 goto out; 213 } 214 if (serio_write(list->serio_raw->serio, c)) { 215 retval = -EIO; 216 goto out; 217 } 218 written++; 219 }; 220 221out: 222 mutex_unlock(&serio_raw_mutex); 223 return written; 224} 225 226static unsigned int serio_raw_poll(struct file *file, poll_table *wait) 227{ 228 struct serio_raw_list *list = file->private_data; 229 230 poll_wait(file, &list->serio_raw->wait, wait); 231 232 if (list->serio_raw->head != list->serio_raw->tail) 233 return POLLIN | POLLRDNORM; 234 235 return 0; 236} 237 238static const struct file_operations serio_raw_fops = { 239 .owner = THIS_MODULE, 240 .open = serio_raw_open, 241 .release = serio_raw_release, 242 .read = serio_raw_read, 243 .write = serio_raw_write, 244 .poll = serio_raw_poll, 245 .fasync = serio_raw_fasync, 246}; 247 248 249/********************************************************************* 250 * Interface with serio port * 251 *********************************************************************/ 252 253static irqreturn_t serio_raw_interrupt(struct serio *serio, unsigned char data, 254 unsigned int dfl) 255{ 256 struct serio_raw *serio_raw = serio_get_drvdata(serio); 257 struct serio_raw_list *list; 258 unsigned int head = serio_raw->head; 259 260 /* we are holding serio->lock here so we are prootected */ 261 serio_raw->queue[head] = data; 262 head = (head + 1) % SERIO_RAW_QUEUE_LEN; 263 if (likely(head != serio_raw->tail)) { 264 serio_raw->head = head; 265 list_for_each_entry(list, &serio_raw->list, node) 266 kill_fasync(&list->fasync, SIGIO, POLL_IN); 267 wake_up_interruptible(&serio_raw->wait); 268 } 269 270 return IRQ_HANDLED; 271} 272 273static int serio_raw_connect(struct serio *serio, struct serio_driver *drv) 274{ 275 struct serio_raw *serio_raw; 276 int err; 277 278 if (!(serio_raw = kzalloc(sizeof(struct serio_raw), GFP_KERNEL))) { 279 printk(KERN_ERR "serio_raw.c: can't allocate memory for a device\n"); 280 return -ENOMEM; 281 } 282 283 mutex_lock(&serio_raw_mutex); 284 285 snprintf(serio_raw->name, sizeof(serio_raw->name), "serio_raw%d", serio_raw_no++); 286 serio_raw->refcnt = 1; 287 serio_raw->serio = serio; 288 INIT_LIST_HEAD(&serio_raw->list); 289 init_waitqueue_head(&serio_raw->wait); 290 291 serio_set_drvdata(serio, serio_raw); 292 293 err = serio_open(serio, drv); 294 if (err) 295 goto out_free; 296 297 list_add_tail(&serio_raw->node, &serio_raw_list); 298 299 serio_raw->dev.minor = PSMOUSE_MINOR; 300 serio_raw->dev.name = serio_raw->name; 301 serio_raw->dev.parent = &serio->dev; 302 serio_raw->dev.fops = &serio_raw_fops; 303 304 err = misc_register(&serio_raw->dev); 305 if (err) { 306 serio_raw->dev.minor = MISC_DYNAMIC_MINOR; 307 err = misc_register(&serio_raw->dev); 308 } 309 310 if (err) { 311 printk(KERN_INFO "serio_raw: failed to register raw access device for %s\n", 312 serio->phys); 313 goto out_close; 314 } 315 316 printk(KERN_INFO "serio_raw: raw access enabled on %s (%s, minor %d)\n", 317 serio->phys, serio_raw->name, serio_raw->dev.minor); 318 goto out; 319 320out_close: 321 serio_close(serio); 322 list_del_init(&serio_raw->node); 323out_free: 324 serio_set_drvdata(serio, NULL); 325 kfree(serio_raw); 326out: 327 mutex_unlock(&serio_raw_mutex); 328 return err; 329} 330 331static int serio_raw_reconnect(struct serio *serio) 332{ 333 struct serio_raw *serio_raw = serio_get_drvdata(serio); 334 struct serio_driver *drv = serio->drv; 335 336 if (!drv || !serio_raw) { 337 printk(KERN_DEBUG "serio_raw: reconnect request, but serio is disconnected, ignoring...\n"); 338 return -1; 339 } 340 341 /* 342 * Nothing needs to be done here, we just need this method to 343 * keep the same device. 344 */ 345 return 0; 346} 347 348static void serio_raw_disconnect(struct serio *serio) 349{ 350 struct serio_raw *serio_raw; 351 352 mutex_lock(&serio_raw_mutex); 353 354 serio_raw = serio_get_drvdata(serio); 355 356 serio_close(serio); 357 serio_set_drvdata(serio, NULL); 358 359 serio_raw->serio = NULL; 360 if (!serio_raw_cleanup(serio_raw)) 361 wake_up_interruptible(&serio_raw->wait); 362 363 mutex_unlock(&serio_raw_mutex); 364} 365 366static struct serio_device_id serio_raw_serio_ids[] = { 367 { 368 .type = SERIO_8042, 369 .proto = SERIO_ANY, 370 .id = SERIO_ANY, 371 .extra = SERIO_ANY, 372 }, 373 { 374 .type = SERIO_8042_XL, 375 .proto = SERIO_ANY, 376 .id = SERIO_ANY, 377 .extra = SERIO_ANY, 378 }, 379 { 0 } 380}; 381 382MODULE_DEVICE_TABLE(serio, serio_raw_serio_ids); 383 384static struct serio_driver serio_raw_drv = { 385 .driver = { 386 .name = "serio_raw", 387 }, 388 .description = DRIVER_DESC, 389 .id_table = serio_raw_serio_ids, 390 .interrupt = serio_raw_interrupt, 391 .connect = serio_raw_connect, 392 .reconnect = serio_raw_reconnect, 393 .disconnect = serio_raw_disconnect, 394 .manual_bind = 1, 395}; 396 397static int __init serio_raw_init(void) 398{ 399 return serio_register_driver(&serio_raw_drv); 400} 401 402static void __exit serio_raw_exit(void) 403{ 404 serio_unregister_driver(&serio_raw_drv); 405} 406 407module_init(serio_raw_init); 408module_exit(serio_raw_exit); 409