1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Input driver to ExplorerPS/2 device driver module.
   4 *
   5 * Copyright (c) 1999-2002 Vojtech Pavlik
   6 * Copyright (c) 2004      Dmitry Torokhov
   7 */
   8
   9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11#define MOUSEDEV_MINOR_BASE	32
  12#define MOUSEDEV_MINORS		31
  13#define MOUSEDEV_MIX		63
  14
  15#include <linux/bitops.h>
  16#include <linux/sched.h>
  17#include <linux/slab.h>
  18#include <linux/poll.h>
  19#include <linux/module.h>
  20#include <linux/init.h>
  21#include <linux/input.h>
  22#include <linux/random.h>
  23#include <linux/major.h>
  24#include <linux/device.h>
  25#include <linux/cdev.h>
  26#include <linux/kernel.h>
  27
  28MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  29MODULE_DESCRIPTION("Mouse (ExplorerPS/2) device interfaces");
  30MODULE_LICENSE("GPL");
  31
  32#ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_X
  33#define CONFIG_INPUT_MOUSEDEV_SCREEN_X	1024
  34#endif
  35#ifndef CONFIG_INPUT_MOUSEDEV_SCREEN_Y
  36#define CONFIG_INPUT_MOUSEDEV_SCREEN_Y	768
  37#endif
  38
  39static int xres = CONFIG_INPUT_MOUSEDEV_SCREEN_X;
  40module_param(xres, uint, 0644);
  41MODULE_PARM_DESC(xres, "Horizontal screen resolution");
  42
  43static int yres = CONFIG_INPUT_MOUSEDEV_SCREEN_Y;
  44module_param(yres, uint, 0644);
  45MODULE_PARM_DESC(yres, "Vertical screen resolution");
  46
  47static unsigned tap_time = 200;
  48module_param(tap_time, uint, 0644);
  49MODULE_PARM_DESC(tap_time, "Tap time for touchpads in absolute mode (msecs)");
  50
  51struct mousedev_hw_data {
  52	int dx, dy, dz;
  53	int x, y;
  54	int abs_event;
  55	unsigned long buttons;
  56};
  57
  58struct mousedev {
  59	int open;
  60	struct input_handle handle;
  61	wait_queue_head_t wait;
  62	struct list_head client_list;
  63	spinlock_t client_lock; /* protects client_list */
  64	struct mutex mutex;
  65	struct device dev;
  66	struct cdev cdev;
  67	bool exist;
  68
  69	struct list_head mixdev_node;
  70	bool opened_by_mixdev;
  71
  72	struct mousedev_hw_data packet;
  73	unsigned int pkt_count;
  74	int old_x[4], old_y[4];
  75	int frac_dx, frac_dy;
  76	unsigned long touch;
  77
  78	int (*open_device)(struct mousedev *mousedev);
  79	void (*close_device)(struct mousedev *mousedev);
  80};
  81
  82enum mousedev_emul {
  83	MOUSEDEV_EMUL_PS2,
  84	MOUSEDEV_EMUL_IMPS,
  85	MOUSEDEV_EMUL_EXPS
  86};
  87
  88struct mousedev_motion {
  89	int dx, dy, dz;
  90	unsigned long buttons;
  91};
  92
  93#define PACKET_QUEUE_LEN	16
  94struct mousedev_client {
  95	struct fasync_struct *fasync;
  96	struct mousedev *mousedev;
  97	struct list_head node;
  98
  99	struct mousedev_motion packets[PACKET_QUEUE_LEN];
 100	unsigned int head, tail;
 101	spinlock_t packet_lock;
 102	int pos_x, pos_y;
 103
 104	u8 ps2[6];
 105	unsigned char ready, buffer, bufsiz;
 106	unsigned char imexseq, impsseq;
 107	enum mousedev_emul mode;
 108	unsigned long last_buttons;
 109};
 110
 111#define MOUSEDEV_SEQ_LEN	6
 112
 113static unsigned char mousedev_imps_seq[] = { 0xf3, 200, 0xf3, 100, 0xf3, 80 };
 114static unsigned char mousedev_imex_seq[] = { 0xf3, 200, 0xf3, 200, 0xf3, 80 };
 115
 116static struct mousedev *mousedev_mix;
 117static LIST_HEAD(mousedev_mix_list);
 118
 119#define fx(i)  (mousedev->old_x[(mousedev->pkt_count - (i)) & 03])
 120#define fy(i)  (mousedev->old_y[(mousedev->pkt_count - (i)) & 03])
 121
 122static void mousedev_touchpad_event(struct input_dev *dev,
 123				    struct mousedev *mousedev,
 124				    unsigned int code, int value)
 125{
 126	int size, tmp;
 127	enum { FRACTION_DENOM = 128 };
 128
 129	switch (code) {
 130
 131	case ABS_X:
 132
 133		fx(0) = value;
 134		if (mousedev->touch && mousedev->pkt_count >= 2) {
 135			size = input_abs_get_max(dev, ABS_X) -
 136					input_abs_get_min(dev, ABS_X);
 137			if (size == 0)
 138				size = 256 * 2;
 139
 140			tmp = ((value - fx(2)) * 256 * FRACTION_DENOM) / size;
 141			tmp += mousedev->frac_dx;
 142			mousedev->packet.dx = tmp / FRACTION_DENOM;
 143			mousedev->frac_dx =
 144				tmp - mousedev->packet.dx * FRACTION_DENOM;
 145		}
 146		break;
 147
 148	case ABS_Y:
 149		fy(0) = value;
 150		if (mousedev->touch && mousedev->pkt_count >= 2) {
 151			/* use X size for ABS_Y to keep the same scale */
 152			size = input_abs_get_max(dev, ABS_X) -
 153					input_abs_get_min(dev, ABS_X);
 154			if (size == 0)
 155				size = 256 * 2;
 156
 157			tmp = -((value - fy(2)) * 256 * FRACTION_DENOM) / size;
 158			tmp += mousedev->frac_dy;
 159			mousedev->packet.dy = tmp / FRACTION_DENOM;
 160			mousedev->frac_dy = tmp -
 161				mousedev->packet.dy * FRACTION_DENOM;
 162		}
 163		break;
 164	}
 165}
 166
 167static void mousedev_abs_event(struct input_dev *dev, struct mousedev *mousedev,
 168				unsigned int code, int value)
 169{
 170	int min, max, size;
 171
 172	switch (code) {
 173
 174	case ABS_X:
 175		min = input_abs_get_min(dev, ABS_X);
 176		max = input_abs_get_max(dev, ABS_X);
 177
 178		size = max - min;
 179		if (size == 0)
 180			size = xres ? : 1;
 181
 182		value = clamp(value, min, max);
 183
 184		mousedev->packet.x = ((value - min) * xres) / size;
 185		mousedev->packet.abs_event = 1;
 186		break;
 187
 188	case ABS_Y:
 189		min = input_abs_get_min(dev, ABS_Y);
 190		max = input_abs_get_max(dev, ABS_Y);
 191
 192		size = max - min;
 193		if (size == 0)
 194			size = yres ? : 1;
 195
 196		value = clamp(value, min, max);
 197
 198		mousedev->packet.y = yres - ((value - min) * yres) / size;
 199		mousedev->packet.abs_event = 1;
 200		break;
 201	}
 202}
 203
 204static void mousedev_rel_event(struct mousedev *mousedev,
 205				unsigned int code, int value)
 206{
 207	switch (code) {
 208	case REL_X:
 209		mousedev->packet.dx += value;
 210		break;
 211
 212	case REL_Y:
 213		mousedev->packet.dy -= value;
 214		break;
 215
 216	case REL_WHEEL:
 217		mousedev->packet.dz -= value;
 218		break;
 219	}
 220}
 221
 222static void mousedev_key_event(struct mousedev *mousedev,
 223				unsigned int code, int value)
 224{
 225	int index;
 226
 227	switch (code) {
 228
 229	case BTN_TOUCH:
 230	case BTN_0:
 231	case BTN_LEFT:		index = 0; break;
 232
 233	case BTN_STYLUS:
 234	case BTN_1:
 235	case BTN_RIGHT:		index = 1; break;
 236
 237	case BTN_2:
 238	case BTN_FORWARD:
 239	case BTN_STYLUS2:
 240	case BTN_MIDDLE:	index = 2; break;
 241
 242	case BTN_3:
 243	case BTN_BACK:
 244	case BTN_SIDE:		index = 3; break;
 245
 246	case BTN_4:
 247	case BTN_EXTRA:		index = 4; break;
 248
 249	default:		return;
 250	}
 251
 252	if (value) {
 253		set_bit(index, &mousedev->packet.buttons);
 254		set_bit(index, &mousedev_mix->packet.buttons);
 255	} else {
 256		clear_bit(index, &mousedev->packet.buttons);
 257		clear_bit(index, &mousedev_mix->packet.buttons);
 258	}
 259}
 260
 261static void mousedev_notify_readers(struct mousedev *mousedev,
 262				    struct mousedev_hw_data *packet)
 263{
 264	struct mousedev_client *client;
 265	struct mousedev_motion *p;
 266	unsigned int new_head;
 267	int wake_readers = 0;
 268
 269	rcu_read_lock();
 270	list_for_each_entry_rcu(client, &mousedev->client_list, node) {
 271
 272		/* Just acquire the lock, interrupts already disabled */
 273		spin_lock(&client->packet_lock);
 274
 275		p = &client->packets[client->head];
 276		if (client->ready && p->buttons != mousedev->packet.buttons) {
 277			new_head = (client->head + 1) % PACKET_QUEUE_LEN;
 278			if (new_head != client->tail) {
 279				p = &client->packets[client->head = new_head];
 280				memset(p, 0, sizeof(struct mousedev_motion));
 281			}
 282		}
 283
 284		if (packet->abs_event) {
 285			p->dx += packet->x - client->pos_x;
 286			p->dy += packet->y - client->pos_y;
 287			client->pos_x = packet->x;
 288			client->pos_y = packet->y;
 289		}
 290
 291		client->pos_x += packet->dx;
 292		client->pos_x = clamp_val(client->pos_x, 0, xres);
 293
 294		client->pos_y += packet->dy;
 295		client->pos_y = clamp_val(client->pos_y, 0, yres);
 296
 297		p->dx += packet->dx;
 298		p->dy += packet->dy;
 299		p->dz += packet->dz;
 300		p->buttons = mousedev->packet.buttons;
 301
 302		if (p->dx || p->dy || p->dz ||
 303		    p->buttons != client->last_buttons)
 304			client->ready = 1;
 305
 306		spin_unlock(&client->packet_lock);
 307
 308		if (client->ready) {
 309			kill_fasync(&client->fasync, SIGIO, POLL_IN);
 310			wake_readers = 1;
 311		}
 312	}
 313	rcu_read_unlock();
 314
 315	if (wake_readers)
 316		wake_up_interruptible(&mousedev->wait);
 317}
 318
 319static void mousedev_touchpad_touch(struct mousedev *mousedev, int value)
 320{
 321	if (!value) {
 322		if (mousedev->touch &&
 323		    time_before(jiffies,
 324				mousedev->touch + msecs_to_jiffies(tap_time))) {
 325			/*
 326			 * Toggle left button to emulate tap.
 327			 * We rely on the fact that mousedev_mix always has 0
 328			 * motion packet so we won't mess current position.
 329			 */
 330			set_bit(0, &mousedev->packet.buttons);
 331			set_bit(0, &mousedev_mix->packet.buttons);
 332			mousedev_notify_readers(mousedev, &mousedev_mix->packet);
 333			mousedev_notify_readers(mousedev_mix,
 334						&mousedev_mix->packet);
 335			clear_bit(0, &mousedev->packet.buttons);
 336			clear_bit(0, &mousedev_mix->packet.buttons);
 337		}
 338		mousedev->touch = mousedev->pkt_count = 0;
 339		mousedev->frac_dx = 0;
 340		mousedev->frac_dy = 0;
 341
 342	} else if (!mousedev->touch)
 343		mousedev->touch = jiffies;
 344}
 345
 346static void mousedev_event(struct input_handle *handle,
 347			   unsigned int type, unsigned int code, int value)
 348{
 349	struct mousedev *mousedev = handle->private;
 350
 351	switch (type) {
 352
 353	case EV_ABS:
 354		/* Ignore joysticks */
 355		if (test_bit(BTN_TRIGGER, handle->dev->keybit))
 356			return;
 357
 358		if (test_bit(BTN_TOOL_FINGER, handle->dev->keybit))
 359			mousedev_touchpad_event(handle->dev,
 360						mousedev, code, value);
 361		else
 362			mousedev_abs_event(handle->dev, mousedev, code, value);
 363
 364		break;
 365
 366	case EV_REL:
 367		mousedev_rel_event(mousedev, code, value);
 368		break;
 369
 370	case EV_KEY:
 371		if (value != 2) {
 372			if (code == BTN_TOUCH &&
 373			    test_bit(BTN_TOOL_FINGER, handle->dev->keybit))
 374				mousedev_touchpad_touch(mousedev, value);
 375			else
 376				mousedev_key_event(mousedev, code, value);
 377		}
 378		break;
 379
 380	case EV_SYN:
 381		if (code == SYN_REPORT) {
 382			if (mousedev->touch) {
 383				mousedev->pkt_count++;
 384				/*
 385				 * Input system eats duplicate events,
 386				 * but we need all of them to do correct
 387				 * averaging so apply present one forward
 388				 */
 389				fx(0) = fx(1);
 390				fy(0) = fy(1);
 391			}
 392
 393			mousedev_notify_readers(mousedev, &mousedev->packet);
 394			mousedev_notify_readers(mousedev_mix, &mousedev->packet);
 395
 396			mousedev->packet.dx = mousedev->packet.dy =
 397				mousedev->packet.dz = 0;
 398			mousedev->packet.abs_event = 0;
 399		}
 400		break;
 401	}
 402}
 403
 404static int mousedev_fasync(int fd, struct file *file, int on)
 405{
 406	struct mousedev_client *client = file->private_data;
 407
 408	return fasync_helper(fd, file, on, &client->fasync);
 409}
 410
 411static void mousedev_free(struct device *dev)
 412{
 413	struct mousedev *mousedev = container_of(dev, struct mousedev, dev);
 414
 415	input_put_device(mousedev->handle.dev);
 416	kfree(mousedev);
 417}
 418
 419static int mousedev_open_device(struct mousedev *mousedev)
 420{
 421	int retval;
 422
 423	retval = mutex_lock_interruptible(&mousedev->mutex);
 424	if (retval)
 425		return retval;
 426
 427	if (!mousedev->exist)
 428		retval = -ENODEV;
 429	else if (!mousedev->open++) {
 430		retval = input_open_device(&mousedev->handle);
 431		if (retval)
 432			mousedev->open--;
 433	}
 434
 435	mutex_unlock(&mousedev->mutex);
 436	return retval;
 437}
 438
 439static void mousedev_close_device(struct mousedev *mousedev)
 440{
 441	mutex_lock(&mousedev->mutex);
 442
 443	if (mousedev->exist && !--mousedev->open)
 444		input_close_device(&mousedev->handle);
 445
 446	mutex_unlock(&mousedev->mutex);
 447}
 448
 449/*
 450 * Open all available devices so they can all be multiplexed in one.
 451 * stream. Note that this function is called with mousedev_mix->mutex
 452 * held.
 453 */
 454static int mixdev_open_devices(struct mousedev *mixdev)
 455{
 456	int error;
 457
 458	error = mutex_lock_interruptible(&mixdev->mutex);
 459	if (error)
 460		return error;
 461
 462	if (!mixdev->open++) {
 463		struct mousedev *mousedev;
 464
 465		list_for_each_entry(mousedev, &mousedev_mix_list, mixdev_node) {
 466			if (!mousedev->opened_by_mixdev) {
 467				if (mousedev_open_device(mousedev))
 468					continue;
 469
 470				mousedev->opened_by_mixdev = true;
 471			}
 472		}
 473	}
 474
 475	mutex_unlock(&mixdev->mutex);
 476	return 0;
 477}
 478
 479/*
 480 * Close all devices that were opened as part of multiplexed
 481 * device. Note that this function is called with mousedev_mix->mutex
 482 * held.
 483 */
 484static void mixdev_close_devices(struct mousedev *mixdev)
 485{
 486	mutex_lock(&mixdev->mutex);
 487
 488	if (!--mixdev->open) {
 489		struct mousedev *mousedev;
 490
 491		list_for_each_entry(mousedev, &mousedev_mix_list, mixdev_node) {
 492			if (mousedev->opened_by_mixdev) {
 493				mousedev->opened_by_mixdev = false;
 494				mousedev_close_device(mousedev);
 495			}
 496		}
 497	}
 498
 499	mutex_unlock(&mixdev->mutex);
 500}
 501
 502
 503static void mousedev_attach_client(struct mousedev *mousedev,
 504				   struct mousedev_client *client)
 505{
 506	spin_lock(&mousedev->client_lock);
 507	list_add_tail_rcu(&client->node, &mousedev->client_list);
 508	spin_unlock(&mousedev->client_lock);
 509}
 510
 511static void mousedev_detach_client(struct mousedev *mousedev,
 512				   struct mousedev_client *client)
 513{
 514	spin_lock(&mousedev->client_lock);
 515	list_del_rcu(&client->node);
 516	spin_unlock(&mousedev->client_lock);
 517	synchronize_rcu();
 518}
 519
 520static int mousedev_release(struct inode *inode, struct file *file)
 521{
 522	struct mousedev_client *client = file->private_data;
 523	struct mousedev *mousedev = client->mousedev;
 524
 525	mousedev_detach_client(mousedev, client);
 526	kfree(client);
 527
 528	mousedev->close_device(mousedev);
 529
 530	return 0;
 531}
 532
 533static int mousedev_open(struct inode *inode, struct file *file)
 534{
 535	struct mousedev_client *client;
 536	struct mousedev *mousedev;
 537	int error;
 538
 539#ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
 540	if (imajor(inode) == MISC_MAJOR)
 541		mousedev = mousedev_mix;
 542	else
 543#endif
 544		mousedev = container_of(inode->i_cdev, struct mousedev, cdev);
 545
 546	client = kzalloc(sizeof(struct mousedev_client), GFP_KERNEL);
 547	if (!client)
 548		return -ENOMEM;
 549
 550	spin_lock_init(&client->packet_lock);
 551	client->pos_x = xres / 2;
 552	client->pos_y = yres / 2;
 553	client->mousedev = mousedev;
 554	mousedev_attach_client(mousedev, client);
 555
 556	error = mousedev->open_device(mousedev);
 557	if (error)
 558		goto err_free_client;
 559
 560	file->private_data = client;
 561	stream_open(inode, file);
 562
 563	return 0;
 564
 565 err_free_client:
 566	mousedev_detach_client(mousedev, client);
 567	kfree(client);
 568	return error;
 569}
 570
 571static void mousedev_packet(struct mousedev_client *client, u8 *ps2_data)
 572{
 573	struct mousedev_motion *p = &client->packets[client->tail];
 574	s8 dx, dy, dz;
 575
 576	dx = clamp_val(p->dx, -127, 127);
 577	p->dx -= dx;
 578
 579	dy = clamp_val(p->dy, -127, 127);
 580	p->dy -= dy;
 581
 582	ps2_data[0] = BIT(3);
 583	ps2_data[0] |= ((dx & BIT(7)) >> 3) | ((dy & BIT(7)) >> 2);
 584	ps2_data[0] |= p->buttons & 0x07;
 585	ps2_data[1] = dx;
 586	ps2_data[2] = dy;
 587
 588	switch (client->mode) {
 589	case MOUSEDEV_EMUL_EXPS:
 590		dz = clamp_val(p->dz, -7, 7);
 591		p->dz -= dz;
 592
 593		ps2_data[3] = (dz & 0x0f) | ((p->buttons & 0x18) << 1);
 594		client->bufsiz = 4;
 595		break;
 596
 597	case MOUSEDEV_EMUL_IMPS:
 598		dz = clamp_val(p->dz, -127, 127);
 599		p->dz -= dz;
 600
 601		ps2_data[0] |= ((p->buttons & 0x10) >> 3) |
 602			       ((p->buttons & 0x08) >> 1);
 603		ps2_data[3] = dz;
 604
 605		client->bufsiz = 4;
 606		break;
 607
 608	case MOUSEDEV_EMUL_PS2:
 609	default:
 610		p->dz = 0;
 611
 612		ps2_data[0] |= ((p->buttons & 0x10) >> 3) |
 613			       ((p->buttons & 0x08) >> 1);
 614
 615		client->bufsiz = 3;
 616		break;
 617	}
 618
 619	if (!p->dx && !p->dy && !p->dz) {
 620		if (client->tail == client->head) {
 621			client->ready = 0;
 622			client->last_buttons = p->buttons;
 623		} else
 624			client->tail = (client->tail + 1) % PACKET_QUEUE_LEN;
 625	}
 626}
 627
 628static void mousedev_generate_response(struct mousedev_client *client,
 629					int command)
 630{
 631	client->ps2[0] = 0xfa; /* ACK */
 632
 633	switch (command) {
 634
 635	case 0xeb: /* Poll */
 636		mousedev_packet(client, &client->ps2[1]);
 637		client->bufsiz++; /* account for leading ACK */
 638		break;
 639
 640	case 0xf2: /* Get ID */
 641		switch (client->mode) {
 642		case MOUSEDEV_EMUL_PS2:
 643			client->ps2[1] = 0;
 644			break;
 645		case MOUSEDEV_EMUL_IMPS:
 646			client->ps2[1] = 3;
 647			break;
 648		case MOUSEDEV_EMUL_EXPS:
 649			client->ps2[1] = 4;
 650			break;
 651		}
 652		client->bufsiz = 2;
 653		break;
 654
 655	case 0xe9: /* Get info */
 656		client->ps2[1] = 0x60; client->ps2[2] = 3; client->ps2[3] = 200;
 657		client->bufsiz = 4;
 658		break;
 659
 660	case 0xff: /* Reset */
 661		client->impsseq = client->imexseq = 0;
 662		client->mode = MOUSEDEV_EMUL_PS2;
 663		client->ps2[1] = 0xaa; client->ps2[2] = 0x00;
 664		client->bufsiz = 3;
 665		break;
 666
 667	default:
 668		client->bufsiz = 1;
 669		break;
 670	}
 671	client->buffer = client->bufsiz;
 672}
 673
 674static ssize_t mousedev_write(struct file *file, const char __user *buffer,
 675				size_t count, loff_t *ppos)
 676{
 677	struct mousedev_client *client = file->private_data;
 678	unsigned char c;
 679	unsigned int i;
 680
 681	for (i = 0; i < count; i++) {
 682
 683		if (get_user(c, buffer + i))
 684			return -EFAULT;
 685
 686		spin_lock_irq(&client->packet_lock);
 687
 688		if (c == mousedev_imex_seq[client->imexseq]) {
 689			if (++client->imexseq == MOUSEDEV_SEQ_LEN) {
 690				client->imexseq = 0;
 691				client->mode = MOUSEDEV_EMUL_EXPS;
 692			}
 693		} else
 694			client->imexseq = 0;
 695
 696		if (c == mousedev_imps_seq[client->impsseq]) {
 697			if (++client->impsseq == MOUSEDEV_SEQ_LEN) {
 698				client->impsseq = 0;
 699				client->mode = MOUSEDEV_EMUL_IMPS;
 700			}
 701		} else
 702			client->impsseq = 0;
 703
 704		mousedev_generate_response(client, c);
 705
 706		spin_unlock_irq(&client->packet_lock);
 707		cond_resched();
 708	}
 709
 710	kill_fasync(&client->fasync, SIGIO, POLL_IN);
 711	wake_up_interruptible(&client->mousedev->wait);
 712
 713	return count;
 714}
 715
 716static ssize_t mousedev_read(struct file *file, char __user *buffer,
 717			     size_t count, loff_t *ppos)
 718{
 719	struct mousedev_client *client = file->private_data;
 720	struct mousedev *mousedev = client->mousedev;
 721	u8 data[sizeof(client->ps2)];
 722	int retval = 0;
 723
 724	if (!client->ready && !client->buffer && mousedev->exist &&
 725	    (file->f_flags & O_NONBLOCK))
 726		return -EAGAIN;
 727
 728	retval = wait_event_interruptible(mousedev->wait,
 729			!mousedev->exist || client->ready || client->buffer);
 730	if (retval)
 731		return retval;
 732
 733	if (!mousedev->exist)
 734		return -ENODEV;
 735
 736	spin_lock_irq(&client->packet_lock);
 737
 738	if (!client->buffer && client->ready) {
 739		mousedev_packet(client, client->ps2);
 740		client->buffer = client->bufsiz;
 741	}
 742
 743	if (count > client->buffer)
 744		count = client->buffer;
 745
 746	memcpy(data, client->ps2 + client->bufsiz - client->buffer, count);
 747	client->buffer -= count;
 748
 749	spin_unlock_irq(&client->packet_lock);
 750
 751	if (copy_to_user(buffer, data, count))
 752		return -EFAULT;
 753
 754	return count;
 755}
 756
 757/* No kernel lock - fine */
 758static __poll_t mousedev_poll(struct file *file, poll_table *wait)
 759{
 760	struct mousedev_client *client = file->private_data;
 761	struct mousedev *mousedev = client->mousedev;
 762	__poll_t mask;
 763
 764	poll_wait(file, &mousedev->wait, wait);
 765
 766	mask = mousedev->exist ? EPOLLOUT | EPOLLWRNORM : EPOLLHUP | EPOLLERR;
 767	if (client->ready || client->buffer)
 768		mask |= EPOLLIN | EPOLLRDNORM;
 769
 770	return mask;
 771}
 772
 773static const struct file_operations mousedev_fops = {
 774	.owner		= THIS_MODULE,
 775	.read		= mousedev_read,
 776	.write		= mousedev_write,
 777	.poll		= mousedev_poll,
 778	.open		= mousedev_open,
 779	.release	= mousedev_release,
 780	.fasync		= mousedev_fasync,
 781	.llseek		= noop_llseek,
 782};
 783
 784/*
 785 * Mark device non-existent. This disables writes, ioctls and
 786 * prevents new users from opening the device. Already posted
 787 * blocking reads will stay, however new ones will fail.
 788 */
 789static void mousedev_mark_dead(struct mousedev *mousedev)
 790{
 791	mutex_lock(&mousedev->mutex);
 792	mousedev->exist = false;
 793	mutex_unlock(&mousedev->mutex);
 794}
 795
 796/*
 797 * Wake up users waiting for IO so they can disconnect from
 798 * dead device.
 799 */
 800static void mousedev_hangup(struct mousedev *mousedev)
 801{
 802	struct mousedev_client *client;
 803
 804	spin_lock(&mousedev->client_lock);
 805	list_for_each_entry(client, &mousedev->client_list, node)
 806		kill_fasync(&client->fasync, SIGIO, POLL_HUP);
 807	spin_unlock(&mousedev->client_lock);
 808
 809	wake_up_interruptible(&mousedev->wait);
 810}
 811
 812static void mousedev_cleanup(struct mousedev *mousedev)
 813{
 814	struct input_handle *handle = &mousedev->handle;
 815
 816	mousedev_mark_dead(mousedev);
 817	mousedev_hangup(mousedev);
 818
 819	/* mousedev is marked dead so no one else accesses mousedev->open */
 820	if (mousedev->open)
 821		input_close_device(handle);
 822}
 823
 824static int mousedev_reserve_minor(bool mixdev)
 825{
 826	int minor;
 827
 828	if (mixdev) {
 829		minor = input_get_new_minor(MOUSEDEV_MIX, 1, false);
 830		if (minor < 0)
 831			pr_err("failed to reserve mixdev minor: %d\n", minor);
 832	} else {
 833		minor = input_get_new_minor(MOUSEDEV_MINOR_BASE,
 834					    MOUSEDEV_MINORS, true);
 835		if (minor < 0)
 836			pr_err("failed to reserve new minor: %d\n", minor);
 837	}
 838
 839	return minor;
 840}
 841
 842static struct mousedev *mousedev_create(struct input_dev *dev,
 843					struct input_handler *handler,
 844					bool mixdev)
 845{
 846	struct mousedev *mousedev;
 847	int minor;
 848	int error;
 849
 850	minor = mousedev_reserve_minor(mixdev);
 851	if (minor < 0) {
 852		error = minor;
 853		goto err_out;
 854	}
 855
 856	mousedev = kzalloc(sizeof(struct mousedev), GFP_KERNEL);
 857	if (!mousedev) {
 858		error = -ENOMEM;
 859		goto err_free_minor;
 860	}
 861
 862	INIT_LIST_HEAD(&mousedev->client_list);
 863	INIT_LIST_HEAD(&mousedev->mixdev_node);
 864	spin_lock_init(&mousedev->client_lock);
 865	mutex_init(&mousedev->mutex);
 866	lockdep_set_subclass(&mousedev->mutex,
 867			     mixdev ? SINGLE_DEPTH_NESTING : 0);
 868	init_waitqueue_head(&mousedev->wait);
 869
 870	if (mixdev) {
 871		dev_set_name(&mousedev->dev, "mice");
 872
 873		mousedev->open_device = mixdev_open_devices;
 874		mousedev->close_device = mixdev_close_devices;
 875	} else {
 876		int dev_no = minor;
 877		/* Normalize device number if it falls into legacy range */
 878		if (dev_no < MOUSEDEV_MINOR_BASE + MOUSEDEV_MINORS)
 879			dev_no -= MOUSEDEV_MINOR_BASE;
 880		dev_set_name(&mousedev->dev, "mouse%d", dev_no);
 881
 882		mousedev->open_device = mousedev_open_device;
 883		mousedev->close_device = mousedev_close_device;
 884	}
 885
 886	mousedev->exist = true;
 887	mousedev->handle.dev = input_get_device(dev);
 888	mousedev->handle.name = dev_name(&mousedev->dev);
 889	mousedev->handle.handler = handler;
 890	mousedev->handle.private = mousedev;
 891
 892	mousedev->dev.class = &input_class;
 893	if (dev)
 894		mousedev->dev.parent = &dev->dev;
 895	mousedev->dev.devt = MKDEV(INPUT_MAJOR, minor);
 896	mousedev->dev.release = mousedev_free;
 897	device_initialize(&mousedev->dev);
 898
 899	if (!mixdev) {
 900		error = input_register_handle(&mousedev->handle);
 901		if (error)
 902			goto err_free_mousedev;
 903	}
 904
 905	cdev_init(&mousedev->cdev, &mousedev_fops);
 906
 907	error = cdev_device_add(&mousedev->cdev, &mousedev->dev);
 908	if (error)
 909		goto err_cleanup_mousedev;
 910
 911	return mousedev;
 912
 913 err_cleanup_mousedev:
 914	mousedev_cleanup(mousedev);
 915	if (!mixdev)
 916		input_unregister_handle(&mousedev->handle);
 917 err_free_mousedev:
 918	put_device(&mousedev->dev);
 919 err_free_minor:
 920	input_free_minor(minor);
 921 err_out:
 922	return ERR_PTR(error);
 923}
 924
 925static void mousedev_destroy(struct mousedev *mousedev)
 926{
 927	cdev_device_del(&mousedev->cdev, &mousedev->dev);
 928	mousedev_cleanup(mousedev);
 929	input_free_minor(MINOR(mousedev->dev.devt));
 930	if (mousedev != mousedev_mix)
 931		input_unregister_handle(&mousedev->handle);
 932	put_device(&mousedev->dev);
 933}
 934
 935static int mixdev_add_device(struct mousedev *mousedev)
 936{
 937	int retval;
 938
 939	retval = mutex_lock_interruptible(&mousedev_mix->mutex);
 940	if (retval)
 941		return retval;
 942
 943	if (mousedev_mix->open) {
 944		retval = mousedev_open_device(mousedev);
 945		if (retval)
 946			goto out;
 947
 948		mousedev->opened_by_mixdev = true;
 949	}
 950
 951	get_device(&mousedev->dev);
 952	list_add_tail(&mousedev->mixdev_node, &mousedev_mix_list);
 953
 954 out:
 955	mutex_unlock(&mousedev_mix->mutex);
 956	return retval;
 957}
 958
 959static void mixdev_remove_device(struct mousedev *mousedev)
 960{
 961	mutex_lock(&mousedev_mix->mutex);
 962
 963	if (mousedev->opened_by_mixdev) {
 964		mousedev->opened_by_mixdev = false;
 965		mousedev_close_device(mousedev);
 966	}
 967
 968	list_del_init(&mousedev->mixdev_node);
 969	mutex_unlock(&mousedev_mix->mutex);
 970
 971	put_device(&mousedev->dev);
 972}
 973
 974static int mousedev_connect(struct input_handler *handler,
 975			    struct input_dev *dev,
 976			    const struct input_device_id *id)
 977{
 978	struct mousedev *mousedev;
 979	int error;
 980
 981	mousedev = mousedev_create(dev, handler, false);
 982	if (IS_ERR(mousedev))
 983		return PTR_ERR(mousedev);
 984
 985	error = mixdev_add_device(mousedev);
 986	if (error) {
 987		mousedev_destroy(mousedev);
 988		return error;
 989	}
 990
 991	return 0;
 992}
 993
 994static void mousedev_disconnect(struct input_handle *handle)
 995{
 996	struct mousedev *mousedev = handle->private;
 997
 998	mixdev_remove_device(mousedev);
 999	mousedev_destroy(mousedev);
1000}
1001
1002static const struct input_device_id mousedev_ids[] = {
1003	{
1004		.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1005				INPUT_DEVICE_ID_MATCH_KEYBIT |
1006				INPUT_DEVICE_ID_MATCH_RELBIT,
1007		.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) },
1008		.keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },
1009		.relbit = { BIT_MASK(REL_X) | BIT_MASK(REL_Y) },
1010	},	/* A mouse like device, at least one button,
1011		   two relative axes */
1012	{
1013		.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1014				INPUT_DEVICE_ID_MATCH_RELBIT,
1015		.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) },
1016		.relbit = { BIT_MASK(REL_WHEEL) },
1017	},	/* A separate scrollwheel */
1018	{
1019		.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1020				INPUT_DEVICE_ID_MATCH_KEYBIT |
1021				INPUT_DEVICE_ID_MATCH_ABSBIT,
1022		.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
1023		.keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) },
1024		.absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },
1025	},	/* A tablet like device, at least touch detection,
1026		   two absolute axes */
1027	{
1028		.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1029				INPUT_DEVICE_ID_MATCH_KEYBIT |
1030				INPUT_DEVICE_ID_MATCH_ABSBIT,
1031		.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
1032		.keybit = { [BIT_WORD(BTN_TOOL_FINGER)] =
1033				BIT_MASK(BTN_TOOL_FINGER) },
1034		.absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
1035				BIT_MASK(ABS_PRESSURE) |
1036				BIT_MASK(ABS_TOOL_WIDTH) },
1037	},	/* A touchpad */
1038	{
1039		.flags = INPUT_DEVICE_ID_MATCH_EVBIT |
1040			INPUT_DEVICE_ID_MATCH_KEYBIT |
1041			INPUT_DEVICE_ID_MATCH_ABSBIT,
1042		.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
1043		.keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },
1044		.absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },
1045	},	/* Mouse-like device with absolute X and Y but ordinary
1046		   clicks, like hp ILO2 High Performance mouse */
1047
1048	{ },	/* Terminating entry */
1049};
1050
1051MODULE_DEVICE_TABLE(input, mousedev_ids);
1052
1053static struct input_handler mousedev_handler = {
1054	.event		= mousedev_event,
1055	.connect	= mousedev_connect,
1056	.disconnect	= mousedev_disconnect,
1057	.legacy_minors	= true,
1058	.minor		= MOUSEDEV_MINOR_BASE,
1059	.name		= "mousedev",
1060	.id_table	= mousedev_ids,
1061};
1062
1063#ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
1064#include <linux/miscdevice.h>
1065
1066static struct miscdevice psaux_mouse = {
1067	.minor	= PSMOUSE_MINOR,
1068	.name	= "psaux",
1069	.fops	= &mousedev_fops,
1070};
1071
1072static bool psaux_registered;
1073
1074static void __init mousedev_psaux_register(void)
1075{
1076	int error;
1077
1078	error = misc_register(&psaux_mouse);
1079	if (error)
1080		pr_warn("could not register psaux device, error: %d\n",
1081			   error);
1082	else
1083		psaux_registered = true;
1084}
1085
1086static void __exit mousedev_psaux_unregister(void)
1087{
1088	if (psaux_registered)
1089		misc_deregister(&psaux_mouse);
1090}
1091#else
1092static inline void mousedev_psaux_register(void) { }
1093static inline void mousedev_psaux_unregister(void) { }
1094#endif
1095
1096static int __init mousedev_init(void)
1097{
1098	int error;
1099
1100	mousedev_mix = mousedev_create(NULL, &mousedev_handler, true);
1101	if (IS_ERR(mousedev_mix))
1102		return PTR_ERR(mousedev_mix);
1103
1104	error = input_register_handler(&mousedev_handler);
1105	if (error) {
1106		mousedev_destroy(mousedev_mix);
1107		return error;
1108	}
1109
1110	mousedev_psaux_register();
1111
1112	pr_info("PS/2 mouse device common for all mice\n");
1113
1114	return 0;
1115}
1116
1117static void __exit mousedev_exit(void)
1118{
1119	mousedev_psaux_unregister();
1120	input_unregister_handler(&mousedev_handler);
1121	mousedev_destroy(mousedev_mix);
1122}
1123
1124module_init(mousedev_init);
1125module_exit(mousedev_exit);