File: /usr/src/linux/drivers/sbus/char/sunmouse.c
1 /* sunmouse.c: Sun mouse driver for the Sparc
2 *
3 * Copyright (C) 1995, 1996, 1997 David S. Miller (davem@caip.rutgers.edu)
4 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
5 *
6 * Parts based on the psaux.c driver written by:
7 * Johan Myreen.
8 *
9 * Dec/19/95 Added SunOS mouse ioctls - miguel.
10 * Jan/5/96 Added VUID support, sigio support - miguel.
11 * Mar/5/96 Added proper mouse stream support - miguel.
12 * Sep/96 Allow more than one reader -miguel.
13 * Aug/97 Added PCI 8042 controller support -DaveM
14 */
15
16 /* The mouse is run off of one of the Zilog serial ports. On
17 * that port is the mouse and the keyboard, each gets a zs channel.
18 * The mouse itself is mouse-systems in nature. So the protocol is:
19 *
20 * Byte 1) Button state which is bit-encoded as
21 * 0x4 == left-button down, else up
22 * 0x2 == middle-button down, else up
23 * 0x1 == right-button down, else up
24 *
25 * Byte 2) Delta-x
26 * Byte 3) Delta-y
27 * Byte 4) Delta-x again
28 * Byte 5) Delta-y again
29 *
30 * One day this driver will have to support more than one mouse in the system.
31 *
32 * This driver has two modes of operation: the default VUID_NATIVE is
33 * set when the device is opened and allows the application to see the
34 * mouse character stream as we get it from the serial (for gpm for
35 * example). The second method, VUID_FIRM_EVENT will provide cooked
36 * events in Firm_event records as expected by SunOS/Solaris applications.
37 *
38 * FIXME: We need to support more than one mouse.
39 * */
40
41 #include <linux/config.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/fcntl.h>
45 #include <linux/signal.h>
46 #include <linux/timer.h>
47 #include <linux/errno.h>
48 #include <linux/miscdevice.h>
49 #include <linux/mm.h>
50 #include <linux/poll.h>
51 #include <linux/spinlock.h>
52 #include <linux/smp_lock.h>
53 #include <linux/init.h>
54 #include <asm/uaccess.h>
55 #include <asm/system.h>
56 #include <asm/vuid_event.h>
57 #include <linux/random.h>
58 /* The following keeps track of software state for the Sun
59 * mouse.
60 */
61 #define STREAM_SIZE 2048
62 #define EV_SIZE (STREAM_SIZE/sizeof (Firm_event))
63 #define BUTTON_LEFT 4
64 #define BUTTON_MIDDLE 2
65 #define BUTTON_RIGHT 1
66
67 struct sun_mouse {
68 unsigned char transaction[5]; /* Each protocol transaction */
69 unsigned char byte; /* Counter, starts at 0 */
70 unsigned char button_state; /* Current button state */
71 unsigned char prev_state; /* Previous button state */
72 int delta_x; /* Current delta-x */
73 int delta_y; /* Current delta-y */
74 int active; /* set if device is open */
75 int vuid_mode; /* VUID_NATIVE or VUID_FIRM_EVENT */
76 wait_queue_head_t proc_list;
77 struct fasync_struct *fasync;
78
79 /* The event/stream queue */
80 spinlock_t lock;
81 unsigned int head;
82 unsigned int tail;
83 union {
84 char stream [STREAM_SIZE];
85 Firm_event ev [EV_SIZE];
86 } queue;
87 };
88
89 static struct sun_mouse sunmouse;
90 #define gen_events (sunmouse.vuid_mode != VUID_NATIVE)
91 #define bstate sunmouse.button_state
92 #define pstate sunmouse.prev_state
93
94 extern void mouse_put_char(char ch);
95
96 #undef SMOUSE_DEBUG
97
98 static int
99 push_event (Firm_event *ev)
100 {
101 unsigned long flags;
102 int next, ret;
103
104 spin_lock_irqsave(&sunmouse.lock, flags);
105
106 next = (sunmouse.head + 1) % EV_SIZE;
107 ret = 0;
108 if (next != sunmouse.tail) {
109 sunmouse.queue.ev [sunmouse.head] = *ev;
110 sunmouse.head = next;
111 ret = 1;
112 }
113
114 spin_unlock_irqrestore(&sunmouse.lock, flags);
115
116 return ret;
117 }
118
119 static int
120 queue_empty (void)
121 {
122 return sunmouse.head == sunmouse.tail;
123 }
124
125 /* Must be invoked under the sunmouse.lock */
126 static void get_from_queue (Firm_event *p)
127 {
128 *p = sunmouse.queue.ev [sunmouse.tail];
129 sunmouse.tail = (sunmouse.tail + 1) % EV_SIZE;
130 }
131
132 static void
133 push_char (char c)
134 {
135 unsigned long flags;
136 int next;
137
138 spin_lock_irqsave(&sunmouse.lock, flags);
139
140 next = (sunmouse.head + 1) % STREAM_SIZE;
141 if (next != sunmouse.tail) {
142 #ifdef SMOUSE_DEBUG
143 printk("P<%02x>\n", (unsigned char)c);
144 #endif
145 sunmouse.queue.stream [sunmouse.head] = c;
146 sunmouse.head = next;
147 }
148
149 spin_unlock_irqrestore(&sunmouse.lock, flags);
150
151 kill_fasync (&sunmouse.fasync, SIGIO, POLL_IN);
152 wake_up_interruptible (&sunmouse.proc_list);
153 }
154
155 /* Auto baud rate "detection". ;-) */
156 static int mouse_baud = 4800; /* Initial rate set by zilog driver. */
157
158 /* Change the baud rate after receiving too many "bogon bytes". */
159 void sun_mouse_change_baud(void)
160 {
161 extern void rs_change_mouse_baud(int newbaud);
162
163 if(mouse_baud == 1200)
164 mouse_baud = 2400;
165 else if(mouse_baud == 2400)
166 mouse_baud = 4800;
167 else if(mouse_baud == 4800)
168 mouse_baud = 9600;
169 else
170 mouse_baud = 1200;
171
172 rs_change_mouse_baud(mouse_baud);
173 }
174
175 /* This tries to monitor the mouse state so that it
176 * can automatically adjust to the correct baud rate.
177 * The mouse spits out BRKs when the baud rate is
178 * incorrect.
179 *
180 * It returns non-zero if we should ignore this byte.
181 */
182 int mouse_baud_detection(unsigned char c, int is_break)
183 {
184 static int mouse_got_break = 0;
185 static int ctr = 0;
186
187 if (is_break) {
188 /* Let a few normal bytes go by before
189 * we jump the gun and say we need to
190 * try another baud rate.
191 */
192 if (mouse_got_break && ctr < 8)
193 return 1;
194
195 /* OK, we need to try another baud rate. */
196 sun_mouse_change_baud();
197 ctr = 0;
198 mouse_got_break = 1;
199 return 1;
200 }
201 if (mouse_got_break) {
202 ctr++;
203 if (c == 0x87) {
204 printk(KERN_INFO "sunmouse: Successfully "
205 "adjusted to %d baud.\n", mouse_baud);
206 mouse_got_break = 0;
207 }
208 return 1;
209 }
210
211 return 0;
212 }
213
214 /* You ask me, why does this cap the lower bound at -127 and not
215 * -128? Because the xf86 mouse code is crap and treats -128
216 * as an illegal value and resets it's protocol state machine
217 * when it sees this value.
218 */
219 #define CLIP(__X) (((__X) > 127) ? 127 : (((__X) < -127) ? -127 : (__X)))
220
221 /* The following is called from the serial driver when bytes/breaks
222 * are received on the Mouse line.
223 */
224 void
225 sun_mouse_inbyte(unsigned char byte, int is_break)
226 {
227 signed char mvalue;
228 int d, pushed = 0;
229 Firm_event ev;
230
231 add_mouse_randomness (byte);
232 #if 0
233 {
234 static int xxx = 0;
235 printk("mouse(%02x:%d) ",
236 byte, is_break);
237 if (byte == 0x87) {
238 xxx = 0;
239 printk("\n");
240 }
241 }
242 #endif
243 if (mouse_baud_detection(byte, is_break))
244 return;
245
246 if(!sunmouse.active)
247 return;
248
249 /* Ignore this if it is garbage. */
250 if (sunmouse.byte == 69) {
251 if (byte != 0x87)
252 return;
253
254 /* Ok, we've begun the state machine. */
255 sunmouse.byte = 0;
256 }
257 #if 0
258 /* If the mouse sends us a byte from 0x80 to 0x87
259 * we are starting at byte zero in the transaction
260 * protocol.
261 */
262 if((byte & ~0x0f) == 0x80)
263 sunmouse.byte = 0;
264 #endif
265
266 mvalue = (signed char) byte;
267 switch(sunmouse.byte) {
268 case 0:
269 /* If we get a bogus button byte, just skip it.
270 * When we get here the baud detection code has
271 * passed, so the only other things which can
272 * cause this are dropped serial characters and
273 * confused mouse. We check this because otherwise
274 * begin posting erroneous mouse events.
275 */
276 if ((byte & 0xf0) != 0x80)
277 return;
278
279 /* Button state */
280 sunmouse.button_state = (~byte) & 0x7;
281 #ifdef SMOUSE_DEBUG
282 printk("B<Left %s, Middle %s, Right %s>",
283 ((sunmouse.button_state & 0x4) ? "DOWN" : "UP"),
284 ((sunmouse.button_state & 0x2) ? "DOWN" : "UP"),
285 ((sunmouse.button_state & 0x1) ? "DOWN" : "UP"));
286 #endif
287 /* To deal with the Sparcbook 3 */
288 if (byte & 0x8) {
289 sunmouse.byte += 2;
290 sunmouse.delta_y = 0;
291 sunmouse.delta_x = 0;
292 }
293 sunmouse.byte++;
294 return;
295 case 1:
296 /* Delta-x 1 */
297 #ifdef SMOUSE_DEBUG
298 printk("DX1<%d>", mvalue);
299 #endif
300 sunmouse.delta_x = mvalue;
301 sunmouse.byte++;
302 return;
303 case 2:
304 /* Delta-y 1 */
305 #ifdef SMOUSE_DEBUG
306 printk("DY1<%d>", mvalue);
307 #endif
308 sunmouse.delta_y = mvalue;
309 sunmouse.byte++;
310 return;
311 case 3:
312 /* Delta-x 2 */
313 #ifdef SMOUSE_DEBUG
314 printk("DX2<%d>", mvalue);
315 #endif
316 sunmouse.delta_x += mvalue;
317 sunmouse.delta_x = CLIP(sunmouse.delta_x);
318 sunmouse.byte++;
319 return;
320 case 4:
321 /* Last byte, Delta-y 2 */
322 #ifdef SMOUSE_DEBUG
323 printk("DY2<%d>", mvalue);
324 #endif
325 sunmouse.delta_y += mvalue;
326 sunmouse.delta_y = CLIP(sunmouse.delta_y);
327 sunmouse.byte = 0; /* Back to button state */
328 break;
329 case 69:
330 /* Until we get the (0x80 -> 0x87) value we aren't
331 * in the middle of a real transaction, so just
332 * return.
333 */
334 return;
335 default:
336 printk("sunmouse: bogon transaction state\n");
337 sunmouse.byte = 69; /* What could cause this? */
338 return;
339 };
340
341 if (!gen_events) {
342 push_char (~sunmouse.button_state & 0x87);
343 push_char (sunmouse.delta_x);
344 push_char (sunmouse.delta_y);
345 return;
346 }
347
348 d = bstate ^ pstate;
349 pstate = bstate;
350 if (d) {
351 if (d & BUTTON_LEFT) {
352 ev.id = MS_LEFT;
353 ev.value = bstate & BUTTON_LEFT;
354 }
355 if (d & BUTTON_RIGHT) {
356 ev.id = MS_RIGHT;
357 ev.value = bstate & BUTTON_RIGHT;
358 }
359 if (d & BUTTON_MIDDLE) {
360 ev.id = MS_MIDDLE;
361 ev.value = bstate & BUTTON_MIDDLE;
362 }
363 ev.time = xtime;
364 ev.value = ev.value ? VKEY_DOWN : VKEY_UP;
365 pushed += push_event (&ev);
366 }
367 if (sunmouse.delta_x) {
368 ev.id = LOC_X_DELTA;
369 ev.time = xtime;
370 ev.value = sunmouse.delta_x;
371 pushed += push_event (&ev);
372 sunmouse.delta_x = 0;
373 }
374 if (sunmouse.delta_y) {
375 ev.id = LOC_Y_DELTA;
376 ev.time = xtime;
377 ev.value = sunmouse.delta_y;
378 pushed += push_event (&ev);
379 }
380
381 if (pushed != 0) {
382 /* We just completed a transaction, wake up whoever is awaiting
383 * this event.
384 */
385 kill_fasync (&sunmouse.fasync, SIGIO, POLL_IN);
386 wake_up_interruptible(&sunmouse.proc_list);
387 }
388 return;
389 }
390
391 static int
392 sun_mouse_open(struct inode * inode, struct file * file)
393 {
394 spin_lock_irq(&sunmouse.lock);
395 if (sunmouse.active++)
396 goto out;
397 sunmouse.delta_x = sunmouse.delta_y = 0;
398 sunmouse.button_state = 0x80;
399 sunmouse.vuid_mode = VUID_NATIVE;
400 out:
401 spin_unlock_irq(&sunmouse.lock);
402 return 0;
403 }
404
405 static int sun_mouse_fasync (int fd, struct file *filp, int on)
406 {
407 int retval;
408
409 retval = fasync_helper (fd, filp, on, &sunmouse.fasync);
410 if (retval < 0)
411 return retval;
412 return 0;
413 }
414
415 static int
416 sun_mouse_close(struct inode *inode, struct file *file)
417 {
418 sun_mouse_fasync (-1, file, 0);
419
420 spin_lock_irq(&sunmouse.lock);
421 sunmouse.active--;
422 spin_unlock_irq(&sunmouse.lock);
423
424 return 0;
425 }
426
427 static ssize_t
428 sun_mouse_write(struct file *file, const char *buffer,
429 size_t count, loff_t *ppos)
430 {
431 return -EINVAL; /* foo on you */
432 }
433
434 static ssize_t
435 sun_mouse_read(struct file *file, char *buffer,
436 size_t count, loff_t *ppos)
437 {
438 DECLARE_WAITQUEUE(wait, current);
439 unsigned long flags;
440
441 if (queue_empty ()) {
442 if (file->f_flags & O_NONBLOCK)
443 return -EWOULDBLOCK;
444 add_wait_queue (&sunmouse.proc_list, &wait);
445 repeat:
446 set_current_state(TASK_INTERRUPTIBLE);
447 if (queue_empty() && !signal_pending(current)) {
448 schedule();
449 goto repeat;
450 }
451 current->state = TASK_RUNNING;
452 remove_wait_queue (&sunmouse.proc_list, &wait);
453 }
454 if (gen_events) {
455 char *p = buffer, *end = buffer+count;
456
457 spin_lock_irqsave(&sunmouse.lock, flags);
458 while (p < end && !queue_empty ()){
459 Firm_event this_event;
460
461 get_from_queue(&this_event);
462 spin_unlock_irqrestore(&sunmouse.lock, flags);
463
464 #ifdef CONFIG_SPARC32_COMPAT
465 if (current->thread.flags & SPARC_FLAG_32BIT) {
466 if ((end - p) <
467 ((sizeof(Firm_event) - sizeof(struct timeval) +
468 (sizeof(u32) * 2))))
469 break;
470 if (copy_to_user((Firm_event *)p, &this_event,
471 sizeof(Firm_event)-sizeof(struct timeval)))
472 return -EFAULT;
473 p += sizeof(Firm_event)-sizeof(struct timeval);
474 if (__put_user(this_event.time.tv_sec, (u32 *)p))
475 return -EFAULT;
476 p += sizeof(u32);
477 if (__put_user(this_event.time.tv_usec, (u32 *)p))
478 return -EFAULT;
479 p += sizeof(u32);
480 } else
481 #endif
482 {
483 if ((end - p) < sizeof(Firm_event))
484 break;
485 if (copy_to_user((Firm_event *)p, &this_event,
486 sizeof(Firm_event)))
487 return -EFAULT;
488 p += sizeof (Firm_event);
489 }
490 spin_lock_irqsave(&sunmouse.lock, flags);
491 }
492 spin_unlock_irqrestore(&sunmouse.lock, flags);
493 file->f_dentry->d_inode->i_atime = CURRENT_TIME;
494 return p-buffer;
495 } else {
496 int c, limit = 3;
497
498 if (count < limit)
499 limit = count;
500 for (c = 0; c < limit; c++) {
501 unsigned char val;
502 int empty = 0;
503
504 spin_lock_irqsave(&sunmouse.lock, flags);
505 if (queue_empty()) {
506 empty = 1;
507 val = 0;
508 } else {
509 val = sunmouse.queue.stream[sunmouse.tail];
510 sunmouse.tail = (sunmouse.tail + 1) % STREAM_SIZE;
511 }
512 spin_unlock_irqrestore(&sunmouse.lock, flags);
513
514 if (empty)
515 break;
516
517 put_user(val, buffer);
518 buffer++;
519 }
520 while (c < count) {
521 if (c >= 5)
522 break;
523 put_user(0, buffer);
524 buffer++;
525 c++;
526 }
527 file->f_dentry->d_inode->i_atime = CURRENT_TIME;
528 return c;
529 }
530 /* Only called if nothing was sent */
531 if (signal_pending(current))
532 return -ERESTARTSYS;
533 return 0;
534 }
535
536 static unsigned int sun_mouse_poll(struct file *file, poll_table *wait)
537 {
538 poll_wait(file, &sunmouse.proc_list, wait);
539 if(!queue_empty())
540 return POLLIN | POLLRDNORM;
541 return 0;
542 }
543 int
544 sun_mouse_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
545 {
546 int i;
547
548 switch (cmd){
549 /* VUIDGFORMAT - Get input device byte stream format */
550 case _IOR('v', 2, int):
551 if (put_user(sunmouse.vuid_mode, (int *) arg))
552 return -EFAULT;
553 break;
554
555 /* VUIDSFORMAT - Set input device byte stream format*/
556 case _IOW('v', 1, int):
557 if (get_user(i, (int *) arg))
558 return -EFAULT;
559 if (i == VUID_NATIVE || i == VUID_FIRM_EVENT){
560 int value;
561
562 if (get_user(value, (int *)arg))
563 return -EFAULT;
564
565 spin_lock_irq(&sunmouse.lock);
566 sunmouse.vuid_mode = value;
567 sunmouse.head = sunmouse.tail = 0;
568 spin_unlock_irq(&sunmouse.lock);
569 } else
570 return -EINVAL;
571 break;
572
573 case 0x8024540b:
574 case 0x40245408:
575 /* This is a buggy application doing termios on the mouse driver */
576 /* we ignore it. I keep this check here so that we will notice */
577 /* future mouse vuid ioctls */
578 return -ENOTTY;
579
580 default:
581 #ifdef DEBUG
582 printk ("[MOUSE-ioctl: %8.8x]\n", cmd);
583 #endif
584 return -EINVAL;
585 }
586 return 0;
587 }
588
589 struct file_operations sun_mouse_fops = {
590 read: sun_mouse_read,
591 write: sun_mouse_write,
592 poll: sun_mouse_poll,
593 ioctl: sun_mouse_ioctl,
594 open: sun_mouse_open,
595 release: sun_mouse_close,
596 fasync: sun_mouse_fasync,
597 };
598
599 static struct miscdevice sun_mouse_mouse = {
600 SUN_MOUSE_MINOR, "sunmouse", &sun_mouse_fops
601 };
602
603 void sun_mouse_zsinit(void)
604 {
605 printk("Sun Mouse-Systems mouse driver version 1.00\n");
606
607 sunmouse.active = 0;
608 misc_register (&sun_mouse_mouse);
609 sunmouse.delta_x = sunmouse.delta_y = 0;
610 sunmouse.button_state = 0x80;
611 init_waitqueue_head(&sunmouse.proc_list);
612 spin_lock_init(&sunmouse.lock);
613 sunmouse.byte = 69;
614 }
615