← Back to branch summary

~helenos-nicf/helenos/nicf

« back to all changes in this revision

Viewing changes to uspace/srv/hid/input/port/adb.c

  • Committer: Radim Vansa
  • Date: 2011-09-20 21:55:59 UTC
  • mfrom: (697.1.517 HelenOS.mainline)
  • Revision ID: radim.vansa@matfyz.cz-20110920215559-7fjpai6wt5ieurcq
Merge with mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/srv/hid/input/port/adb.c
1
1
/*
2
 
 * Copyright (c) 2010 Jiri Svoboda
 
2
 * Copyright (c) 2011 Jiri Svoboda
3
3
 * All rights reserved.
4
4
 *
5
5
 * Redistribution and use in source and binary forms, with or without
29
29
/** @addtogroup kbd_port
30
30
 * @ingroup kbd
31
31
 * @{
32
 
 */ 
 
32
 */
33
33
/** @file
34
34
 * @brief ADB keyboard port driver.
35
35
 */
36
36
 
37
37
#include <ipc/adb.h>
38
38
#include <async.h>
 
39
#include <input.h>
39
40
#include <kbd_port.h>
40
41
#include <kbd.h>
41
42
#include <vfs/vfs.h>
42
43
#include <fcntl.h>
43
44
#include <errno.h>
 
45
#include <loc.h>
44
46
 
45
 
static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall);
 
47
static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
46
48
static void adb_kbd_reg0_data(uint16_t data);
47
49
 
48
 
static int dev_phone;
49
 
 
50
 
#define NAME "kbd"
51
 
 
52
 
int kbd_port_init(void)
 
50
static int adb_port_init(kbd_dev_t *);
 
51
static void adb_port_yield(void);
 
52
static void adb_port_reclaim(void);
 
53
static void adb_port_write(uint8_t data);
 
54
 
 
55
kbd_port_ops_t adb_port = {
 
56
        .init = adb_port_init,
 
57
        .yield = adb_port_yield,
 
58
        .reclaim = adb_port_reclaim,
 
59
        .write = adb_port_write
 
60
};
 
61
 
 
62
static kbd_dev_t *kbd_dev;
 
63
static async_sess_t *dev_sess;
 
64
 
 
65
static int adb_port_init(kbd_dev_t *kdev)
53
66
{
54
 
        const char *input = "/dev/adb/kbd";
55
 
        int input_fd;
56
 
 
57
 
        printf(NAME ": open %s\n", input);
58
 
 
59
 
        input_fd = open(input, O_RDONLY);
60
 
        if (input_fd < 0) {
61
 
                printf(NAME ": Failed opening %s (%d)\n", input, input_fd);
62
 
                return false;
63
 
        }
64
 
 
65
 
        dev_phone = fd_phone(input_fd);
66
 
        if (dev_phone < 0) {
67
 
                printf(NAME ": Failed to connect to device\n");
68
 
                return false;
69
 
        }
70
 
 
 
67
        const char *dev = "adb/kbd";
 
68
        service_id_t service_id;
 
69
        async_exch_t *exch;
 
70
        int rc;
 
71
        
 
72
        kbd_dev = kdev;
 
73
        
 
74
        rc = loc_service_get_id(dev, &service_id, 0);
 
75
        if (rc != EOK)
 
76
                return rc;
 
77
        
 
78
        dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
 
79
        if (dev_sess == NULL) {
 
80
                printf("%s: Failed to connect to device\n", NAME);
 
81
                return ENOENT;
 
82
        }
 
83
        
 
84
        exch = async_exchange_begin(dev_sess);
 
85
        if (exch == NULL) {
 
86
                printf("%s: Failed starting exchange with device\n", NAME);
 
87
                async_hangup(dev_sess);
 
88
                return ENOMEM;
 
89
        }
 
90
        
71
91
        /* NB: The callback connection is slotted for removal */
72
 
        if (async_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) {
73
 
                printf(NAME ": Failed to create callback from device\n");
74
 
                return false;
 
92
        rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
 
93
        async_exchange_end(exch);
 
94
        if (rc != EOK) {
 
95
                printf("%s: Failed to create callback from device\n", NAME);
 
96
                async_hangup(dev_sess);
 
97
                return rc;
75
98
        }
76
 
 
77
 
        return 0;
78
 
}
79
 
 
80
 
void kbd_port_yield(void)
81
 
{
82
 
}
83
 
 
84
 
void kbd_port_reclaim(void)
85
 
{
86
 
}
87
 
 
88
 
void kbd_port_write(uint8_t data)
 
99
        
 
100
        return EOK;
 
101
}
 
102
 
 
103
static void adb_port_yield(void)
 
104
{
 
105
}
 
106
 
 
107
static void adb_port_reclaim(void)
 
108
{
 
109
}
 
110
 
 
111
static void adb_port_write(uint8_t data)
89
112
{
90
113
        /*async_msg_1(dev_phone, CHAR_WRITE_BYTE, data);*/
91
114
}
92
115
 
93
 
static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall)
 
116
static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
94
117
{
95
118
        /* Ignore parameters, the connection is already opened */
96
119
        while (true) {
99
122
                ipc_callid_t callid = async_get_call(&call);
100
123
 
101
124
                int retval;
102
 
 
103
 
                switch (IPC_GET_IMETHOD(call)) {
104
 
                case IPC_M_PHONE_HUNGUP:
 
125
                
 
126
                if (!IPC_GET_IMETHOD(call)) {
105
127
                        /* TODO: Handle hangup */
106
128
                        return;
 
129
                }
 
130
                
 
131
                switch (IPC_GET_IMETHOD(call)) {
107
132
                case ADB_REG_NOTIF:
108
133
                        adb_kbd_reg0_data(IPC_GET_ARG1(call));
109
134
                        break;
116
141
 
117
142
static void adb_kbd_reg0_data(uint16_t data)
118
143
{
119
 
        uint8_t b0, b1;
120
 
 
121
 
        b0 = (data >> 8) & 0xff;
122
 
        b1 = data & 0xff;
123
 
 
 
144
        uint8_t b0 = (data >> 8) & 0xff;
 
145
        uint8_t b1 = data & 0xff;
 
146
        
124
147
        if (b0 != 0xff)
125
 
                kbd_push_scancode(b0);
 
148
                kbd_push_data(kbd_dev, b0);
 
149
        
126
150
        if (b1 != 0xff)
127
 
                kbd_push_scancode(b1);
 
151
                kbd_push_data(kbd_dev, b1);
128
152
}
129
153
 
130
154
/**