source: mainline/uspace/drv/char/i8042/i8042.c@ f2a92b0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since f2a92b0 was cfb79747, checked in by Jakub Jermar <jakub@…>, 13 years ago

Merge mainline changes.
  • Property mode set to 100644
File size: 10.3 KB
Line 
1/*
2 * Copyright (c) 2001-2004 Jakub Jermar
3 * Copyright (c) 2006 Josef Cejka
4 * Copyright (c) 2009 Jiri Svoboda
5 * Copyright (c) 2011 Jan Vesely
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * - Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * - Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * - The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/** @addtogroup kbd_port
33 * @ingroup kbd
34 * @{
35 */
36
37/** @file
38 * @brief i8042 PS/2 port driver.
39 */
40
41#include <devman.h>
42#include <device/hw_res.h>
43#include <ddi.h>
44#include <libarch/ddi.h>
45#include <errno.h>
46#include <str_error.h>
47#include <inttypes.h>
48#include <ddf/log.h>
49#include <ddf/interrupt.h>
50#include "i8042.h"
51
52/* Interesting bits for status register */
53#define i8042_OUTPUT_FULL 0x01
54#define i8042_INPUT_FULL 0x02
55#define i8042_AUX_DATA 0x20
56
57/* Command constants */
58#define i8042_CMD_WRITE_CMDB 0x60 /**< Write command byte */
59#define i8042_CMD_WRITE_AUX 0xd4 /**< Write aux device */
60
61/* Command byte fields */
62#define i8042_KBD_IE 0x01
63#define i8042_AUX_IE 0x02
64#define i8042_KBD_DISABLE 0x10
65#define i8042_AUX_DISABLE 0x20
66#define i8042_KBD_TRANSLATE 0x40 /* Use this to switch to XT scancodes */
67
68#define CHECK_RET_DESTROY(ret, msg...) \
69 do { \
70 if (ret != EOK) { \
71 ddf_msg(LVL_ERROR, msg); \
72 if (dev->kbd_fun) { \
73 dev->kbd_fun->driver_data = NULL; \
74 ddf_fun_destroy(dev->kbd_fun); \
75 } \
76 if (dev->aux_fun) { \
77 dev->aux_fun->driver_data = NULL; \
78 ddf_fun_destroy(dev->aux_fun); \
79 } \
80 } \
81 } while (0)
82
83#define CHECK_RET_UNBIND_DESTROY(ret, msg...) \
84 do { \
85 if (ret != EOK) { \
86 ddf_msg(LVL_ERROR, msg); \
87 if (dev->kbd_fun) { \
88 ddf_fun_unbind(dev->kbd_fun); \
89 dev->kbd_fun->driver_data = NULL; \
90 ddf_fun_destroy(dev->kbd_fun); \
91 } \
92 if (dev->aux_fun) { \
93 ddf_fun_unbind(dev->aux_fun); \
94 dev->aux_fun->driver_data = NULL; \
95 ddf_fun_destroy(dev->aux_fun); \
96 } \
97 } \
98 } while (0)
99
100void default_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
101
102/** Port function operations. */
103static ddf_dev_ops_t ops = {
104 .default_handler = default_handler,
105};
106
107static const irq_pio_range_t i8042_ranges[] = {
108 {
109 .base = 0,
110 .size = sizeof(i8042_regs_t)
111 }
112};
113
114/** i8042 Interrupt pseudo-code. */
115static const irq_cmd_t i8042_cmds[] = {
116 {
117 .cmd = CMD_PIO_READ_8,
118 .addr = NULL, /* will be patched in run-time */
119 .dstarg = 1
120 },
121 {
122 .cmd = CMD_BTEST,
123 .value = i8042_OUTPUT_FULL,
124 .srcarg = 1,
125 .dstarg = 3
126 },
127 {
128 .cmd = CMD_PREDICATE,
129 .value = 2,
130 .srcarg = 3
131 },
132 {
133 .cmd = CMD_PIO_READ_8,
134 .addr = NULL, /* will be patched in run-time */
135 .dstarg = 2
136 },
137 {
138 .cmd = CMD_ACCEPT
139 }
140};
141
142/** Wait until it is safe to write to the device. */
143static void wait_ready(i8042_t *dev)
144{
145 assert(dev);
146 while (pio_read_8(&dev->regs->status) & i8042_INPUT_FULL);
147}
148
149/** Interrupt handler routine.
150 *
151 * Write new data to the corresponding buffer.
152 *
153 * @param dev Device that caued the interrupt.
154 * @param iid Call id.
155 * @param call pointerr to call data.
156 *
157 */
158static void i8042_irq_handler(ddf_dev_t *dev, ipc_callid_t iid,
159 ipc_call_t *call)
160{
161 if ((!dev) || (!dev->driver_data))
162 return;
163
164 i8042_t *controller = dev->driver_data;
165
166 const uint8_t status = IPC_GET_ARG1(*call);
167 const uint8_t data = IPC_GET_ARG2(*call);
168
169 buffer_t *buffer = (status & i8042_AUX_DATA) ?
170 &controller->aux_buffer : &controller->kbd_buffer;
171
172 buffer_write(buffer, data);
173}
174
175/** Initialize i8042 driver structure.
176 *
177 * @param dev Driver structure to initialize.
178 * @param regs I/O address of registers.
179 * @param reg_size size of the reserved I/O address space.
180 * @param irq_kbd IRQ for primary port.
181 * @param irq_mouse IRQ for aux port.
182 * @param ddf_dev DDF device structure of the device.
183 *
184 * @return Error code.
185 *
186 */
187int i8042_init(i8042_t *dev, void *regs, size_t reg_size, int irq_kbd,
188 int irq_mouse, ddf_dev_t *ddf_dev)
189{
190 assert(ddf_dev);
191 assert(dev);
192
193 if (reg_size < sizeof(i8042_regs_t))
194 return EINVAL;
195
196 if (pio_enable(regs, sizeof(i8042_regs_t), (void **) &dev->regs) != 0)
197 return -1;
198
199 dev->kbd_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2a");
200 if (!dev->kbd_fun)
201 return ENOMEM;
202
203 int ret = ddf_fun_add_match_id(dev->kbd_fun, "char/xtkbd", 90);
204 if (ret != EOK) {
205 ddf_fun_destroy(dev->kbd_fun);
206 return ret;
207 }
208
209 dev->aux_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2b");
210 if (!dev->aux_fun) {
211 ddf_fun_destroy(dev->kbd_fun);
212 return ENOMEM;
213 }
214
215 ret = ddf_fun_add_match_id(dev->aux_fun, "char/ps2mouse", 90);
216 if (ret != EOK) {
217 ddf_fun_destroy(dev->kbd_fun);
218 ddf_fun_destroy(dev->aux_fun);
219 return ret;
220 }
221
222 dev->kbd_fun->ops = &ops;
223 dev->aux_fun->ops = &ops;
224 dev->kbd_fun->driver_data = dev;
225 dev->aux_fun->driver_data = dev;
226
227 buffer_init(&dev->kbd_buffer, dev->kbd_data, BUFFER_SIZE);
228 buffer_init(&dev->aux_buffer, dev->aux_data, BUFFER_SIZE);
229 fibril_mutex_initialize(&dev->write_guard);
230
231 ret = ddf_fun_bind(dev->kbd_fun);
232 CHECK_RET_DESTROY(ret, "Failed to bind keyboard function: %s.",
233 str_error(ret));
234
235 ret = ddf_fun_bind(dev->aux_fun);
236 CHECK_RET_DESTROY(ret, "Failed to bind mouse function: %s.",
237 str_error(ret));
238
239 /* Disable kbd and aux */
240 wait_ready(dev);
241 pio_write_8(&dev->regs->status, i8042_CMD_WRITE_CMDB);
242 wait_ready(dev);
243 pio_write_8(&dev->regs->data, i8042_KBD_DISABLE | i8042_AUX_DISABLE);
244
245 /* Flush all current IO */
246 while (pio_read_8(&dev->regs->status) & i8042_OUTPUT_FULL)
247 (void) pio_read_8(&dev->regs->data);
248
249 const size_t range_count = sizeof(i8042_ranges) /
250 sizeof(irq_pio_range_t);
251 irq_pio_range_t ranges[range_count];
252 memcpy(ranges, i8042_ranges, sizeof(i8042_ranges));
253 ranges[0].base = (uintptr_t) regs;
254
255 const size_t cmd_count = sizeof(i8042_cmds) / sizeof(irq_cmd_t);
256 irq_cmd_t cmds[cmd_count];
257 memcpy(cmds, i8042_cmds, sizeof(i8042_cmds));
258 cmds[0].addr = (void *) &(((i8042_regs_t *) regs)->status);
259 cmds[3].addr = (void *) &(((i8042_regs_t *) regs)->data);
260
261 irq_code_t irq_code = {
262 .rangecount = range_count,
263 .ranges = ranges,
264 .cmdcount = cmd_count,
265 .cmds = cmds
266 };
267
268 ret = register_interrupt_handler(ddf_dev, irq_kbd, i8042_irq_handler,
269 &irq_code);
270 CHECK_RET_UNBIND_DESTROY(ret, "Failed set handler for kbd: %s.",
271 str_error(ret));
272
273 ret = register_interrupt_handler(ddf_dev, irq_mouse, i8042_irq_handler,
274 &irq_code);
275 CHECK_RET_UNBIND_DESTROY(ret, "Failed set handler for mouse: %s.",
276 str_error(ret));
277
278 /* Enable interrupts */
279 async_sess_t *parent_sess =
280 devman_parent_device_connect(EXCHANGE_SERIALIZE, ddf_dev->handle,
281 IPC_FLAG_BLOCKING);
282 ret = parent_sess ? EOK : ENOMEM;
283 CHECK_RET_UNBIND_DESTROY(ret, "Failed to create parent connection.");
284
285 const bool enabled = hw_res_enable_interrupt(parent_sess);
286 async_hangup(parent_sess);
287 ret = enabled ? EOK : EIO;
288 CHECK_RET_UNBIND_DESTROY(ret, "Failed to enable interrupts: %s.");
289
290 /* Enable port interrupts. */
291 wait_ready(dev);
292 pio_write_8(&dev->regs->status, i8042_CMD_WRITE_CMDB);
293 wait_ready(dev);
294 pio_write_8(&dev->regs->data, i8042_KBD_IE | i8042_KBD_TRANSLATE |
295 i8042_AUX_IE);
296
297 return EOK;
298}
299
300// FIXME TODO use shared instead this
301enum {
302 IPC_CHAR_READ = DEV_FIRST_CUSTOM_METHOD,
303 IPC_CHAR_WRITE,
304};
305
306/** Write data to i8042 port.
307 *
308 * @param fun DDF function.
309 * @param buffer Data source.
310 * @param size Data size.
311 *
312 * @return Bytes written.
313 *
314 */
315static int i8042_write(ddf_fun_t *fun, char *buffer, size_t size)
316{
317 assert(fun);
318 assert(fun->driver_data);
319
320 i8042_t *controller = fun->driver_data;
321 fibril_mutex_lock(&controller->write_guard);
322
323 for (size_t i = 0; i < size; ++i) {
324 if (controller->aux_fun == fun) {
325 wait_ready(controller);
326 pio_write_8(&controller->regs->status,
327 i8042_CMD_WRITE_AUX);
328 }
329
330 wait_ready(controller);
331 pio_write_8(&controller->regs->data, buffer[i]);
332 }
333
334 fibril_mutex_unlock(&controller->write_guard);
335 return size;
336}
337
338/** Read data from i8042 port.
339 *
340 * @param fun DDF function.
341 * @param buffer Data place.
342 * @param size Data place size.
343 *
344 * @return Bytes read.
345 *
346 */
347static int i8042_read(ddf_fun_t *fun, char *data, size_t size)
348{
349 assert(fun);
350 assert(fun->driver_data);
351
352 i8042_t *controller = fun->driver_data;
353 buffer_t *buffer = (fun == controller->aux_fun) ?
354 &controller->aux_buffer : &controller->kbd_buffer;
355
356 for (size_t i = 0; i < size; ++i)
357 *data++ = buffer_read(buffer);
358
359 return size;
360}
361
362/** Handle data requests.
363 *
364 * @param fun ddf_fun_t function.
365 * @param id callid
366 * @param call IPC request.
367 *
368 */
369void default_handler(ddf_fun_t *fun, ipc_callid_t id, ipc_call_t *call)
370{
371 const sysarg_t method = IPC_GET_IMETHOD(*call);
372 const size_t size = IPC_GET_ARG1(*call);
373
374 switch (method) {
375 case IPC_CHAR_READ:
376 if (size <= 4 * sizeof(sysarg_t)) {
377 sysarg_t message[4] = {};
378
379 i8042_read(fun, (char *) message, size);
380 async_answer_4(id, size, message[0], message[1],
381 message[2], message[3]);
382 } else
383 async_answer_0(id, ELIMIT);
384 break;
385
386 case IPC_CHAR_WRITE:
387 if (size <= 3 * sizeof(sysarg_t)) {
388 const sysarg_t message[3] = {
389 IPC_GET_ARG2(*call),
390 IPC_GET_ARG3(*call),
391 IPC_GET_ARG4(*call)
392 };
393
394 i8042_write(fun, (char *) message, size);
395 async_answer_0(id, size);
396 } else
397 async_answer_0(id, ELIMIT);
398
399 default:
400 async_answer_0(id, EINVAL);
401 }
402}
403
404/**
405 * @}
406 */
Note: See TracBrowser for help on using the repository browser.