static async_sess_t *get_wifi_by_index(size_t i)
{
service_id_t *wifis = NULL;
size_t count;
int rc = get_wifi_list(&wifis, &count);
if (rc != EOK) {
printf("Error fetching wifi list.\n");
return NULL;
}
if (i >= count) {
printf("Invalid wifi index.\n");
free(wifis);
return NULL;
}
async_sess_t *sess =
loc_service_connect(wifis[i], INTERFACE_DDF, 0);
if (sess == NULL) {
printf("Error connecting to service.\n");
free(wifis);
return NULL;
}
return sess;
}
int vbd_create(vbd_t **rvbd)
{
vbd_t *vbd;
service_id_t vbd_svcid;
int rc;
vbd = calloc(1, sizeof(vbd_t));
if (vbd == NULL) {
rc = ENOMEM;
goto error;
}
rc = loc_service_get_id(SERVICE_NAME_VBD, &vbd_svcid,
IPC_FLAG_BLOCKING);
if (rc != EOK) {
rc = EIO;
goto error;
}
vbd->sess = loc_service_connect(vbd_svcid, INTERFACE_VBD,
IPC_FLAG_BLOCKING);
if (vbd->sess == NULL) {
rc = EIO;
goto error;
}
*rvbd = vbd;
return EOK;
error:
free(vbd);
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;
}
/**
* Start a new audio session.
* @param service Named service typically 'HOUND_SERVICE' constant.
* @return Valid session on success, NULL on failure.
*/
hound_sess_t *hound_service_connect(const char *service)
{
service_id_t id = 0;
const int ret =
loc_service_get_id(service, &id, IPC_FLAG_BLOCKING);
if (ret != EOK)
return NULL;
return loc_service_connect(id, INTERFACE_HOUND, IPC_FLAG_BLOCKING);
}
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 UDP client instance.
*
* @param rudp Place to store pointer to new UDP client
* @return EOK on success, ENOMEM if out of memory, EIO if service
* cannot be contacted
*/
int udp_create(udp_t **rudp)
{
udp_t *udp;
service_id_t udp_svcid;
int rc;
udp = calloc(1, sizeof(udp_t));
if (udp == NULL) {
rc = ENOMEM;
goto error;
}
list_initialize(&udp->assoc);
fibril_mutex_initialize(&udp->lock);
fibril_condvar_initialize(&udp->cv);
rc = loc_service_get_id(SERVICE_NAME_UDP, &udp_svcid,
IPC_FLAG_BLOCKING);
if (rc != EOK) {
rc = EIO;
goto error;
}
udp->sess = loc_service_connect(udp_svcid, INTERFACE_UDP,
IPC_FLAG_BLOCKING);
if (udp->sess == NULL) {
rc = EIO;
goto error;
}
rc = udp_callback_create(udp);
if (rc != EOK) {
rc = EIO;
goto error;
}
*rudp = udp;
return EOK;
error:
free(udp);
return rc;
}
static void loc_callback(void)
{
category_id_t led_cat;
int rc = loc_category_get_id("led", &led_cat, IPC_FLAG_BLOCKING);
if (rc != EOK)
return;
service_id_t *svcs;
size_t count;
rc = loc_category_get_svcs(led_cat, &svcs, &count);
if (rc != EOK)
return;
for (size_t i = 0; i < count; i++) {
bool known = false;
/* Determine whether we already know this device. */
list_foreach(led_devs, link, led_dev_t, dev) {
if (dev->svc_id == svcs[i]) {
known = true;
break;
}
}
if (!known) {
led_dev_t *dev = (led_dev_t *) calloc(1, sizeof(led_dev_t));
if (!dev)
continue;
link_initialize(&dev->link);
dev->svc_id = svcs[i];
dev->sess = loc_service_connect(svcs[i], INTERFACE_DDF, 0);
list_append(&dev->link, &led_devs);
}
}
// FIXME: Handle LED device removal
free(svcs);
}
int inet_init(uint8_t protocol, inet_ev_ops_t *ev_ops)
{
service_id_t inet_svc;
int rc;
assert(inet_sess == NULL);
assert(inet_ev_ops == NULL);
assert(inet_protocol == 0);
rc = loc_service_get_id(SERVICE_NAME_INET, &inet_svc,
IPC_FLAG_BLOCKING);
if (rc != EOK)
return ENOENT;
inet_sess = loc_service_connect(EXCHANGE_SERIALIZE, inet_svc,
IPC_FLAG_BLOCKING);
if (inet_sess == NULL)
return ENOENT;
if (inet_set_proto(protocol) != EOK) {
async_hangup(inet_sess);
inet_sess = NULL;
return EIO;
}
if (inet_callback_create() != EOK) {
async_hangup(inet_sess);
inet_sess = NULL;
return EIO;
}
inet_protocol = protocol;
inet_ev_ops = ev_ops;
return EOK;
}
int main(int argc, char **argv)
{
sysarg_t baud = 38400;
service_id_t svc_id;
char *serial_port_name = NULL;
int arg = 1;
int rc;
isdv4_event_fn event_fn = emit_event;
if (argc > arg && str_test_prefix(argv[arg], "--baud=")) {
size_t arg_offset = str_lsize(argv[arg], 7);
char* arg_str = argv[arg] + arg_offset;
if (str_length(arg_str) == 0) {
fprintf(stderr, "--baud requires an argument\n");
syntax_print();
return 1;
}
char *endptr;
baud = strtol(arg_str, &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "Invalid value for baud\n");
syntax_print();
return 1;
}
arg++;
}
if (argc > arg && str_cmp(argv[arg], "--print-events") == 0) {
event_fn = print_and_emit_event;
arg++;
}
if (argc > arg) {
serial_port_name = argv[arg];
rc = loc_service_get_id(serial_port_name, &svc_id, 0);
if (rc != EOK) {
fprintf(stderr, "Cannot find device service %s\n",
argv[arg]);
return 1;
}
arg++;
}
else {
category_id_t serial_cat_id;
rc = loc_category_get_id("serial", &serial_cat_id, 0);
if (rc != EOK) {
fprintf(stderr, "Failed getting id of category "
"'serial'\n");
return 1;
}
service_id_t *svc_ids;
size_t svc_count;
rc = loc_category_get_svcs(serial_cat_id, &svc_ids, &svc_count); if (rc != EOK) {
fprintf(stderr, "Failed getting list of services\n");
return 1;
}
if (svc_count == 0) {
fprintf(stderr, "No service in category 'serial'\n");
free(svc_ids);
return 1;
}
svc_id = svc_ids[0];
rc = loc_service_get_name(svc_id, &serial_port_name);
if (rc != EOK) {
fprintf(stderr, "Failed getting name of serial service\n");
return 1;
}
free(svc_ids);
}
if (argc > arg) {
fprintf(stderr, "Too many arguments\n");
syntax_print();
return 1;
}
fibril_mutex_initialize(&client_mutex);
printf(NAME ": Using serial port %s\n", serial_port_name);
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
IPC_FLAG_BLOCKING);
if (!sess) {
fprintf(stderr, "Failed connecting to service\n");
}
async_exch_t *exch = async_exchange_begin(sess);
rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
SERIAL_NO_PARITY, 8, 1);
async_exchange_end(exch);
if (rc != EOK) {
fprintf(stderr, "Failed setting serial properties\n");
return 2;
}
rc = isdv4_init(&state, sess, event_fn);
if (rc != EOK) {
fprintf(stderr, "Failed initializing isdv4 state");
return 2;
}
rc = isdv4_init_tablet(&state);
if (rc != EOK) {
fprintf(stderr, "Failed initializing tablet");
return 2;
}
printf("Tablet information:\n");
printf(" Stylus: %ux%u pressure: %u tilt: ", state.stylus_max_x,
state.stylus_max_y, state.stylus_max_pressure);
if (state.stylus_tilt_supported) {
printf("%ux%u\n", state.stylus_max_xtilt, state.stylus_max_ytilt);
}
else {
printf("not supported\n");
}
printf(" Touch: %ux%u type: %s\n", state.touch_max_x, state.touch_max_y,
touch_type(state.touch_type));
fid_t fibril = fibril_create(read_fibril, NULL);
/* From this on, state is to be used only by read_fibril */
fibril_add_ready(fibril);
async_set_fallback_port_handler(mouse_connection, NULL);
rc = loc_server_register(NAME);
if (rc != EOK) {
printf("%s: Unable to register driver.\n", NAME);
return rc;
}
service_id_t service_id;
char *service_name;
rc = asprintf(&service_name, "mouse/isdv4-%" PRIun, svc_id);
if (rc < 0) {
printf(NAME ": Unable to create service name\n");
return rc;
}
rc = loc_service_register(service_name, &service_id);
if (rc != EOK) {
printf(NAME ": Unable to register service %s.\n", service_name);
return rc;
}
category_id_t mouse_category;
rc = loc_category_get_id("mouse", &mouse_category, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf(NAME ": Unable to get mouse category id.\n");
}
else {
rc = loc_service_add_to_cat(service_id, mouse_category);
if (rc != EOK) {
printf(NAME ": Unable to add device to mouse category.\n");
}
}
printf("%s: Accepting connections\n", NAME);
task_retval(0);
async_manager();
/* Not reached */
return 0;
}
int
main(int argc, char **argv)
{
int rc, c;
category_id_t cat_id;
size_t svc_cnt;
service_id_t *svc_ids = NULL;
service_id_t svc_id;
char *svc_name = NULL;
bool read_only = true;
char *wdate = NULL;
char *wtime = NULL;
struct tm t;
int n_args = argc;
while ((c = getopt(argc, argv, "hd:t:")) != -1) {
switch (c) {
case 'h':
usage();
return 0;
case 'd':
if (wdate) {
usage();
return 1;
}
wdate = (char *)optarg;
read_only = false;
n_args -= 2;
break;
case 't':
if (wtime) {
usage();
return 1;
}
wtime = (char *)optarg;
read_only = false;
n_args -= 2;
break;
case '?':
usage();
return 1;
}
}
if (n_args != 1) {
printf(NAME ": Unrecognized parameter\n");
usage();
return 1;
}
/* Get the id of the clock category */
rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING);
if (rc != EOK) {
printf(NAME ": Cannot get clock category id\n");
goto exit;
}
/* Get the list of available services in the clock category */
rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
if (rc != EOK) {
printf(NAME ": Cannot get the list of services in the clock "
"category\n");
goto exit;
}
/* Check if there are available services in the clock category */
if (svc_cnt == 0) {
printf(NAME ": No available service found in "
"the clock category\n");
goto exit;
}
/* Get the name of the clock service */
rc = loc_service_get_name(svc_ids[0], &svc_name);
if (rc != EOK) {
printf(NAME ": Cannot get the name of the service\n");
goto exit;
}
/* Get the service id for the device */
rc = loc_service_get_id(svc_name, &svc_id, 0);
if (rc != EOK) {
printf(NAME ": Cannot get the service id for device %s",
svc_name);
goto exit;
}
/* Connect to the device */
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
if (!sess) {
printf(NAME ": Cannot connect to the device\n");
goto exit;
}
/* Read the current date/time */
rc = clock_dev_time_get(sess, &t);
if (rc != EOK) {
printf(NAME ": Cannot read the current time\n");
goto exit;
}
if (read_only) {
/* Print the current time and exit */
printf("%02d/%02d/%d ", t.tm_mday,
t.tm_mon + 1, 1900 + t.tm_year);
printf("%02d:%02d:%02d\n", t.tm_hour, t.tm_min, t.tm_sec);
} else {
if (wdate) {
rc = read_date_from_arg(wdate, &t);
if (rc != EOK) {
printf(NAME ": error, date format not "
"recognized\n");
usage();
goto exit;
}
}
if (wtime) {
rc = read_time_from_arg(wtime, &t);
if (rc != EOK) {
printf(NAME ": error, time format not "
"recognized\n");
usage();
goto exit;
}
}
rc = tm_sanity_check(&t);
if (rc != EOK) {
printf(NAME ": error, invalid date/time\n");
goto exit;
}
rc = clock_dev_time_set(sess, &t);
if (rc != EOK) {
printf(NAME ": error, Unable to set date/time\n");
goto exit;
}
}
exit:
free(svc_name);
free(svc_ids);
return rc;
}
int main(int argc, char **argv)
{
sysarg_t baud = 9600;
service_id_t svc_id;
int arg = 1;
int rc;
if (argc > arg && str_test_prefix(argv[arg], "--baud=")) {
size_t arg_offset = str_lsize(argv[arg], 7);
char* arg_str = argv[arg] + arg_offset;
if (str_length(arg_str) == 0) {
fprintf(stderr, "--baud requires an argument\n");
syntax_print();
return 1;
}
char *endptr;
baud = strtol(arg_str, &endptr, 10);
if (*endptr != '\0') {
fprintf(stderr, "Invalid value for baud\n");
syntax_print();
return 1;
}
arg++;
}
if (argc > arg) {
rc = loc_service_get_id(argv[arg], &svc_id, 0);
if (rc != EOK) {
fprintf(stderr, "Cannot find device service %s\n",
argv[arg]);
return 1;
}
arg++;
}
else {
category_id_t serial_cat_id;
rc = loc_category_get_id("serial", &serial_cat_id, 0);
if (rc != EOK) {
fprintf(stderr, "Failed getting id of category "
"'serial'\n");
return 1;
}
service_id_t *svc_ids;
size_t svc_count;
rc = loc_category_get_svcs(serial_cat_id, &svc_ids, &svc_count);
if (rc != EOK) {
fprintf(stderr, "Failed getting list of services\n");
return 1;
}
if (svc_count == 0) {
fprintf(stderr, "No service in category 'serial'\n");
free(svc_ids);
return 1;
}
svc_id = svc_ids[0];
free(svc_ids);
}
if (argc > arg) {
fprintf(stderr, "Too many arguments\n");
syntax_print();
return 1;
}
async_sess_t *sess = loc_service_connect(svc_id, INTERFACE_DDF,
IPC_FLAG_BLOCKING);
if (!sess) {
fprintf(stderr, "Failed connecting to service\n");
}
async_exch_t *exch = async_exchange_begin(sess);
rc = async_req_4_0(exch, SERIAL_SET_COM_PROPS, baud,
SERIAL_NO_PARITY, 8, 1);
async_exchange_end(exch);
if (rc != EOK) {
fprintf(stderr, "Failed setting serial properties\n");
return 2;
}
uint8_t *buf = (uint8_t *) malloc(BUF_SIZE);
if (buf == NULL) {
fprintf(stderr, "Failed allocating buffer\n");
return 3;
}
while (true) {
ssize_t read = char_dev_read(sess, buf, BUF_SIZE);
if (read < 0) {
fprintf(stderr, "Failed reading from serial device\n");
break;
}
ssize_t i;
for (i = 0; i < read; i++) {
printf("%02hhx ", buf[i]);
}
fflush(stdout);
}
free(buf);
return 0;
}