| /* |
| * Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| #define _GNU_SOURCE |
| #include <errno.h> |
| #include <getopt.h> |
| #include <glob.h> |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <syslog.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <dirent.h> |
| #include <time.h> |
| |
| #include <alsa/asoundlib.h> |
| #include <linux/input.h> |
| #include <linux/uinput.h> |
| |
| #define DAEMON_NAME "jabra_vold" |
| |
| /* endpoint used for the HID interrupt */ |
| #define JABRA_ENDPOINT 0x81 |
| |
| /* |
| * Report numbers used by the Jabra device. |
| * |
| * We could parse them from the HID descriptors, |
| * but that's long and complicated. |
| */ |
| enum jabra_report { |
| JABRA_HID_REPORT = 1, |
| JABRA_TELEPHONY_REPORT = 3, |
| }; |
| |
| /* bit for mute key press in the telephony report */ |
| #define MUTE_FLAG 0x08 |
| |
| /* Names used by the kernel Alsa audio driver */ |
| #define ALSA_DEV_NAME "Jabra SPEAK" |
| #define ALSA_CONTROL_NAME "PCM Playback Volume" |
| #define CARD_PREFIX "card" |
| |
| #define KEY_CROS_VOLDOWN KEY_VOLUMEDOWN |
| #define KEY_CROS_VOLUP KEY_VOLUMEUP |
| |
| /* Maximum number of supported Alsa devices for Jabra */ |
| #define ALSA_DEV_COUNT_MAX 4 |
| |
| /* |
| * Linux kernel usbmon binary interface format |
| * from Documentation/usb/usbmon.txt |
| * |
| * Only the 48 first bytes as we are using read() rather the IOCTL |
| * which returns the full header. |
| */ |
| struct usbmon_packet { |
| uint64_t id; /* 0: URB ID - from submission to callback */ |
| unsigned char type; /* 8: Same as text; extensible. */ |
| unsigned char xfer_type; /* ISO (0), Intr, Control, Bulk (3) */ |
| unsigned char epnum; /* Endpoint number and transfer direction */ |
| unsigned char devnum; /* Device address */ |
| uint16_t busnum; /* 12: Bus number */ |
| char flag_setup; /* 14: Same as text */ |
| char flag_data; /* 15: Same as text; Binary zero is OK. */ |
| int64_t ts_sec; /* 16: gettimeofday */ |
| int32_t ts_usec; /* 24: gettimeofday */ |
| int status; /* 28: */ |
| unsigned int length; /* 32: Length of data (submitted or actual) */ |
| unsigned int len_cap; /* 36: Delivered length */ |
| union { /* 40: */ |
| unsigned char setup[8]; /* Only for Control S-type */ |
| struct iso_rec { /* Only for ISO */ |
| int error_count; |
| int numdesc; |
| } iso; |
| } s; |
| }; |
| |
| /* Device node for the usbmon binary interface */ |
| #define USBMON_DEV_FMT "/dev/usbmon%d" |
| |
| /* device context */ |
| struct jabra_dev { |
| int uinput_fd; |
| int alsa_dev_count; |
| snd_hctl_t *hctl[ALSA_DEV_COUNT_MAX]; |
| snd_hctl_elem_t *playback_vol[ALSA_DEV_COUNT_MAX]; |
| int mon_fd; |
| int devnum; |
| int alsa_card_idx; |
| }; |
| |
| static void logd(int level, const char *fmt, ...) |
| __attribute__((format (printf, 2, 3))); |
| static void logd(int level, const char *fmt, ...) |
| { |
| va_list ap; |
| |
| va_start(ap, fmt); |
| vsyslog(level, fmt, ap); |
| va_end(ap); |
| } |
| |
| static int alsa_touch_volume(struct jabra_dev *dev) |
| { |
| snd_ctl_elem_value_t *elem; |
| int err = 0, idx; |
| |
| snd_ctl_elem_value_alloca(&elem); |
| for (idx = 0; idx < dev->alsa_dev_count; ++idx) { |
| err = snd_hctl_elem_read(dev->playback_vol[idx], elem); |
| if (err < 0) |
| goto return_err; |
| err = snd_hctl_elem_write(dev->playback_vol[idx], elem); |
| if (err < 0) |
| goto return_err; |
| logd(LOG_INFO, "Touch volume: %ld\n", |
| snd_ctl_elem_value_get_integer(elem, 0)); |
| } |
| |
| return_err: |
| return (err < 0) ? err : 0; |
| } |
| |
| static int alsa_init(struct jabra_dev *dev) |
| { |
| int ret; |
| snd_ctl_elem_id_t *id; |
| int idx; |
| char *card_name; |
| char *hwid[ALSA_DEV_COUNT_MAX] = { NULL, }; |
| time_t deadline = time(NULL) + 5 /* 5-second timeout */; |
| |
| /* allow a brief initial delay so that multiple ALSA devices can be found */ |
| usleep(500000); |
| |
| while (time(NULL) < deadline) { |
| /* find the Jabra device id */ |
| for (idx = -1; (snd_card_next(&idx) == 0) && (idx >= 0); ) { |
| if ((-1 != dev->alsa_card_idx) && (idx != dev->alsa_card_idx)) |
| continue; |
| ret = snd_card_get_name(idx, &card_name); |
| if (!ret && (strncmp(card_name, ALSA_DEV_NAME, |
| sizeof(ALSA_DEV_NAME) - 1) == 0)) { |
| ret = asprintf(&hwid[dev->alsa_dev_count], "hw:%d", idx); |
| logd(LOG_NOTICE, "ALSA dev %s (%s)\n", |
| hwid[dev->alsa_dev_count], card_name); |
| free(card_name); |
| if (dev->alsa_dev_count++ >= ALSA_DEV_COUNT_MAX) { |
| logd(LOG_ERR, "Too many ALSA devices found for Jabra\n"); |
| break; |
| } |
| } |
| if (!ret) |
| free(card_name); |
| } |
| if (dev->alsa_dev_count) |
| break; |
| logd(LOG_INFO, "no ALSA device, retry later ...\n"); |
| /* |
| * card not found, loading the kernel module and initializing |
| * the driver might take some time, retry later. |
| */ |
| usleep(250000); |
| } |
| if (!dev->alsa_dev_count) { |
| logd(LOG_ERR, "Cannot find ALSA device for Jabra\n"); |
| return -ENODEV; |
| } |
| |
| /* initialize the Jabra USB-audio mixer control */ |
| for (idx = 0; idx < dev->alsa_dev_count; ++idx) { |
| ret = snd_hctl_open(&dev->hctl[idx], hwid[idx], 0); |
| if (ret < 0) |
| return -ENODEV; |
| ret = snd_hctl_load(dev->hctl[idx]); |
| if (ret < 0) |
| goto fail_after_open; |
| |
| snd_ctl_elem_id_alloca(&id); |
| snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER); |
| snd_ctl_elem_id_set_name(id, ALSA_CONTROL_NAME); |
| dev->playback_vol[idx] = snd_hctl_find_elem(dev->hctl[idx], id); |
| if (!dev->playback_vol[idx]) |
| goto fail_after_open; |
| |
| free(hwid[idx]); |
| } |
| return 0; |
| |
| fail_after_open: |
| logd(LOG_ERR, "alsa initialization failed (%d)\n", ret); |
| for (idx = 0; idx < dev->alsa_dev_count; ++idx) { |
| if (dev->hctl[idx]) { |
| snd_hctl_close(dev->hctl[idx]); |
| dev->hctl[idx] = NULL; |
| } |
| free(hwid[idx]); |
| } |
| return ret; |
| } |
| |
| static int hid_init(struct jabra_dev *dev) |
| { |
| int ret; |
| size_t count; |
| char* uidev_ptr; |
| struct uinput_user_dev *uidev = calloc(1, sizeof(struct uinput_user_dev)); |
| |
| time_t deadline = time(NULL) + 5 /* 5-second timeout */; |
| |
| if (!uidev) { |
| logd(LOG_ERR, "Failed to allocate uinput_user_dev buffer"); |
| return -ENOMEM; |
| } |
| |
| while (time(NULL) < deadline) { |
| dev->uinput_fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK); |
| if (dev->uinput_fd >= 0) |
| break; |
| logd(LOG_INFO, "uinput not started, retry later ...\n"); |
| /* |
| * uinput not started, retry later. |
| */ |
| usleep(250000); |
| } |
| |
| |
| if (dev->uinput_fd < 0) { |
| logd(LOG_ERR, "Cannot open uinput for HID event injection\n"); |
| return -ENOMEM; |
| } |
| |
| ioctl(dev->uinput_fd, UI_SET_EVBIT, EV_KEY); |
| ioctl(dev->uinput_fd, UI_SET_EVBIT, EV_SYN); |
| ioctl(dev->uinput_fd, UI_SET_KEYBIT, KEY_CROS_VOLDOWN); |
| ioctl(dev->uinput_fd, UI_SET_KEYBIT, KEY_CROS_VOLUP); |
| |
| snprintf(uidev->name, UINPUT_MAX_NAME_SIZE, "jabra_vold input device"); |
| uidev->id.bustype = BUS_USB; |
| uidev->id.version = 1; |
| |
| for (uidev_ptr = (char*)uidev, count = sizeof(*uidev); count; ) { |
| int written = write(dev->uinput_fd, uidev_ptr, count); |
| if (written < 0) { |
| if (errno == EINTR || errno == EAGAIN) continue; |
| logd(LOG_ERR, "Failed to configure input device\n"); |
| ret = errno; |
| goto fail_exit; |
| } else { |
| uidev_ptr += written; |
| count -= written; |
| } |
| } |
| ret = ioctl(dev->uinput_fd, UI_DEV_CREATE); |
| if (ret < 0) { |
| logd(LOG_ERR, "Failed to create input device\n"); |
| goto fail_exit; |
| } |
| |
| free(uidev); |
| return 0; |
| |
| fail_exit: |
| close(dev->uinput_fd); |
| dev->uinput_fd = 0; |
| free(uidev); |
| return ret; |
| } |
| |
| static void inject_hid_event(struct jabra_dev *dev, uint8_t key) |
| { |
| struct input_event evt = { .type = EV_KEY, .code = key, .value = 1 }; |
| struct input_event syn = { .type = EV_SYN, .code = SYN_REPORT }; |
| int ret; |
| |
| ret = gettimeofday(&evt.time, NULL); |
| if (ret) |
| logd(LOG_WARNING, "Cannot get time\n"); |
| /* key press event */ |
| ret = write(dev->uinput_fd, &evt, sizeof(evt)); |
| if (ret < 0) |
| logd(LOG_WARNING, "Cannot inject HID event\n"); |
| /* key release event */ |
| evt.value = 0; |
| ret = write(dev->uinput_fd, &evt, sizeof(evt)); |
| if (ret < 0) |
| logd(LOG_WARNING, "Cannot inject HID event\n"); |
| syn.time = evt.time; |
| ret = write(dev->uinput_fd, &syn, sizeof(syn)); |
| if (ret < 0) |
| logd(LOG_WARNING, "Cannot inject HID SYN report\n"); |
| } |
| |
| static void handle_hid_event(struct jabra_dev *dev, |
| uint8_t report, uint8_t code) |
| { |
| if (report == JABRA_HID_REPORT) { /* volume keys */ |
| switch(code) |
| { |
| case 0: /* volume key release */ |
| /* touch the volume on the USB Audio interface |
| * to ensure we receive the next one |
| */ |
| alsa_touch_volume(dev); |
| break; |
| case 1: /* volume- press */ |
| inject_hid_event(dev, KEY_CROS_VOLDOWN); |
| break; |
| case 2: /* volume+ press */ |
| inject_hid_event(dev, KEY_CROS_VOLUP); |
| break; |
| } |
| } else if (report == JABRA_TELEPHONY_REPORT) { /* other keys */ |
| /* |
| * if 'code' has the MUTE_FLAG bit set, the user has pressed |
| * the mic mute button, but the UI is not handling mic mute key |
| * so far (only speaker mute), so we don't inject any HID event. |
| */ |
| } else { |
| logd(LOG_NOTICE, "HID message %02x %02x\n", report, code); |
| } |
| } |
| |
| static int usbmon_poll(struct jabra_dev *dev) |
| { |
| struct pkt { |
| struct usbmon_packet hdr; |
| uint8_t payload[64]; |
| } pkt; |
| ssize_t rlen; |
| |
| while (1) { |
| rlen = read(dev->mon_fd, &pkt, sizeof(pkt)); |
| if (rlen <= 0) |
| return rlen; |
| if ((pkt.hdr.devnum == dev->devnum) && |
| (pkt.hdr.epnum == JABRA_ENDPOINT) && |
| (pkt.hdr.type == 'C')) { |
| |
| if ((pkt.hdr.status == 0) && (pkt.hdr.len_cap == 3)) |
| handle_hid_event(dev, pkt.payload[0], |
| pkt.payload[1]); |
| if (pkt.hdr.status == -EPROTO) { |
| logd(LOG_NOTICE, |
| "Comm failed : disconnected ?\n"); |
| return 0; |
| } |
| } |
| } |
| } |
| |
| static int usbmon_open(struct jabra_dev *dev, int busnum) |
| { |
| char *node; |
| int ret; |
| |
| ret = asprintf(&node, USBMON_DEV_FMT, busnum); |
| if (ret < 0) |
| return ret; |
| |
| dev->mon_fd = open(node, O_RDONLY); |
| if (dev->mon_fd < 0) { |
| dev->mon_fd = 0; |
| ret = errno; |
| logd(LOG_ERR, "Cannot open usbmon node %s (%d)\n", |
| node, ret); |
| goto fail_free; |
| } |
| logd(LOG_INFO,"Using %s bus %d device %d\n", node, busnum, dev->devnum); |
| ret = 0; |
| |
| fail_free: |
| free(node); |
| return ret; |
| } |
| |
| /* Search for the sound card index under /sys/devices/, the directory |
| * path starts with the DEVPATH environment variable provided by udev, |
| * and follow by the subdirectory to sound subsustem. Example: |
| * /sys/devices/pci0000:00/0000:00:14.0/usb1/1-6/1-6:1.0/sound/ |
| */ |
| static int find_card(char *devpath, int busnum, int devnum) |
| { |
| char path[256]; |
| char *tokens, *tmp, *last; |
| DIR * dir; |
| struct dirent * ptr; |
| int alsa_card_idx = -1; |
| int opendir_retry = 5; |
| |
| /* Extract the last layer of directory from devpath. i.e |
| * '1-6' from /sys/devices/pci0000:00/0000:00:14.0/usb1/1-6 |
| */ |
| last = NULL; |
| tokens = strdup(devpath); |
| tmp = strtok(tokens, "/"); |
| while (tmp) { |
| last = tmp; |
| tmp = strtok(NULL, "/"); |
| } |
| snprintf(path, sizeof(path), "%s/%s:1.0/sound/", devpath, last); |
| free(tokens); |
| |
| usb_open_dir: |
| dir = opendir(path); |
| if (dir == NULL) { |
| if (errno == ENOENT) { |
| if (opendir_retry-- == 0) { |
| logd(LOG_ERR, "Open %s timeout\n", path); |
| return -EINVAL; |
| } |
| usleep(100000); |
| goto usb_open_dir; |
| } |
| logd(LOG_ERR, "Open %s fail, %s\n", path, strerror(errno)); |
| return -errno; |
| } |
| |
| /* Search for the file named 'cardX' where X is the sound card index |
| * given by ALSA framework. */ |
| while((ptr = readdir(dir)) != NULL) { |
| if (strncmp(CARD_PREFIX, ptr->d_name, sizeof(CARD_PREFIX) - 1)) |
| continue; |
| |
| alsa_card_idx = atoi(ptr->d_name + sizeof(CARD_PREFIX) - 1); |
| logd(LOG_INFO, "Successfully found card %d by parsing %s\n", |
| alsa_card_idx, path); |
| break; |
| } |
| |
| closedir(dir); |
| return alsa_card_idx; |
| } |
| |
| static int use_jabra_device(char *devpath, int busnum, int devnum, int loglvl, int errlog) |
| { |
| struct jabra_dev *dev; |
| int idx, ret; |
| |
| /* setup the syslog facility and honor UDEV log level if set */ |
| openlog(DAEMON_NAME, errlog ? LOG_PERROR : 0, LOG_DAEMON); |
| setlogmask(LOG_UPTO(loglvl)); |
| |
| dev = calloc(1, sizeof(struct jabra_dev)); |
| if (!dev) |
| return -ENOMEM; |
| dev->devnum = devnum; |
| |
| ret = hid_init(dev); |
| if (ret) |
| goto err; |
| |
| /* Look up the sound card index before alsa_init(). Set to -1 if |
| * card index cannot be found, in which case alsa_init() will |
| * keep all volume controls from all sound cards to use. */ |
| if (devpath) { |
| ret = find_card(devpath, busnum, devnum); |
| dev->alsa_card_idx = (ret < 0) ? -1 : ret; |
| } |
| |
| ret = alsa_init(dev); |
| if (ret) |
| goto err; |
| |
| ret = usbmon_open(dev, busnum); |
| if (ret) |
| goto err; |
| |
| /* Set volume is required to receive HID packets afterwards. */ |
| alsa_touch_volume(dev); |
| |
| usbmon_poll(dev); |
| err: |
| if (dev->mon_fd) |
| close(dev->mon_fd); |
| for (idx = 0; idx < dev->alsa_dev_count; ++idx) { |
| if (dev->hctl[idx]) |
| snd_hctl_close(dev->hctl[idx]); |
| } |
| if (dev->uinput_fd) { |
| ioctl(dev->uinput_fd, UI_DEV_DESTROY); |
| close(dev->uinput_fd); |
| } |
| free(dev); |
| closelog(); |
| return ret; |
| } |
| |
| int main(int argc, char *argv[]) |
| { |
| int opt; |
| char *action_str = "start"; |
| char *busnum_str = getenv("BUSNUM"); |
| char *devnum_str = getenv("DEVNUM"); |
| char *loglevel_str = getenv("LOGLEVEL"); |
| char *devpath = getenv("DEVPATH"); |
| char pid_filename[128]; |
| int use_stderr = 0; |
| int busnum, devnum; |
| int loglevel = LOG_NOTICE; |
| int pid; |
| |
| while ((opt = getopt(argc, argv, "a:b:d:n:p:")) != -1) { |
| switch (opt) { |
| case 'a': |
| action_str = optarg; |
| break; |
| case 'b': |
| busnum_str = optarg; |
| break; |
| case 'd': |
| loglevel_str = optarg; |
| use_stderr = 1; |
| break; |
| case 'n': |
| devnum_str = optarg; |
| break; |
| case 'p': |
| if (optarg) |
| devpath = optarg; |
| break; |
| } |
| } |
| |
| if (!busnum_str || !devnum_str) { |
| fprintf(stderr, "USB bus/device not defined\n"); |
| return -ENODEV; |
| } |
| busnum = atoi(busnum_str); |
| devnum = atoi(devnum_str); |
| if (loglevel_str) |
| loglevel = atoi(loglevel_str); |
| snprintf(pid_filename, sizeof(pid_filename), "/run/jabra_vold/jabra_vold.%d.%d.pid", |
| busnum, devnum); |
| |
| if (strcmp(action_str, "start") == 0) { |
| if (daemon(0, 0)) { |
| perror("Failed to daemonize"); |
| return errno; |
| } |
| |
| FILE* pid_file = fopen(pid_filename, "r"); |
| if (pid_file) { |
| int pid_to_kill; |
| if (fscanf(pid_file, "%d", &pid_to_kill) > 0) { |
| logd(LOG_INFO, "Stopping stale jabra_vold process %d\n", pid_to_kill); |
| kill(pid_to_kill, SIGKILL); |
| } |
| fclose(pid_file); |
| } |
| pid_file = fopen(pid_filename, "we"); |
| if (!pid_file) { |
| fprintf(stderr, "Failed to open PID file to write for jabra_vold %d:%d: %m\n", |
| busnum, devnum); |
| return errno; |
| } |
| pid = getpid(); |
| logd(LOG_INFO, "Started jabra_vold process %d.\n", pid); |
| if (fprintf(pid_file, "%d\n", pid) <= 0) { |
| int ret = errno; |
| perror("Failed to write PID to the PID file."); |
| fclose(pid_file); |
| return ret; |
| } |
| fclose(pid_file); |
| } else if (strcmp(action_str, "stop") == 0) { |
| FILE* pid_file = fopen(pid_filename, "r"); |
| if (!pid_file) { |
| logd(LOG_ERR, "Failed to open PID file to read for jabra_vold %d:%d\n", |
| busnum, devnum); |
| return -ENOMEM; |
| } |
| if (fscanf(pid_file, "%d", &pid) <= 0) { |
| logd(LOG_ERR, "Failed to obtain PID for jabra_vold %d:%d\n", |
| busnum, devnum); |
| return -ENOMEM; |
| } |
| fclose(pid_file); |
| remove(pid_filename); |
| logd(LOG_INFO, "Stopping jabra_vold process %d\n", pid); |
| kill(pid, SIGKILL); |
| return 0; |
| } else { |
| fprintf(stderr, "Unrecognized action string '%s'\n", action_str); |
| return -EINVAL; |
| } |
| |
| return use_jabra_device(devpath, busnum, devnum, loglevel, use_stderr); |
| } |