1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Generic gameport layer
4  *
5  * Copyright (c) 1999-2002 Vojtech Pavlik
6  * Copyright (c) 2005 Dmitry Torokhov
7  */
8 
9 
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 
12 #include <linux/stddef.h>
13 #include <linux/module.h>
14 #include <linux/io.h>
15 #include <linux/ioport.h>
16 #include <linux/init.h>
17 #include <linux/gameport.h>
18 #include <linux/slab.h>
19 #include <linux/delay.h>
20 #include <linux/workqueue.h>
21 #include <linux/sched.h>	/* HZ */
22 #include <linux/mutex.h>
23 #include <linux/timekeeping.h>
24 
25 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
26 MODULE_DESCRIPTION("Generic gameport layer");
27 MODULE_LICENSE("GPL");
28 
29 static bool use_ktime = true;
30 module_param(use_ktime, bool, 0400);
31 MODULE_PARM_DESC(use_ktime, "Use ktime for measuring I/O speed");
32 
33 /*
34  * gameport_mutex protects entire gameport subsystem and is taken
35  * every time gameport port or driver registrered or unregistered.
36  */
37 static DEFINE_MUTEX(gameport_mutex);
38 
39 static LIST_HEAD(gameport_list);
40 
41 static struct bus_type gameport_bus;
42 
43 static void gameport_add_port(struct gameport *gameport);
44 static void gameport_attach_driver(struct gameport_driver *drv);
45 static void gameport_reconnect_port(struct gameport *gameport);
46 static void gameport_disconnect_port(struct gameport *gameport);
47 
48 #if defined(__i386__)
49 
50 #include <linux/i8253.h>
51 
52 #define DELTA(x,y)      ((y)-(x)+((y)<(x)?1193182/HZ:0))
53 #define GET_TIME(x)     do { x = get_time_pit(); } while (0)
54 
55 static unsigned int get_time_pit(void)
56 {
57 	unsigned long flags;
58 	unsigned int count;
59 
60 	raw_spin_lock_irqsave(&i8253_lock, flags);
61 	outb_p(0x00, 0x43);
62 	count = inb_p(0x40);
63 	count |= inb_p(0x40) << 8;
64 	raw_spin_unlock_irqrestore(&i8253_lock, flags);
65 
66 	return count;
67 }
68 
69 #endif
70 
71 
72 
73 /*
74  * gameport_measure_speed() measures the gameport i/o speed.
75  */
76 
77 static int gameport_measure_speed(struct gameport *gameport)
78 {
79 	unsigned int i, t, tx;
80 	u64 t1, t2, t3;
81 	unsigned long flags;
82 
83 	if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
84 		return 0;
85 
86 	tx = ~0;
87 
88 	for (i = 0; i < 50; i++) {
89 		local_irq_save(flags);
90 		t1 = ktime_get_ns();
91 		for (t = 0; t < 50; t++)
92 			gameport_read(gameport);
93 		t2 = ktime_get_ns();
94 		t3 = ktime_get_ns();
95 		local_irq_restore(flags);
96 		udelay(i * 10);
97 		t = (t2 - t1) - (t3 - t2);
98 		if (t < tx)
99 			tx = t;
100 	}
101 
102 	gameport_close(gameport);
103 	t = 1000000 * 50;
104 	if (tx)
105 		t /= tx;
106 	return t;
107 }
108 
109 static int old_gameport_measure_speed(struct gameport *gameport)
110 {
111 #if defined(__i386__)
112 
113 	unsigned int i, t, t1, t2, t3, tx;
114 	unsigned long flags;
115 
116 	if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
117 		return 0;
118 
119 	tx = 1 << 30;
120 
121 	for(i = 0; i < 50; i++) {
122 		local_irq_save(flags);
123 		GET_TIME(t1);
124 		for (t = 0; t < 50; t++) gameport_read(gameport);
125 		GET_TIME(t2);
126 		GET_TIME(t3);
127 		local_irq_restore(flags);
128 		udelay(i * 10);
129 		if ((t = DELTA(t2,t1) - DELTA(t3,t2)) < tx) tx = t;
130 	}
131 
132 	gameport_close(gameport);
133 	return 59659 / (tx < 1 ? 1 : tx);
134 
135 #elif defined (__x86_64__)
136 
137 	unsigned int i, t;
138 	unsigned long tx, t1, t2, flags;
139 
140 	if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
141 		return 0;
142 
143 	tx = 1 << 30;
144 
145 	for(i = 0; i < 50; i++) {
146 		local_irq_save(flags);
147 		t1 = rdtsc();
148 		for (t = 0; t < 50; t++) gameport_read(gameport);
149 		t2 = rdtsc();
150 		local_irq_restore(flags);
151 		udelay(i * 10);
152 		if (t2 - t1 < tx) tx = t2 - t1;
153 	}
154 
155 	gameport_close(gameport);
156 	return (this_cpu_read(cpu_info.loops_per_jiffy) *
157 		(unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx);
158 
159 #else
160 
161 	unsigned int j, t = 0;
162 
163 	if (gameport_open(gameport, NULL, GAMEPORT_MODE_RAW))
164 		return 0;
165 
166 	j = jiffies; while (j == jiffies);
167 	j = jiffies; while (j == jiffies) { t++; gameport_read(gameport); }
168 
169 	gameport_close(gameport);
170 	return t * HZ / 1000;
171 
172 #endif
173 }
174 
175 void gameport_start_polling(struct gameport *gameport)
176 {
177 	spin_lock(&gameport->timer_lock);
178 
179 	if (!gameport->poll_cnt++) {
180 		BUG_ON(!gameport->poll_handler);
181 		BUG_ON(!gameport->poll_interval);
182 		mod_timer(&gameport->poll_timer, jiffies + msecs_to_jiffies(gameport->poll_interval));
183 	}
184 
185 	spin_unlock(&gameport->timer_lock);
186 }
187 EXPORT_SYMBOL(gameport_start_polling);
188 
189 void gameport_stop_polling(struct gameport *gameport)
190 {
191 	spin_lock(&gameport->timer_lock);
192 
193 	if (!--gameport->poll_cnt)
194 		del_timer(&gameport->poll_timer);
195 
196 	spin_unlock(&gameport->timer_lock);
197 }
198 EXPORT_SYMBOL(gameport_stop_polling);
199 
200 static void gameport_run_poll_handler(struct timer_list *t)
201 {
202 	struct gameport *gameport = from_timer(gameport, t, poll_timer);
203 
204 	gameport->poll_handler(gameport);
205 	if (gameport->poll_cnt)
206 		mod_timer(&gameport->poll_timer, jiffies + msecs_to_jiffies(gameport->poll_interval));
207 }
208 
209 /*
210  * Basic gameport -> driver core mappings
211  */
212 
213 static int gameport_bind_driver(struct gameport *gameport, struct gameport_driver *drv)
214 {
215 	int error;
216 
217 	gameport->dev.driver = &drv->driver;
218 	if (drv->connect(gameport, drv)) {
219 		gameport->dev.driver = NULL;
220 		return -ENODEV;
221 	}
222 
223 	error = device_bind_driver(&gameport->dev);
224 	if (error) {
225 		dev_warn(&gameport->dev,
226 			 "device_bind_driver() failed for %s (%s) and %s, error: %d\n",
227 			gameport->phys, gameport->name,
228 			drv->description, error);
229 		drv->disconnect(gameport);
230 		gameport->dev.driver = NULL;
231 		return error;
232 	}
233 
234 	return 0;
235 }
236 
237 static void gameport_find_driver(struct gameport *gameport)
238 {
239 	int error;
240 
241 	error = device_attach(&gameport->dev);
242 	if (error < 0)
243 		dev_warn(&gameport->dev,
244 			 "device_attach() failed for %s (%s), error: %d\n",
245 			 gameport->phys, gameport->name, error);
246 }
247 
248 
249 /*
250  * Gameport event processing.
251  */
252 
253 enum gameport_event_type {
254 	GAMEPORT_REGISTER_PORT,
255 	GAMEPORT_ATTACH_DRIVER,
256 };
257 
258 struct gameport_event {
259 	enum gameport_event_type type;
260 	void *object;
261 	struct module *owner;
262 	struct list_head node;
263 };
264 
265 static DEFINE_SPINLOCK(gameport_event_lock);	/* protects gameport_event_list */
266 static LIST_HEAD(gameport_event_list);
267 
268 static struct gameport_event *gameport_get_event(void)
269 {
270 	struct gameport_event *event = NULL;
271 	unsigned long flags;
272 
273 	spin_lock_irqsave(&gameport_event_lock, flags);
274 
275 	if (!list_empty(&gameport_event_list)) {
276 		event = list_first_entry(&gameport_event_list,
277 					 struct gameport_event, node);
278 		list_del_init(&event->node);
279 	}
280 
281 	spin_unlock_irqrestore(&gameport_event_lock, flags);
282 	return event;
283 }
284 
285 static void gameport_free_event(struct gameport_event *event)
286 {
287 	module_put(event->owner);
288 	kfree(event);
289 }
290 
291 static void gameport_remove_duplicate_events(struct gameport_event *event)
292 {
293 	struct gameport_event *e, *next;
294 	unsigned long flags;
295 
296 	spin_lock_irqsave(&gameport_event_lock, flags);
297 
298 	list_for_each_entry_safe(e, next, &gameport_event_list, node) {
299 		if (event->object == e->object) {
300 			/*
301 			 * If this event is of different type we should not
302 			 * look further - we only suppress duplicate events
303 			 * that were sent back-to-back.
304 			 */
305 			if (event->type != e->type)
306 				break;
307 
308 			list_del_init(&e->node);
309 			gameport_free_event(e);
310 		}
311 	}
312 
313 	spin_unlock_irqrestore(&gameport_event_lock, flags);
314 }
315 
316 
317 static void gameport_handle_events(struct work_struct *work)
318 {
319 	struct gameport_event *event;
320 
321 	mutex_lock(&gameport_mutex);
322 
323 	/*
324 	 * Note that we handle only one event here to give swsusp
325 	 * a chance to freeze kgameportd thread. Gameport events
326 	 * should be pretty rare so we are not concerned about
327 	 * taking performance hit.
328 	 */
329 	if ((event = gameport_get_event())) {
330 
331 		switch (event->type) {
332 
333 		case GAMEPORT_REGISTER_PORT:
334 			gameport_add_port(event->object);
335 			break;
336 
337 		case GAMEPORT_ATTACH_DRIVER:
338 			gameport_attach_driver(event->object);
339 			break;
340 		}
341 
342 		gameport_remove_duplicate_events(event);
343 		gameport_free_event(event);
344 	}
345 
346 	mutex_unlock(&gameport_mutex);
347 }
348 
349 static DECLARE_WORK(gameport_event_work, gameport_handle_events);
350 
351 static int gameport_queue_event(void *object, struct module *owner,
352 				enum gameport_event_type event_type)
353 {
354 	unsigned long flags;
355 	struct gameport_event *event;
356 	int retval = 0;
357 
358 	spin_lock_irqsave(&gameport_event_lock, flags);
359 
360 	/*
361 	 * Scan event list for the other events for the same gameport port,
362 	 * starting with the most recent one. If event is the same we
363 	 * do not need add new one. If event is of different type we
364 	 * need to add this event and should not look further because
365 	 * we need to preserve sequence of distinct events.
366 	 */
367 	list_for_each_entry_reverse(event, &gameport_event_list, node) {
368 		if (event->object == object) {
369 			if (event->type == event_type)
370 				goto out;
371 			break;
372 		}
373 	}
374 
375 	event = kmalloc(sizeof(struct gameport_event), GFP_ATOMIC);
376 	if (!event) {
377 		pr_err("Not enough memory to queue event %d\n", event_type);
378 		retval = -ENOMEM;
379 		goto out;
380 	}
381 
382 	if (!try_module_get(owner)) {
383 		pr_warn("Can't get module reference, dropping event %d\n",
384 			event_type);
385 		kfree(event);
386 		retval = -EINVAL;
387 		goto out;
388 	}
389 
390 	event->type = event_type;
391 	event->object = object;
392 	event->owner = owner;
393 
394 	list_add_tail(&event->node, &gameport_event_list);
395 	queue_work(system_long_wq, &gameport_event_work);
396 
397 out:
398 	spin_unlock_irqrestore(&gameport_event_lock, flags);
399 	return retval;
400 }
401 
402 /*
403  * Remove all events that have been submitted for a given object,
404  * be it a gameport port or a driver.
405  */
406 static void gameport_remove_pending_events(void *object)
407 {
408 	struct gameport_event *event, *next;
409 	unsigned long flags;
410 
411 	spin_lock_irqsave(&gameport_event_lock, flags);
412 
413 	list_for_each_entry_safe(event, next, &gameport_event_list, node) {
414 		if (event->object == object) {
415 			list_del_init(&event->node);
416 			gameport_free_event(event);
417 		}
418 	}
419 
420 	spin_unlock_irqrestore(&gameport_event_lock, flags);
421 }
422 
423 /*
424  * Destroy child gameport port (if any) that has not been fully registered yet.
425  *
426  * Note that we rely on the fact that port can have only one child and therefore
427  * only one child registration request can be pending. Additionally, children
428  * are registered by driver's connect() handler so there can't be a grandchild
429  * pending registration together with a child.
430  */
431 static struct gameport *gameport_get_pending_child(struct gameport *parent)
432 {
433 	struct gameport_event *event;
434 	struct gameport *gameport, *child = NULL;
435 	unsigned long flags;
436 
437 	spin_lock_irqsave(&gameport_event_lock, flags);
438 
439 	list_for_each_entry(event, &gameport_event_list, node) {
440 		if (event->type == GAMEPORT_REGISTER_PORT) {
441 			gameport = event->object;
442 			if (gameport->parent == parent) {
443 				child = gameport;
444 				break;
445 			}
446 		}
447 	}
448 
449 	spin_unlock_irqrestore(&gameport_event_lock, flags);
450 	return child;
451 }
452 
453 /*
454  * Gameport port operations
455  */
456 
457 static ssize_t gameport_description_show(struct device *dev, struct device_attribute *attr, char *buf)
458 {
459 	struct gameport *gameport = to_gameport_port(dev);
460 
461 	return sprintf(buf, "%s\n", gameport->name);
462 }
463 static DEVICE_ATTR(description, S_IRUGO, gameport_description_show, NULL);
464 
465 static ssize_t drvctl_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
466 {
467 	struct gameport *gameport = to_gameport_port(dev);
468 	struct device_driver *drv;
469 	int error;
470 
471 	error = mutex_lock_interruptible(&gameport_mutex);
472 	if (error)
473 		return error;
474 
475 	if (!strncmp(buf, "none", count)) {
476 		gameport_disconnect_port(gameport);
477 	} else if (!strncmp(buf, "reconnect", count)) {
478 		gameport_reconnect_port(gameport);
479 	} else if (!strncmp(buf, "rescan", count)) {
480 		gameport_disconnect_port(gameport);
481 		gameport_find_driver(gameport);
482 	} else if ((drv = driver_find(buf, &gameport_bus)) != NULL) {
483 		gameport_disconnect_port(gameport);
484 		error = gameport_bind_driver(gameport, to_gameport_driver(drv));
485 	} else {
486 		error = -EINVAL;
487 	}
488 
489 	mutex_unlock(&gameport_mutex);
490 
491 	return error ? error : count;
492 }
493 static DEVICE_ATTR_WO(drvctl);
494 
495 static struct attribute *gameport_device_attrs[] = {
496 	&dev_attr_description.attr,
497 	&dev_attr_drvctl.attr,
498 	NULL,
499 };
500 ATTRIBUTE_GROUPS(gameport_device);
501 
502 static void gameport_release_port(struct device *dev)
503 {
504 	struct gameport *gameport = to_gameport_port(dev);
505 
506 	kfree(gameport);
507 	module_put(THIS_MODULE);
508 }
509 
510 void gameport_set_phys(struct gameport *gameport, const char *fmt, ...)
511 {
512 	va_list args;
513 
514 	va_start(args, fmt);
515 	vsnprintf(gameport->phys, sizeof(gameport->phys), fmt, args);
516 	va_end(args);
517 }
518 EXPORT_SYMBOL(gameport_set_phys);
519 
520 static void gameport_default_trigger(struct gameport *gameport)
521 {
522 #ifdef CONFIG_HAS_IOPORT
523 	outb(0xff, gameport->io);
524 #endif
525 }
526 
527 static unsigned char gameport_default_read(struct gameport *gameport)
528 {
529 #ifdef CONFIG_HAS_IOPORT
530 	return inb(gameport->io);
531 #else
532 	return 0xff;
533 #endif
534 }
535 
536 static void gameport_setup_default_handlers(struct gameport *gameport)
537 {
538 	if ((!gameport->trigger || !gameport->read) &&
539 	    !IS_ENABLED(CONFIG_HAS_IOPORT))
540 		dev_err(&gameport->dev,
541 			"I/O port access is required for %s (%s) but is not available\n",
542 			gameport->phys, gameport->name);
543 
544 	if (!gameport->trigger)
545 		gameport->trigger = gameport_default_trigger;
546 	if (!gameport->read)
547 		gameport->read = gameport_default_read;
548 }
549 
550 /*
551  * Prepare gameport port for registration.
552  */
553 static void gameport_init_port(struct gameport *gameport)
554 {
555 	static atomic_t gameport_no = ATOMIC_INIT(-1);
556 
557 	__module_get(THIS_MODULE);
558 
559 	mutex_init(&gameport->drv_mutex);
560 	device_initialize(&gameport->dev);
561 	dev_set_name(&gameport->dev, "gameport%lu",
562 			(unsigned long)atomic_inc_return(&gameport_no));
563 	gameport->dev.bus = &gameport_bus;
564 	gameport->dev.release = gameport_release_port;
565 	if (gameport->parent)
566 		gameport->dev.parent = &gameport->parent->dev;
567 
568 	gameport_setup_default_handlers(gameport);
569 	INIT_LIST_HEAD(&gameport->node);
570 	spin_lock_init(&gameport->timer_lock);
571 	timer_setup(&gameport->poll_timer, gameport_run_poll_handler, 0);
572 }
573 
574 /*
575  * Complete gameport port registration.
576  * Driver core will attempt to find appropriate driver for the port.
577  */
578 static void gameport_add_port(struct gameport *gameport)
579 {
580 	int error;
581 
582 	if (gameport->parent)
583 		gameport->parent->child = gameport;
584 
585 	gameport->speed = use_ktime ?
586 		gameport_measure_speed(gameport) :
587 		old_gameport_measure_speed(gameport);
588 
589 	list_add_tail(&gameport->node, &gameport_list);
590 
591 	if (gameport->io)
592 		dev_info(&gameport->dev, "%s is %s, io %#x, speed %dkHz\n",
593 			 gameport->name, gameport->phys, gameport->io, gameport->speed);
594 	else
595 		dev_info(&gameport->dev, "%s is %s, speed %dkHz\n",
596 			gameport->name, gameport->phys, gameport->speed);
597 
598 	error = device_add(&gameport->dev);
599 	if (error)
600 		dev_err(&gameport->dev,
601 			"device_add() failed for %s (%s), error: %d\n",
602 			gameport->phys, gameport->name, error);
603 }
604 
605 /*
606  * gameport_destroy_port() completes deregistration process and removes
607  * port from the system
608  */
609 static void gameport_destroy_port(struct gameport *gameport)
610 {
611 	struct gameport *child;
612 
613 	child = gameport_get_pending_child(gameport);
614 	if (child) {
615 		gameport_remove_pending_events(child);
616 		put_device(&child->dev);
617 	}
618 
619 	if (gameport->parent) {
620 		gameport->parent->child = NULL;
621 		gameport->parent = NULL;
622 	}
623 
624 	if (device_is_registered(&gameport->dev))
625 		device_del(&gameport->dev);
626 
627 	list_del_init(&gameport->node);
628 
629 	gameport_remove_pending_events(gameport);
630 	put_device(&gameport->dev);
631 }
632 
633 /*
634  * Reconnect gameport port and all its children (re-initialize attached devices)
635  */
636 static void gameport_reconnect_port(struct gameport *gameport)
637 {
638 	do {
639 		if (!gameport->drv || !gameport->drv->reconnect || gameport->drv->reconnect(gameport)) {
640 			gameport_disconnect_port(gameport);
641 			gameport_find_driver(gameport);
642 			/* Ok, old children are now gone, we are done */
643 			break;
644 		}
645 		gameport = gameport->child;
646 	} while (gameport);
647 }
648 
649 /*
650  * gameport_disconnect_port() unbinds a port from its driver. As a side effect
651  * all child ports are unbound and destroyed.
652  */
653 static void gameport_disconnect_port(struct gameport *gameport)
654 {
655 	struct gameport *s, *parent;
656 
657 	if (gameport->child) {
658 		/*
659 		 * Children ports should be disconnected and destroyed
660 		 * first, staring with the leaf one, since we don't want
661 		 * to do recursion
662 		 */
663 		for (s = gameport; s->child; s = s->child)
664 			/* empty */;
665 
666 		do {
667 			parent = s->parent;
668 
669 			device_release_driver(&s->dev);
670 			gameport_destroy_port(s);
671 		} while ((s = parent) != gameport);
672 	}
673 
674 	/*
675 	 * Ok, no children left, now disconnect this port
676 	 */
677 	device_release_driver(&gameport->dev);
678 }
679 
680 /*
681  * Submits register request to kgameportd for subsequent execution.
682  * Note that port registration is always asynchronous.
683  */
684 void __gameport_register_port(struct gameport *gameport, struct module *owner)
685 {
686 	gameport_init_port(gameport);
687 	gameport_queue_event(gameport, owner, GAMEPORT_REGISTER_PORT);
688 }
689 EXPORT_SYMBOL(__gameport_register_port);
690 
691 /*
692  * Synchronously unregisters gameport port.
693  */
694 void gameport_unregister_port(struct gameport *gameport)
695 {
696 	mutex_lock(&gameport_mutex);
697 	gameport_disconnect_port(gameport);
698 	gameport_destroy_port(gameport);
699 	mutex_unlock(&gameport_mutex);
700 }
701 EXPORT_SYMBOL(gameport_unregister_port);
702 
703 
704 /*
705  * Gameport driver operations
706  */
707 
708 static ssize_t description_show(struct device_driver *drv, char *buf)
709 {
710 	struct gameport_driver *driver = to_gameport_driver(drv);
711 	return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
712 }
713 static DRIVER_ATTR_RO(description);
714 
715 static struct attribute *gameport_driver_attrs[] = {
716 	&driver_attr_description.attr,
717 	NULL
718 };
719 ATTRIBUTE_GROUPS(gameport_driver);
720 
721 static int gameport_driver_probe(struct device *dev)
722 {
723 	struct gameport *gameport = to_gameport_port(dev);
724 	struct gameport_driver *drv = to_gameport_driver(dev->driver);
725 
726 	drv->connect(gameport, drv);
727 	return gameport->drv ? 0 : -ENODEV;
728 }
729 
730 static void gameport_driver_remove(struct device *dev)
731 {
732 	struct gameport *gameport = to_gameport_port(dev);
733 	struct gameport_driver *drv = to_gameport_driver(dev->driver);
734 
735 	drv->disconnect(gameport);
736 }
737 
738 static void gameport_attach_driver(struct gameport_driver *drv)
739 {
740 	int error;
741 
742 	error = driver_attach(&drv->driver);
743 	if (error)
744 		pr_err("driver_attach() failed for %s, error: %d\n",
745 			drv->driver.name, error);
746 }
747 
748 int __gameport_register_driver(struct gameport_driver *drv, struct module *owner,
749 				const char *mod_name)
750 {
751 	int error;
752 
753 	drv->driver.bus = &gameport_bus;
754 	drv->driver.owner = owner;
755 	drv->driver.mod_name = mod_name;
756 
757 	/*
758 	 * Temporarily disable automatic binding because probing
759 	 * takes long time and we are better off doing it in kgameportd
760 	 */
761 	drv->ignore = true;
762 
763 	error = driver_register(&drv->driver);
764 	if (error) {
765 		pr_err("driver_register() failed for %s, error: %d\n",
766 			drv->driver.name, error);
767 		return error;
768 	}
769 
770 	/*
771 	 * Reset ignore flag and let kgameportd bind the driver to free ports
772 	 */
773 	drv->ignore = false;
774 	error = gameport_queue_event(drv, NULL, GAMEPORT_ATTACH_DRIVER);
775 	if (error) {
776 		driver_unregister(&drv->driver);
777 		return error;
778 	}
779 
780 	return 0;
781 }
782 EXPORT_SYMBOL(__gameport_register_driver);
783 
784 void gameport_unregister_driver(struct gameport_driver *drv)
785 {
786 	struct gameport *gameport;
787 
788 	mutex_lock(&gameport_mutex);
789 
790 	drv->ignore = true;	/* so gameport_find_driver ignores it */
791 	gameport_remove_pending_events(drv);
792 
793 start_over:
794 	list_for_each_entry(gameport, &gameport_list, node) {
795 		if (gameport->drv == drv) {
796 			gameport_disconnect_port(gameport);
797 			gameport_find_driver(gameport);
798 			/* we could've deleted some ports, restart */
799 			goto start_over;
800 		}
801 	}
802 
803 	driver_unregister(&drv->driver);
804 
805 	mutex_unlock(&gameport_mutex);
806 }
807 EXPORT_SYMBOL(gameport_unregister_driver);
808 
809 static int gameport_bus_match(struct device *dev, struct device_driver *drv)
810 {
811 	struct gameport_driver *gameport_drv = to_gameport_driver(drv);
812 
813 	return !gameport_drv->ignore;
814 }
815 
816 static struct bus_type gameport_bus = {
817 	.name		= "gameport",
818 	.dev_groups	= gameport_device_groups,
819 	.drv_groups	= gameport_driver_groups,
820 	.match		= gameport_bus_match,
821 	.probe		= gameport_driver_probe,
822 	.remove		= gameport_driver_remove,
823 };
824 
825 static void gameport_set_drv(struct gameport *gameport, struct gameport_driver *drv)
826 {
827 	mutex_lock(&gameport->drv_mutex);
828 	gameport->drv = drv;
829 	mutex_unlock(&gameport->drv_mutex);
830 }
831 
832 int gameport_open(struct gameport *gameport, struct gameport_driver *drv, int mode)
833 {
834 	if (gameport->open) {
835 		if (gameport->open(gameport, mode)) {
836 			return -1;
837 		}
838 	} else {
839 		if (mode != GAMEPORT_MODE_RAW)
840 			return -1;
841 	}
842 
843 	gameport_set_drv(gameport, drv);
844 	return 0;
845 }
846 EXPORT_SYMBOL(gameport_open);
847 
848 void gameport_close(struct gameport *gameport)
849 {
850 	del_timer_sync(&gameport->poll_timer);
851 	gameport->poll_handler = NULL;
852 	gameport->poll_interval = 0;
853 	gameport_set_drv(gameport, NULL);
854 	if (gameport->close)
855 		gameport->close(gameport);
856 }
857 EXPORT_SYMBOL(gameport_close);
858 
859 static int __init gameport_init(void)
860 {
861 	int error;
862 
863 	error = bus_register(&gameport_bus);
864 	if (error) {
865 		pr_err("failed to register gameport bus, error: %d\n", error);
866 		return error;
867 	}
868 
869 
870 	return 0;
871 }
872 
873 static void __exit gameport_exit(void)
874 {
875 	bus_unregister(&gameport_bus);
876 
877 	/*
878 	 * There should not be any outstanding events but work may
879 	 * still be scheduled so simply cancel it.
880 	 */
881 	cancel_work_sync(&gameport_event_work);
882 }
883 
884 subsys_initcall(gameport_init);
885 module_exit(gameport_exit);
886