1d2912cb1SThomas Gleixner /* SPDX-License-Identifier: GPL-2.0-only */
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * Copyright (C) 1999-2002 Vojtech Pavlik
41da177e4SLinus Torvalds */
5607ca46eSDavid Howells #ifndef _SERIO_H
6607ca46eSDavid Howells #define _SERIO_H
71da177e4SLinus Torvalds
81da177e4SLinus Torvalds
97e044e05SDmitry Torokhov #include <linux/types.h>
101da177e4SLinus Torvalds #include <linux/interrupt.h>
111da177e4SLinus Torvalds #include <linux/list.h>
121da177e4SLinus Torvalds #include <linux/spinlock.h>
13c4e32e9fSArjan van de Ven #include <linux/mutex.h>
141da177e4SLinus Torvalds #include <linux/device.h>
151da177e4SLinus Torvalds #include <linux/mod_devicetable.h>
16607ca46eSDavid Howells #include <uapi/linux/serio.h>
171da177e4SLinus Torvalds
18e1443d28SStephen Chandler Paul extern struct bus_type serio_bus;
19e1443d28SStephen Chandler Paul
201da177e4SLinus Torvalds struct serio {
211da177e4SLinus Torvalds void *port_data;
221da177e4SLinus Torvalds
231da177e4SLinus Torvalds char name[32];
241da177e4SLinus Torvalds char phys[32];
250456c66fSHans de Goede char firmware_id[128];
261da177e4SLinus Torvalds
277e044e05SDmitry Torokhov bool manual_bind;
281da177e4SLinus Torvalds
291da177e4SLinus Torvalds struct serio_device_id id;
301da177e4SLinus Torvalds
3140974618SDmitry Torokhov /* Protects critical sections from port's interrupt handler */
3240974618SDmitry Torokhov spinlock_t lock;
331da177e4SLinus Torvalds
341da177e4SLinus Torvalds int (*write)(struct serio *, unsigned char);
351da177e4SLinus Torvalds int (*open)(struct serio *);
361da177e4SLinus Torvalds void (*close)(struct serio *);
371da177e4SLinus Torvalds int (*start)(struct serio *);
381da177e4SLinus Torvalds void (*stop)(struct serio *);
391da177e4SLinus Torvalds
4009822582SDmitry Eremin-Solenikov struct serio *parent;
4140974618SDmitry Torokhov /* Entry in parent->children list */
4240974618SDmitry Torokhov struct list_head child_node;
4309822582SDmitry Eremin-Solenikov struct list_head children;
4440974618SDmitry Torokhov /* Level of nesting in serio hierarchy */
4540974618SDmitry Torokhov unsigned int depth;
461da177e4SLinus Torvalds
4740974618SDmitry Torokhov /*
4840974618SDmitry Torokhov * serio->drv is accessed from interrupt handlers; when modifying
4940974618SDmitry Torokhov * caller should acquire serio->drv_mutex and serio->lock.
5040974618SDmitry Torokhov */
5140974618SDmitry Torokhov struct serio_driver *drv;
5240974618SDmitry Torokhov /* Protects serio->drv so attributes can pin current driver */
5340974618SDmitry Torokhov struct mutex drv_mutex;
541da177e4SLinus Torvalds
551da177e4SLinus Torvalds struct device dev;
561da177e4SLinus Torvalds
571da177e4SLinus Torvalds struct list_head node;
5840974618SDmitry Torokhov
5940974618SDmitry Torokhov /*
6040974618SDmitry Torokhov * For use by PS/2 layer when several ports share hardware and
6140974618SDmitry Torokhov * may get indigestion when exposed to concurrent access (i8042).
6240974618SDmitry Torokhov */
6340974618SDmitry Torokhov struct mutex *ps2_cmd_mutex;
641da177e4SLinus Torvalds };
651da177e4SLinus Torvalds #define to_serio_port(d) container_of(d, struct serio, dev)
661da177e4SLinus Torvalds
671da177e4SLinus Torvalds struct serio_driver {
68ceee4271SDmitry Torokhov const char *description;
691da177e4SLinus Torvalds
70ceee4271SDmitry Torokhov const struct serio_device_id *id_table;
717e044e05SDmitry Torokhov bool manual_bind;
721da177e4SLinus Torvalds
731da177e4SLinus Torvalds void (*write_wakeup)(struct serio *);
747d12e780SDavid Howells irqreturn_t (*interrupt)(struct serio *, unsigned char, unsigned int);
751da177e4SLinus Torvalds int (*connect)(struct serio *, struct serio_driver *drv);
761da177e4SLinus Torvalds int (*reconnect)(struct serio *);
775ea13206SDmitry Torokhov int (*fast_reconnect)(struct serio *);
781da177e4SLinus Torvalds void (*disconnect)(struct serio *);
791da177e4SLinus Torvalds void (*cleanup)(struct serio *);
801da177e4SLinus Torvalds
811da177e4SLinus Torvalds struct device_driver driver;
821da177e4SLinus Torvalds };
831da177e4SLinus Torvalds #define to_serio_driver(d) container_of(d, struct serio_driver, driver)
841da177e4SLinus Torvalds
851da177e4SLinus Torvalds int serio_open(struct serio *serio, struct serio_driver *drv);
861da177e4SLinus Torvalds void serio_close(struct serio *serio);
871da177e4SLinus Torvalds void serio_rescan(struct serio *serio);
881da177e4SLinus Torvalds void serio_reconnect(struct serio *serio);
897d12e780SDavid Howells irqreturn_t serio_interrupt(struct serio *serio, unsigned char data, unsigned int flags);
901da177e4SLinus Torvalds
911da177e4SLinus Torvalds void __serio_register_port(struct serio *serio, struct module *owner);
92eb5589a8SPaul Gortmaker
93eb5589a8SPaul Gortmaker /* use a define to avoid include chaining to get THIS_MODULE */
94eb5589a8SPaul Gortmaker #define serio_register_port(serio) \
95eb5589a8SPaul Gortmaker __serio_register_port(serio, THIS_MODULE)
961da177e4SLinus Torvalds
971da177e4SLinus Torvalds void serio_unregister_port(struct serio *serio);
98dbf4ccd6SDmitry Torokhov void serio_unregister_child_port(struct serio *serio);
991da177e4SLinus Torvalds
100eb5589a8SPaul Gortmaker int __must_check __serio_register_driver(struct serio_driver *drv,
101eb5589a8SPaul Gortmaker struct module *owner, const char *mod_name);
102eb5589a8SPaul Gortmaker
103eb5589a8SPaul Gortmaker /* use a define to avoid include chaining to get THIS_MODULE & friends */
104eb5589a8SPaul Gortmaker #define serio_register_driver(drv) \
105eb5589a8SPaul Gortmaker __serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)
106eb5589a8SPaul Gortmaker
1071da177e4SLinus Torvalds void serio_unregister_driver(struct serio_driver *drv);
1081da177e4SLinus Torvalds
109fa7f86d1SAxel Lin /**
110fa7f86d1SAxel Lin * module_serio_driver() - Helper macro for registering a serio driver
111fa7f86d1SAxel Lin * @__serio_driver: serio_driver struct
112fa7f86d1SAxel Lin *
113fa7f86d1SAxel Lin * Helper macro for serio drivers which do not do anything special in
114fa7f86d1SAxel Lin * module init/exit. This eliminates a lot of boilerplate. Each module
115fa7f86d1SAxel Lin * may only use this macro once, and calling it replaces module_init()
116fa7f86d1SAxel Lin * and module_exit().
117fa7f86d1SAxel Lin */
118fa7f86d1SAxel Lin #define module_serio_driver(__serio_driver) \
119fa7f86d1SAxel Lin module_driver(__serio_driver, serio_register_driver, \
120fa7f86d1SAxel Lin serio_unregister_driver)
121fa7f86d1SAxel Lin
serio_write(struct serio * serio,unsigned char data)1221da177e4SLinus Torvalds static inline int serio_write(struct serio *serio, unsigned char data)
1231da177e4SLinus Torvalds {
124*7d3370e5SDmitry Torokhov if (serio->write)
1251da177e4SLinus Torvalds return serio->write(serio, data);
126*7d3370e5SDmitry Torokhov else
127*7d3370e5SDmitry Torokhov return -1;
1281da177e4SLinus Torvalds }
1291da177e4SLinus Torvalds
serio_drv_write_wakeup(struct serio * serio)1301da177e4SLinus Torvalds static inline void serio_drv_write_wakeup(struct serio *serio)
1311da177e4SLinus Torvalds {
1321da177e4SLinus Torvalds if (serio->drv && serio->drv->write_wakeup)
1331da177e4SLinus Torvalds serio->drv->write_wakeup(serio);
1341da177e4SLinus Torvalds }
1351da177e4SLinus Torvalds
1361da177e4SLinus Torvalds /*
1370b28002fSAkinobu Mita * Use the following functions to manipulate serio's per-port
1381da177e4SLinus Torvalds * driver-specific data.
1391da177e4SLinus Torvalds */
serio_get_drvdata(struct serio * serio)1401da177e4SLinus Torvalds static inline void *serio_get_drvdata(struct serio *serio)
1411da177e4SLinus Torvalds {
1421da177e4SLinus Torvalds return dev_get_drvdata(&serio->dev);
1431da177e4SLinus Torvalds }
1441da177e4SLinus Torvalds
serio_set_drvdata(struct serio * serio,void * data)1451da177e4SLinus Torvalds static inline void serio_set_drvdata(struct serio *serio, void *data)
1461da177e4SLinus Torvalds {
1471da177e4SLinus Torvalds dev_set_drvdata(&serio->dev, data);
1481da177e4SLinus Torvalds }
1491da177e4SLinus Torvalds
1501da177e4SLinus Torvalds /*
1510b28002fSAkinobu Mita * Use the following functions to protect critical sections in
1521da177e4SLinus Torvalds * driver code from port's interrupt handler
1531da177e4SLinus Torvalds */
serio_pause_rx(struct serio * serio)1541da177e4SLinus Torvalds static inline void serio_pause_rx(struct serio *serio)
1551da177e4SLinus Torvalds {
1561da177e4SLinus Torvalds spin_lock_irq(&serio->lock);
1571da177e4SLinus Torvalds }
1581da177e4SLinus Torvalds
serio_continue_rx(struct serio * serio)1591da177e4SLinus Torvalds static inline void serio_continue_rx(struct serio *serio)
1601da177e4SLinus Torvalds {
1611da177e4SLinus Torvalds spin_unlock_irq(&serio->lock);
1621da177e4SLinus Torvalds }
1631da177e4SLinus Torvalds
1641da177e4SLinus Torvalds #endif
165