int bd_open(async_sess_t *sess, bd_t **rbd)
{
bd_t *bd = calloc(1, sizeof(bd_t));
if (bd == NULL)
return ENOMEM;
bd->sess = sess;
async_exch_t *exch = async_exchange_begin(sess);
int rc = async_connect_to_me(exch, 0, 0, 0, bd_cb_conn, bd);
async_exchange_end(exch);
if (rc != EOK)
goto error;
*rbd = bd;
return EOK;
error:
if (bd != NULL)
free(bd);
return rc;
}
static int adb_port_init(kbd_dev_t *kdev)
{
kbd_dev = kdev;
const char *dev = "adb/kbd";
service_id_t service_id;
int rc = loc_service_get_id(dev, &service_id, 0);
if (rc != EOK)
return rc;
dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id, 0);
if (dev_sess == NULL) {
printf("%s: Failed to connect to device\n", NAME);
return ENOENT;
}
async_exch_t *exch = async_exchange_begin(dev_sess);
if (exch == NULL) {
printf("%s: Failed starting exchange with device\n", NAME);
async_hangup(dev_sess);
return ENOMEM;
}
rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
async_exchange_end(exch);
if (rc != EOK) {
printf("%s: Failed to create callback from device\n", NAME);
async_hangup(dev_sess);
return rc;
}
return EOK;
}
static int inet_callback_create(void)
{
async_exch_t *exch = async_exchange_begin(inet_sess);
ipc_call_t answer;
aid_t req = async_send_0(exch, INET_CALLBACK_CREATE, &answer);
int rc = async_connect_to_me(exch, 0, 0, 0, inet_cb_conn, NULL);
async_exchange_end(exch);
if (rc != EOK)
return rc;
sysarg_t retval;
async_wait_for(req, &retval);
return retval;
}
static int chardev_port_init(kbd_dev_t *kdev)
{
service_id_t service_id;
async_exch_t *exch;
unsigned int i;
int rc;
kbd_dev = kdev;
for (i = 0; i < num_devs; i++) {
rc = loc_service_get_id(in_devs[i], &service_id, 0);
if (rc == EOK)
break;
}
if (i >= num_devs) {
printf("%s: Could not find any suitable input device\n", NAME);
return -1;
}
dev_sess = loc_service_connect(EXCHANGE_ATOMIC, service_id,
IPC_FLAG_BLOCKING);
if (dev_sess == NULL) {
printf("%s: Failed connecting to device\n", NAME);
return ENOENT;
}
exch = async_exchange_begin(dev_sess);
if (exch == NULL) {
printf("%s: Failed starting exchange with device\n", NAME);
async_hangup(dev_sess);
return ENOMEM;
}
/* NB: The callback connection is slotted for removal */
rc = async_connect_to_me(exch, 0, 0, 0, kbd_port_events, NULL);
async_exchange_end(exch);
if (rc != 0) {
printf("%s: Failed to create callback from device\n", NAME);
async_hangup(dev_sess);
return -1;
}
return 0;
}
static int kbdev_ctl_init(kbd_dev_t *kdev)
{
async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
kdev->svc_id, 0);
if (sess == NULL) {
printf("%s: Failed starting session with '%s.'\n", NAME,
kdev->svc_name);
return ENOENT;
}
kbdev_t *kbdev = kbdev_new(kdev);
if (kbdev == NULL) {
printf("%s: Failed allocating device structure for '%s'.\n",
NAME, kdev->svc_name);
async_hangup(sess);
return ENOMEM;
}
kbdev->sess = sess;
async_exch_t *exch = async_exchange_begin(sess);
if (exch == NULL) {
printf("%s: Failed starting exchange with '%s'.\n", NAME,
kdev->svc_name);
kbdev_destroy(kbdev);
return ENOENT;
}
int rc = async_connect_to_me(exch, 0, 0, 0, kbdev_callback_conn, kbdev);
if (rc != EOK) {
printf("%s: Failed creating callback connection from '%s'.\n",
NAME, kdev->svc_name);
async_exchange_end(exch);
kbdev_destroy(kbdev);
return rc;
}
async_exchange_end(exch);
kdev->ctl_private = (void *) kbdev;
return 0;
}
/** Create callback connection from NIC service
*
* @param[in] dev_sess
* @param[in] device_id
*
* @return EOK If the operation was successfully completed
*
*/
int nic_callback_create(async_sess_t *dev_sess, async_client_conn_t cfun,
void *carg)
{
ipc_call_t answer;
int rc;
sysarg_t retval;
async_exch_t *exch = async_exchange_begin(dev_sess);
aid_t req = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
NIC_CALLBACK_CREATE, &answer);
rc = async_connect_to_me(exch, 0, 0, 0, cfun, carg);
if (rc != EOK) {
async_forget(req);
return rc;
}
async_exchange_end(exch);
async_wait_for(req, &retval);
return (int) retval;
}
/** Register new driver with loc. */
int loc_server_register(const char *name)
{
async_exch_t *exch = loc_exchange_begin_blocking(LOC_PORT_SUPPLIER);
ipc_call_t answer;
aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
sysarg_t retval = async_data_write_start(exch, name, str_size(name));
loc_exchange_end(exch);
if (retval != EOK) {
async_forget(req);
return retval;
}
exch = loc_exchange_begin(LOC_PORT_SUPPLIER);
async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
loc_exchange_end(exch);
async_wait_for(req, &retval);
return retval;
}
/** Create callback
*
* Must be called with loc_callback_mutex locked.
*
* @return EOK on success.
*
*/
static int loc_callback_create(void)
{
if (!loc_callback_created) {
async_exch_t *exch =
loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
ipc_call_t answer;
aid_t req = async_send_0(exch, LOC_CALLBACK_CREATE, &answer);
int rc = async_connect_to_me(exch, 0, 0, 0, loc_cb_conn, NULL);
loc_exchange_end(exch);
if (rc != EOK)
return rc;
sysarg_t retval;
async_wait_for(req, &retval);
if (retval != EOK)
return retval;
loc_callback_created = true;
}
return EOK;
}
