1 /* This file contains the device independent input driver interface. */
2 /*
3 * Changes:
4 * Sep 22, 2013 created (D.C. van Moolenbroek)
5 */
6
7 #include <minix/drivers.h>
8 #include <minix/inputdriver.h>
9 #include <minix/ds.h>
10
11 static endpoint_t input_endpt = NONE;
12 static int kbd_id = INVALID_INPUT_ID;
13 static int mouse_id = INVALID_INPUT_ID;
14
15 static int running;
16
17 /*
18 * Announce that we are up after a fresh start or restart.
19 */
20 void
inputdriver_announce(unsigned int type)21 inputdriver_announce(unsigned int type)
22 {
23 const char *driver_prefix = "drv.inp.";
24 char key[DS_MAX_KEYLEN];
25 char label[DS_MAX_KEYLEN];
26 int r;
27
28 /* Publish a driver up event. */
29 if ((r = ds_retrieve_label_name(label, sef_self())) != OK)
30 panic("libinputdriver: unable to retrieve own label: %d", r);
31
32 snprintf(key, sizeof(key), "%s%s", driver_prefix, label);
33 if ((r = ds_publish_u32(key, type, DSF_OVERWRITE)) != OK)
34 panic("libinputdriver: unable to publish up event: %d", r);
35
36 /* Now we wait for the input server to contact us. */
37 }
38
39 /*
40 * Send an event to the input server.
41 */
42 void
inputdriver_send_event(int mouse,unsigned short page,unsigned short code,int value,int flags)43 inputdriver_send_event(int mouse, unsigned short page, unsigned short code,
44 int value, int flags)
45 {
46 message m;
47 int id;
48
49 if (input_endpt == NONE)
50 return;
51
52 id = mouse ? mouse_id : kbd_id;
53 if (id == INVALID_INPUT_ID)
54 return;
55
56 memset(&m, 0, sizeof(m));
57
58 m.m_type = INPUT_EVENT;
59 m.m_linputdriver_input_event.id = id;
60 m.m_linputdriver_input_event.page = page;
61 m.m_linputdriver_input_event.code = code;
62 m.m_linputdriver_input_event.value = value;
63 m.m_linputdriver_input_event.flags = flags;
64
65 /*
66 * Use a blocking send call, for two reasons. First, this avoids the
67 * situation that we ever end up queuing too many asynchronous messages
68 * to the input server. Second, it allows us to detect trivially if
69 * the input server has crashed, in which case we should stop sending
70 * more messages to it.
71 */
72 if (ipc_send(input_endpt, &m) != OK)
73 input_endpt = NONE;
74 }
75
76 /*
77 * The input server requests that we configure the driver. This request should
78 * be sent to us once, although it may be sent multiple times if the input
79 * server crashes and recovers. The configuration consists of device IDs for
80 * use in keyboard and/or mouse events, one per each device type.
81 */
82 static void
do_conf(message * m_ptr)83 do_conf(message *m_ptr)
84 {
85 endpoint_t ep;
86 int r;
87
88 /* Make sure that the sender is actually the input server. */
89 if ((r = ds_retrieve_label_endpt("input", &ep)) != OK) {
90 printf("libinputdriver: unable to get input endpoint (%d)\n",
91 r);
92
93 return; /* ignore message */
94 }
95
96 if (ep != m_ptr->m_source) {
97 printf("libinputdriver: ignoring CONF request from %u\n",
98 m_ptr->m_source);
99
100 return;
101 }
102
103 /* Save the new state. */
104 input_endpt = m_ptr->m_source;
105 kbd_id = m_ptr->m_input_linputdriver_input_conf.kbd_id;
106 mouse_id = m_ptr->m_input_linputdriver_input_conf.mouse_id;
107
108 /* If the input server is "full" there's nothing for us to do. */
109 if (kbd_id == INVALID_INPUT_ID && mouse_id == INVALID_INPUT_ID)
110 printf("libinputdriver: no IDs given, driver disabled\n");
111 }
112
113 /*
114 * The input server is telling us to change the LEDs to a particular mask.
115 * For now this is for keyboards only, so no device type is provided.
116 * This approach was chosen over sending toggle events for the individual LEDs
117 * for convenience reasons only.
118 */
119 static void
do_setleds(struct inputdriver * idp,message * m_ptr)120 do_setleds(struct inputdriver *idp, message *m_ptr)
121 {
122 unsigned int mask;
123
124 if (m_ptr->m_source != input_endpt) {
125 printf("libinputdriver: ignoring SETLEDS request from %u\n",
126 m_ptr->m_source);
127
128 return;
129 }
130
131 mask = m_ptr->m_input_linputdriver_setleds.led_mask;
132
133 if (idp->idr_leds)
134 idp->idr_leds(mask);
135 }
136
137 /*
138 * Call the appropriate driver function, based on the type of message.
139 * All messages in the input protocol are one-way, so we never send a reply.
140 */
141 void
inputdriver_process(struct inputdriver * idp,message * m_ptr,int ipc_status)142 inputdriver_process(struct inputdriver *idp, message *m_ptr, int ipc_status)
143 {
144 /* Check for notifications first. */
145 if (is_ipc_notify(ipc_status)) {
146 switch (_ENDPOINT_P(m_ptr->m_source)) {
147 case HARDWARE:
148 if (idp->idr_intr)
149 idp->idr_intr(m_ptr->m_notify.interrupts);
150 break;
151
152 case CLOCK:
153 if (idp->idr_alarm)
154 idp->idr_alarm(m_ptr->m_notify.timestamp);
155 break;
156
157 default:
158 if (idp->idr_other)
159 idp->idr_other(m_ptr, ipc_status);
160 }
161
162 return;
163 }
164
165 switch (m_ptr->m_type) {
166 case INPUT_CONF: do_conf(m_ptr); break;
167 case INPUT_SETLEDS: do_setleds(idp, m_ptr); break;
168 default:
169 if (idp->idr_other)
170 idp->idr_other(m_ptr, ipc_status);
171 }
172 }
173
174 /*
175 * Break out of the main loop after finishing the current request.
176 */
177 void
inputdriver_terminate(void)178 inputdriver_terminate(void)
179 {
180 running = FALSE;
181
182 sef_cancel();
183 }
184
185 /*
186 * Main program of any input driver task.
187 */
188 void
inputdriver_task(struct inputdriver * idp)189 inputdriver_task(struct inputdriver *idp)
190 {
191 message m;
192 int r, ipc_status;
193
194 running = TRUE;
195
196 while (running) {
197 if ((r = sef_receive_status(ANY, &m, &ipc_status)) != OK) {
198 if (r == EINTR && !running)
199 break;
200
201 panic("libinputdriver: receive failed: %d", r);
202 }
203
204 inputdriver_process(idp, &m, ipc_status);
205 }
206 }
207