static const char *
btkbd_parse_desc(struct btkbd_softc *sc, int id, const void *desc, int dlen)
{
struct hid_data *d;
struct hid_item h;
int imod;
imod = 0;
sc->sc_nkeycode = 0;
d = hid_start_parse(desc, dlen, hid_input);
while (hid_get_item(d, &h)) {
if (h.kind != hid_input || (h.flags & HIO_CONST) ||
HID_GET_USAGE_PAGE(h.usage) != HUP_KEYBOARD ||
h.report_ID != id)
continue;
if (h.flags & HIO_VARIABLE) {
if (h.loc.size != 1)
return ("bad modifier size");
/* Single item */
if (imod < MAXMOD) {
sc->sc_modloc[imod] = h.loc;
sc->sc_mods[imod].mask = 1 << imod;
sc->sc_mods[imod].key = HID_GET_USAGE(h.usage);
imod++;
} else
return ("too many modifier keys");
} else {
/* Array */
if (h.loc.size != 8)
return ("key code size != 8");
if (h.loc.count > MAXKEYCODE)
return ("too many key codes");
if (h.loc.pos % 8 != 0)
return ("key codes not on byte boundary");
if (sc->sc_nkeycode != 0)
return ("multiple key code arrays\n");
sc->sc_keycodeloc = h.loc;
sc->sc_nkeycode = h.loc.count;
}
}
sc->sc_nmod = imod;
hid_end_parse(d);
hid_locate(desc, dlen, HID_USAGE2(HUP_LEDS, HUD_LED_NUM_LOCK),
id, hid_output, &sc->sc_numloc, NULL);
hid_locate(desc, dlen, HID_USAGE2(HUP_LEDS, HUD_LED_CAPS_LOCK),
id, hid_output, &sc->sc_capsloc, NULL);
hid_locate(desc, dlen, HID_USAGE2(HUP_LEDS, HUD_LED_SCROLL_LOCK),
id, hid_output, &sc->sc_scroloc, NULL);
return (NULL);
}
static void
hid_dump_descriptor(report_desc_t r)
{
struct hid_data *d = NULL;
struct hid_item h;
for (d = hid_start_parse(r, ~0, -1); hid_get_item(d, &h); ) {
switch (h.kind) {
case hid_collection:
fprintf(stdout,
"Collection page=%s usage=%s\n", hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
break;
case hid_endcollection:
fprintf(stdout, "End collection\n");
break;
case hid_input:
hid_dump_item("Input ", &h);
break;
case hid_output:
hid_dump_item("Output ", &h);
break;
case hid_feature:
hid_dump_item("Feature", &h);
break;
}
}
hid_end_parse(d);
}
const char *
ukbd_parse_desc(struct ukbd_softc *sc)
{
struct hid_data *d;
struct hid_item h;
int size;
void *desc;
int imod;
uhidev_get_report_desc(sc->sc_hdev.sc_parent, &desc, &size);
imod = 0;
sc->sc_nkeycode = 0;
d = hid_start_parse(desc, size, hid_input);
while (hid_get_item(d, &h)) {
/*printf("ukbd: id=%d kind=%d usage=0x%x flags=0x%x pos=%d size=%d cnt=%d\n",
h.report_ID, h.kind, h.usage, h.flags, h.loc.pos, h.loc.size, h.loc.count);*/
if (h.kind != hid_input || (h.flags & HIO_CONST) ||
HID_GET_USAGE_PAGE(h.usage) != HUP_KEYBOARD ||
h.report_ID != sc->sc_hdev.sc_report_id)
continue;
DPRINTF(("ukbd: imod=%d usage=0x%x flags=0x%x pos=%d size=%d "
"cnt=%d\n", imod,
h.usage, h.flags, h.loc.pos, h.loc.size, h.loc.count));
if (h.flags & HIO_VARIABLE) {
if (h.loc.size != 1)
return ("bad modifier size");
/* Single item */
if (imod < MAXMOD) {
sc->sc_modloc[imod] = h.loc;
sc->sc_mods[imod].mask = 1 << imod;
sc->sc_mods[imod].key = HID_GET_USAGE(h.usage);
imod++;
} else
return ("too many modifier keys");
} else {
/* Array */
if (h.loc.size != 8)
return ("key code size != 8");
if (h.loc.count > MAXKEYCODE)
return ("too many key codes");
if (h.loc.pos % 8 != 0)
return ("key codes not on byte boundary");
if (sc->sc_nkeycode != 0)
return ("multiple key code arrays\n");
sc->sc_keycodeloc = h.loc;
sc->sc_nkeycode = h.loc.count;
}
}
sc->sc_nmod = imod;
hid_end_parse(d);
hid_locate(desc, size, HID_USAGE2(HUP_LEDS, HUD_LED_NUM_LOCK),
sc->sc_hdev.sc_report_id, hid_output, &sc->sc_numloc, NULL);
hid_locate(desc, size, HID_USAGE2(HUP_LEDS, HUD_LED_CAPS_LOCK),
sc->sc_hdev.sc_report_id, hid_output, &sc->sc_capsloc, NULL);
hid_locate(desc, size, HID_USAGE2(HUP_LEDS, HUD_LED_SCROLL_LOCK),
sc->sc_hdev.sc_report_id, hid_output, &sc->sc_scroloc, NULL);
return (NULL);
}
/*
* return appropriate mode for HID descriptor
*/
const char *
hid_mode(prop_data_t desc)
{
report_desc_t r;
hid_data_t d;
struct hid_item h;
const char *mode;
hid_init(NULL);
mode = BTDEVauth; /* default */
r = hid_use_report_desc(prop_data_data_nocopy(desc),
prop_data_size(desc));
if (r == NULL)
err(EXIT_FAILURE, "hid_use_report_desc");
d = hid_start_parse(r, ~0, -1);
while (hid_get_item(d, &h) > 0) {
if (h.kind == hid_collection
&& HID_PAGE(h.usage) == HUP_GENERIC_DESKTOP
&& HID_USAGE(h.usage) == HUG_KEYBOARD)
mode = BTDEVencrypt;
}
hid_end_parse(d);
hid_dispose_report_desc(r);
return mode;
}
int
uhidev_maxrepid(void *buf, int len)
{
struct hid_data *d;
struct hid_item h;
int maxid;
maxid = -1;
h.report_ID = 0;
for (d = hid_start_parse(buf, len, hid_none); hid_get_item(d, &h); )
if (h.report_ID > maxid)
maxid = h.report_ID;
hid_end_parse(d);
return (maxid);
}
static void
dumpitems(report_desc_t r)
{
struct hid_data *d;
struct hid_item h;
int size;
for (d = hid_start_parse(r, ~0, -1); hid_get_item(d, &h); ) {
switch (h.kind) {
case hid_collection:
printf("Collection type=%s page=%s usage=%s\n",
hid_collection_type(h.collection),
hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
break;
case hid_endcollection:
printf("End collection\n");
break;
case hid_input:
dumpitem("Input ", &h);
break;
case hid_output:
dumpitem("Output ", &h);
break;
case hid_feature:
dumpitem("Feature", &h);
break;
}
}
hid_end_parse(d);
size = hid_report_size(r, hid_input, -1);
printf("Total input size %d bytes\n", size);
size = hid_report_size(r, hid_output, -1);
printf("Total output size %d bytes\n", size);
size = hid_report_size(r, hid_feature, -1);
printf("Total feature size %d bytes\n", size);
}
int
hid_get_report_id(int fd)
{
report_desc_t rep;
hid_data_t d;
hid_item_t h;
int kindset;
int temp = -1;
int ret;
if ((rep = hid_get_report_desc(fd)) == NULL)
goto use_ioctl;
kindset = 1 << hid_input | 1 << hid_output | 1 << hid_feature;
for (d = hid_start_parse(rep, kindset, -1); hid_get_item(d, &h); ) {
/* Return the first report ID we met. */
if (h.report_ID != 0) {
temp = h.report_ID;
break;
}
}
hid_end_parse(d);
hid_dispose_report_desc(rep);
if (temp > 0)
return (temp);
use_ioctl:
ret = ioctl(fd, USB_GET_REPORT_ID, &temp);
#ifdef HID_COMPAT7
if (ret < 0)
ret = hid_get_report_id_compat7(fd);
else
#endif
ret = temp;
return (ret);
}
void
SDL_SYS_JoystickUpdate(SDL_Joystick *joy)
{
struct hid_item hitem;
struct hid_data *hdata;
struct report *rep;
int nbutton, naxe = -1;
Sint32 v;
#if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
struct joystick gameport;
if (joy->hwdata->type == BSDJOY_JOY) {
if (read(joy->hwdata->fd, &gameport, sizeof gameport) != sizeof gameport)
return;
if (abs(joy->hwdata->x - gameport.x) > 8) {
joy->hwdata->x = gameport.x;
if (joy->hwdata->x < joy->hwdata->xmin) {
joy->hwdata->xmin = joy->hwdata->x;
}
if (joy->hwdata->x > joy->hwdata->xmax) {
joy->hwdata->xmax = joy->hwdata->x;
}
if (joy->hwdata->xmin == joy->hwdata->xmax) {
joy->hwdata->xmin--;
joy->hwdata->xmax++;
}
v = (Sint32)joy->hwdata->x;
v -= (joy->hwdata->xmax + joy->hwdata->xmin + 1)/2;
v *= 32768/((joy->hwdata->xmax - joy->hwdata->xmin + 1)/2);
SDL_PrivateJoystickAxis(joy, 0, v);
}
if (abs(joy->hwdata->y - gameport.y) > 8) {
joy->hwdata->y = gameport.y;
if (joy->hwdata->y < joy->hwdata->ymin) {
joy->hwdata->ymin = joy->hwdata->y;
}
if (joy->hwdata->y > joy->hwdata->ymax) {
joy->hwdata->ymax = joy->hwdata->y;
}
if (joy->hwdata->ymin == joy->hwdata->ymax) {
joy->hwdata->ymin--;
joy->hwdata->ymax++;
}
v = (Sint32)joy->hwdata->y;
v -= (joy->hwdata->ymax + joy->hwdata->ymin + 1)/2;
v *= 32768/((joy->hwdata->ymax - joy->hwdata->ymin + 1)/2);
SDL_PrivateJoystickAxis(joy, 1, v);
}
if (gameport.b1 != joy->buttons[0]) {
SDL_PrivateJoystickButton(joy, 0, gameport.b1);
}
if (gameport.b2 != joy->buttons[1]) {
SDL_PrivateJoystickButton(joy, 1, gameport.b2);
}
return;
}
#endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */
rep = &joy->hwdata->inreport;
if (read(joy->hwdata->fd, REP_BUF_DATA(rep), rep->size) != rep->size) {
return;
}
#if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_version >= 500111)
hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input, rep->rid);
#else
hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input);
#endif
if (hdata == NULL) {
fprintf(stderr, "%s: Cannot start HID parser\n",
joy->hwdata->path);
return;
}
for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) {
switch (hitem.kind) {
case hid_input:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP: {
unsigned usage = HID_USAGE(hitem.usage);
int joyaxe = usage_to_joyaxe(usage);
if (joyaxe >= 0) {
naxe = joy->hwdata->axis_map[joyaxe];
/* scaleaxe */
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
v -= (hitem.logical_maximum + hitem.logical_minimum + 1)/2;
v *= 32768/((hitem.logical_maximum - hitem.logical_minimum + 1)/2);
if (v != joy->axes[naxe]) {
SDL_PrivateJoystickAxis(joy, naxe, v);
}
} else if (usage == HUG_HAT_SWITCH) {
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
SDL_PrivateJoystickHat(joy, 0,
hatval_to_sdl(v)-hitem.logical_minimum);
}
break;
}
case HUP_BUTTON:
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
if (joy->buttons[nbutton] != v) {
SDL_PrivateJoystickButton(joy,
nbutton, v);
}
nbutton++;
break;
default:
continue;
}
break;
default:
break;
}
}
hid_end_parse(hdata);
return;
}
int
SDL_SYS_JoystickOpen(SDL_Joystick *joy)
{
char *path = joynames[joy->index];
struct joystick_hwdata *hw;
struct hid_item hitem;
struct hid_data *hdata;
struct report *rep;
int fd;
int i;
fd = open(path, O_RDONLY);
if (fd == -1) {
SDL_SetError("%s: %s", path, strerror(errno));
return (-1);
}
hw = (struct joystick_hwdata *)SDL_malloc(sizeof(struct joystick_hwdata));
if (hw == NULL) {
SDL_OutOfMemory();
close(fd);
return (-1);
}
joy->hwdata = hw;
hw->fd = fd;
hw->path = strdup(path);
hw->x = 0;
hw->y = 0;
hw->xmin = 0xffff;
hw->ymin = 0xffff;
hw->xmax = 0;
hw->ymax = 0;
if (! SDL_strncmp(path, "/dev/joy", 8)) {
hw->type = BSDJOY_JOY;
joy->naxes = 2;
joy->nbuttons = 2;
joy->nhats = 0;
joy->nballs = 0;
joydevnames[joy->index] = strdup("Gameport joystick");
goto usbend;
} else {
hw->type = BSDJOY_UHID;
}
{
int ax;
for (ax = 0; ax < JOYAXE_count; ax++)
hw->axis_map[ax] = -1;
}
hw->repdesc = hid_get_report_desc(fd);
if (hw->repdesc == NULL) {
SDL_SetError("%s: USB_GET_REPORT_DESC: %s", hw->path,
strerror(errno));
goto usberr;
}
rep = &hw->inreport;
if (ioctl(fd, USB_GET_REPORT_ID, &rep->rid) < 0) {
rep->rid = -1; /* XXX */
}
if (report_alloc(rep, hw->repdesc, REPORT_INPUT) < 0) {
goto usberr;
}
if (rep->size <= 0) {
SDL_SetError("%s: Input report descriptor has invalid length",
hw->path);
goto usberr;
}
#if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_version >= 500111)
hdata = hid_start_parse(hw->repdesc, 1 << hid_input, rep->rid);
#else
hdata = hid_start_parse(hw->repdesc, 1 << hid_input);
#endif
if (hdata == NULL) {
SDL_SetError("%s: Cannot start HID parser", hw->path);
goto usberr;
}
joy->naxes = 0;
joy->nbuttons = 0;
joy->nhats = 0;
joy->nballs = 0;
for (i=0; i<JOYAXE_count; i++)
hw->axis_map[i] = -1;
while (hid_get_item(hdata, &hitem) > 0) {
char *sp;
const char *s;
switch (hitem.kind) {
case hid_collection:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP:
switch (HID_USAGE(hitem.usage)) {
case HUG_JOYSTICK:
case HUG_GAME_PAD:
s = hid_usage_in_page(hitem.usage);
sp = SDL_malloc(SDL_strlen(s) + 5);
SDL_snprintf(sp, SDL_strlen(s) + 5, "%s (%d)", s,
joy->index);
joydevnames[joy->index] = sp;
}
}
break;
case hid_input:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP: {
unsigned usage = HID_USAGE(hitem.usage);
int joyaxe = usage_to_joyaxe(usage);
if (joyaxe >= 0) {
hw->axis_map[joyaxe] = 1;
} else if (usage == HUG_HAT_SWITCH) {
joy->nhats++;
}
break;
}
case HUP_BUTTON:
joy->nbuttons++;
break;
default:
break;
}
break;
default:
break;
}
}
hid_end_parse(hdata);
for (i=0; i<JOYAXE_count; i++)
if (hw->axis_map[i] > 0)
hw->axis_map[i] = joy->naxes++;
usbend:
/* The poll blocks the event thread. */
fcntl(fd, F_SETFL, O_NONBLOCK);
return (0);
usberr:
close(hw->fd);
SDL_free(hw->path);
SDL_free(hw);
return (-1);
}
int32_t
kbd_status_changed(bthid_session_p s, uint8_t *data, int32_t len)
{
vkbd_status_t st;
uint8_t leds, report_id;
hid_device_p hid_device;
hid_data_t d;
hid_item_t h;
assert(s != NULL);
assert(len == sizeof(vkbd_status_t));
memcpy(&st, data, sizeof(st));
leds = 0;
report_id = NO_REPORT_ID;
hid_device = get_hid_device(&s->bdaddr);
assert(hid_device != NULL);
for (d = hid_start_parse(hid_device->desc, 1 << hid_output, -1);
hid_get_item(d, &h) > 0; ) {
if (HID_PAGE(h.usage) == HUP_LEDS) {
if (report_id == NO_REPORT_ID)
report_id = h.report_ID;
else if (h.report_ID != report_id)
syslog(LOG_WARNING, "Output HID report IDs " \
"for %s do not match: %d vs. %d. " \
"Please report",
bt_ntoa(&s->bdaddr, NULL),
h.report_ID, report_id);
switch(HID_USAGE(h.usage)) {
case 0x01: /* Num Lock LED */
if (st.leds & LED_NUM)
hid_set_data(&leds, &h, 1);
break;
case 0x02: /* Caps Lock LED */
if (st.leds & LED_CAP)
hid_set_data(&leds, &h, 1);
break;
case 0x03: /* Scroll Lock LED */
if (st.leds & LED_SCR)
hid_set_data(&leds, &h, 1);
break;
/* XXX add other LEDs ? */
}
}
}
hid_end_parse(d);
data[0] = 0xa2; /* DATA output (HID output report) */
if (report_id != NO_REPORT_ID) {
data[1] = report_id;
data[2] = leds;
len = 3;
} else {
data[1] = leds;
len = 2;
}
write(s->intr, data, len);
return (0);
}
struct command *
parse_conf(const char *conf, report_desc_t repd, int reportid, int ignore)
{
FILE *f;
char *p;
int line;
char buf[SIZE], name[SIZE], value[SIZE], debounce[SIZE], action[SIZE];
char usbuf[SIZE], coll[SIZE], *tmp;
struct command *cmd, *cmds;
struct hid_data *d;
struct hid_item h;
int inst, cinst, u, lo, hi, range, t;
f = fopen(conf, "r");
if (f == NULL)
err(1, "%s", conf);
cmds = NULL;
for (line = 1; ; line++) {
if (fgets(buf, sizeof buf, f) == NULL)
break;
if (buf[0] == '#' || buf[0] == '\n')
continue;
p = strchr(buf, '\n');
while (p && isspace(peek(f))) {
if (fgets(p, sizeof buf - strlen(buf), f) == NULL)
break;
p = strchr(buf, '\n');
}
if (p)
*p = 0;
if (sscanf(buf, "%s %s %s %[^\n]",
name, value, debounce, action) != 4) {
if (isdemon) {
syslog(LOG_WARNING, "config file `%s', line %d"
", syntax error: %s", conf, line, buf);
freecommands(cmds);
return (NULL);
} else {
errx(1, "config file `%s', line %d,"
", syntax error: %s", conf, line, buf);
}
}
tmp = strchr(name, '#');
if (tmp != NULL) {
*tmp = 0;
inst = atoi(tmp + 1);
} else
inst = 0;
cmd = malloc(sizeof *cmd);
if (cmd == NULL)
err(1, "malloc failed");
cmd->next = cmds;
cmds = cmd;
cmd->line = line;
if (strcmp(value, "*") == 0) {
cmd->anyvalue = 1;
} else {
cmd->anyvalue = 0;
if (sscanf(value, "%d", &cmd->value) != 1) {
if (isdemon) {
syslog(LOG_WARNING,
"config file `%s', line %d, "
"bad value: %s (should be * or a number)\n",
conf, line, value);
freecommands(cmds);
return (NULL);
} else {
errx(1, "config file `%s', line %d, "
"bad value: %s (should be * or a number)\n",
conf, line, value);
}
}
}
if (sscanf(debounce, "%d", &cmd->debounce) != 1) {
if (isdemon) {
syslog(LOG_WARNING,
"config file `%s', line %d, "
"bad value: %s (should be a number >= 0)\n",
conf, line, debounce);
freecommands(cmds);
return (NULL);
} else {
errx(1, "config file `%s', line %d, "
"bad value: %s (should be a number >= 0)\n",
conf, line, debounce);
}
}
coll[0] = 0;
cinst = 0;
for (d = hid_start_parse(repd, 1 << hid_input, reportid);
hid_get_item(d, &h); ) {
if (verbose > 2)
printf("kind=%d usage=%x\n", h.kind, h.usage);
if (h.flags & HIO_CONST)
continue;
switch (h.kind) {
case hid_input:
if (h.usage_minimum != 0 ||
h.usage_maximum != 0) {
lo = h.usage_minimum;
hi = h.usage_maximum;
range = 1;
} else {
lo = h.usage;
hi = h.usage;
range = 0;
}
for (u = lo; u <= hi; u++) {
if (coll[0]) {
snprintf(usbuf, sizeof usbuf,
"%s.%s:%s", coll+1,
hid_usage_page(HID_PAGE(u)),
hid_usage_in_page(u));
} else {
snprintf(usbuf, sizeof usbuf,
"%s:%s",
hid_usage_page(HID_PAGE(u)),
hid_usage_in_page(u));
}
if (verbose > 2)
printf("usage %s\n", usbuf);
t = strlen(usbuf) - strlen(name);
if (t > 0) {
if (strcmp(usbuf + t, name))
continue;
if (usbuf[t - 1] != '.')
continue;
} else if (strcmp(usbuf, name))
continue;
if (inst == cinst++)
goto foundhid;
}
break;
case hid_collection:
snprintf(coll + strlen(coll),
sizeof coll - strlen(coll), ".%s:%s",
hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
break;
case hid_endcollection:
if (coll[0])
*strrchr(coll, '.') = 0;
break;
default:
break;
}
}
if (ignore) {
if (verbose)
warnx("ignore item '%s'", name);
continue;
}
if (isdemon) {
syslog(LOG_WARNING, "config file `%s', line %d, HID "
"item not found: `%s'\n", conf, line, name);
freecommands(cmds);
return (NULL);
} else {
errx(1, "config file `%s', line %d, HID item "
"not found: `%s'\n", conf, line, name);
}
foundhid:
hid_end_parse(d);
cmd->lastseen = -1;
cmd->lastused = -1;
cmd->item = h;
cmd->name = strdup(name);
cmd->action = strdup(action);
if (range) {
if (cmd->value == 1)
cmd->value = u - lo;
else
cmd->value = -1;
}
if (verbose)
printf("PARSE:%d %s, %d, '%s'\n", cmd->line, name,
cmd->value, cmd->action);
}
fclose(f);
return (cmds);
}
int
main (int argc, char **argv)
{
char *device_file;
int fd = -1;
int report_id;
report_desc_t report_desc;
struct hid_data *data;
hid_item_t item;
boolean is_keyboard = FALSE;
boolean is_keypad = FALSE;
boolean is_mouse = FALSE;
boolean is_joystick = FALSE;
if (! hfp_init(argc, argv))
goto end;
device_file = getenv("HAL_PROP_HIDDEV_DEVICE");
if (! device_file)
goto end;
fd = open(device_file, O_RDONLY);
if (fd < 0)
goto end;
/* give a meaningful process title for ps(1) */
setproctitle("%s", device_file);
#ifdef HAVE_LIBUSB20
report_id = hid_get_report_id(fd);
if (report_id == -1)
#else
if (ioctl(fd, USB_GET_REPORT_ID, &report_id) < 0)
#endif
goto end;
hid_init(NULL);
report_desc = hid_get_report_desc(fd);
if (! report_desc)
goto end;
for (data = hid_start_parse(report_desc, ~0, report_id); hid_get_item(data, &item);)
if (item.kind == hid_collection)
{
if (item.collection == HID_COLLECTION_APPLICATION)
{
const char *page;
char *full_page;
int i;
page = hid_usage_page(HID_PAGE(item.usage));
full_page = hfp_strdup_printf("%s Page", page);
for (i = 0; full_page[i] != 0; i++)
if (full_page[i] == '_')
full_page[i] = ' ';
libhal_device_property_strlist_append(hfp_ctx, hfp_udi, "hiddev.application_pages", full_page, &hfp_error);
hfp_free(full_page);
}
switch (item.usage)
{
case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE):
is_mouse = TRUE;
break;
case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_JOYSTICK):
case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_GAME_PAD):
is_joystick = TRUE;
break;
case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD):
is_keyboard = TRUE;
break;
case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYPAD):
is_keypad = TRUE;
break;
}
}
hid_end_parse(data);
hid_dispose_report_desc(report_desc);
if (is_keyboard || is_mouse || is_joystick || is_keypad)
{
libhal_device_add_capability(hfp_ctx, hfp_udi, "input", &hfp_error);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "info.category", "input", &hfp_error);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "input.device", device_file, &hfp_error);
}
if (is_keyboard)
libhal_device_add_capability(hfp_ctx, hfp_udi, "input.keyboard", &hfp_error);
if (is_keypad)
libhal_device_add_capability(hfp_ctx, hfp_udi, "input.keypad", &hfp_error);
if (is_keyboard || is_keypad)
libhal_device_add_capability(hfp_ctx, hfp_udi, "input.keys", &hfp_error);
if (is_mouse)
libhal_device_add_capability(hfp_ctx, hfp_udi, "input.mouse", &hfp_error);
if (is_joystick)
libhal_device_add_capability(hfp_ctx, hfp_udi, "input.joystick", &hfp_error);
end:
return 0;
}
int
hidms_setup(struct device *self, struct hidms *ms, uint32_t quirks,
int id, void *desc, int dlen)
{
struct hid_item h;
struct hid_data *d;
uint32_t flags;
int i, wheel, twheel;
ms->sc_device = self;
ms->sc_rawmode = 1;
ms->sc_flags = quirks;
if (!hid_locate(desc, dlen, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X), id,
hid_input, &ms->sc_loc_x, &flags)) {
printf("\n%s: mouse has no X report\n", self->dv_xname);
return ENXIO;
}
switch(flags & MOUSE_FLAGS_MASK) {
case 0:
ms->sc_flags |= HIDMS_ABSX;
break;
case HIO_RELATIVE:
break;
default:
printf("\n%s: X report 0x%04x not supported\n",
self->dv_xname, flags);
return ENXIO;
}
if (!hid_locate(desc, dlen, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y), id,
hid_input, &ms->sc_loc_y, &flags)) {
printf("\n%s: mouse has no Y report\n", self->dv_xname);
return ENXIO;
}
switch(flags & MOUSE_FLAGS_MASK) {
case 0:
ms->sc_flags |= HIDMS_ABSY;
break;
case HIO_RELATIVE:
break;
default:
printf("\n%s: Y report 0x%04x not supported\n",
self->dv_xname, flags);
return ENXIO;
}
/*
* Try to guess the Z activator: check WHEEL, TWHEEL, and Z,
* in that order.
*/
wheel = hid_locate(desc, dlen,
HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_WHEEL), id,
hid_input, &ms->sc_loc_z, &flags);
if (wheel == 0)
twheel = hid_locate(desc, dlen,
HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_TWHEEL), id,
hid_input, &ms->sc_loc_z, &flags);
else
twheel = 0;
if (wheel || twheel) {
if (NOTMOUSE(flags)) {
DPRINTF(("\n%s: Wheel report 0x%04x not supported\n",
self->dv_xname, flags));
ms->sc_loc_z.size = 0; /* Bad Z coord, ignore it */
} else {
ms->sc_flags |= HIDMS_Z;
/* Wheels need the Z axis reversed. */
ms->sc_flags ^= HIDMS_REVZ;
}
/*
* We might have both a wheel and Z direction; in this case,
* report the Z direction on the W axis.
*
* Otherwise, check for a W direction as an AC Pan input used
* on some newer mice.
*/
if (hid_locate(desc, dlen,
HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Z), id,
hid_input, &ms->sc_loc_w, &flags)) {
if (NOTMOUSE(flags)) {
DPRINTF(("\n%s: Z report 0x%04x not supported\n",
self->dv_xname, flags));
/* Bad Z coord, ignore it */
ms->sc_loc_w.size = 0;
}
else
ms->sc_flags |= HIDMS_W;
} else if (hid_locate(desc, dlen,
HID_USAGE2(HUP_CONSUMER, HUC_AC_PAN), id, hid_input,
&ms->sc_loc_w, &flags)) {
ms->sc_flags |= HIDMS_W;
}
} else if (hid_locate(desc, dlen,
HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Z), id,
hid_input, &ms->sc_loc_z, &flags)) {
if (NOTMOUSE(flags)) {
DPRINTF(("\n%s: Z report 0x%04x not supported\n",
self->dv_xname, flags));
ms->sc_loc_z.size = 0; /* Bad Z coord, ignore it */
} else {
ms->sc_flags |= HIDMS_Z;
}
}
/*
* The Microsoft Wireless Intellimouse 2.0 reports its wheel
* using 0x0048 (I've called it HUG_TWHEEL) and seems to expect
* us to know that the byte after the wheel is the tilt axis.
* There are no other HID axis descriptors other than X, Y and
* TWHEEL, so we report TWHEEL on the W axis.
*/
if (twheel) {
ms->sc_loc_w = ms->sc_loc_z;
ms->sc_loc_w.pos = ms->sc_loc_w.pos + 8;
ms->sc_flags |= HIDMS_W | HIDMS_LEADINGBYTE;
/* Wheels need their axis reversed. */
ms->sc_flags ^= HIDMS_REVW;
}
/* figure out the number of buttons */
for (i = 1; i <= MAX_BUTTONS; i++)
if (!hid_locate(desc, dlen, HID_USAGE2(HUP_BUTTON, i), id,
hid_input, &ms->sc_loc_btn[i - 1], NULL))
break;
ms->sc_num_buttons = i - 1;
if (hid_locate(desc, dlen, HID_USAGE2(HUP_DIGITIZERS,
HUD_TIP_SWITCH), id, hid_input,
&ms->sc_loc_btn[ms->sc_num_buttons], NULL)){
ms->sc_flags |= HIDMS_TIP;
ms->sc_num_buttons++;
}
if (hid_locate(desc, dlen, HID_USAGE2(HUP_DIGITIZERS,
HUD_ERASER), id, hid_input,
&ms->sc_loc_btn[ms->sc_num_buttons], NULL)){
ms->sc_flags |= HIDMS_ERASER;
ms->sc_num_buttons++;
}
if (hid_locate(desc, dlen, HID_USAGE2(HUP_DIGITIZERS,
HUD_BARREL_SWITCH), id, hid_input,
&ms->sc_loc_btn[ms->sc_num_buttons], NULL)){
ms->sc_flags |= HIDMS_BARREL;
ms->sc_num_buttons++;
}
/*
* The Microsoft Wireless Notebook Optical Mouse seems to be in worse
* shape than the Wireless Intellimouse 2.0, as its X, Y, wheel, and
* all of its other button positions are all off. It also reports that
* it has two addional buttons and a tilt wheel.
*/
if (ms->sc_flags & HIDMS_MS_BAD_CLASS) {
/* HIDMS_LEADINGBYTE cleared on purpose */
ms->sc_flags = HIDMS_Z | HIDMS_SPUR_BUT_UP;
ms->sc_num_buttons = 3;
/* XXX change sc_hdev isize to 5? */
/* 1st byte of descriptor report contains garbage */
ms->sc_loc_x.pos = 16;
ms->sc_loc_y.pos = 24;
ms->sc_loc_z.pos = 32;
ms->sc_loc_btn[0].pos = 8;
ms->sc_loc_btn[1].pos = 9;
ms->sc_loc_btn[2].pos = 10;
}
/* Parse descriptors to get touch panel bounds */
d = hid_start_parse(desc, dlen, hid_input);
while (hid_get_item(d, &h)) {
if (h.kind != hid_input ||
HID_GET_USAGE_PAGE(h.usage) != HUP_GENERIC_DESKTOP)
continue;
DPRINTF(("hidms: usage=0x%x range %d..%d\n",
h.usage, h.logical_minimum, h.logical_maximum));
switch (HID_GET_USAGE(h.usage)) {
case HUG_X:
if (ms->sc_flags & HIDMS_ABSX) {
ms->sc_tsscale.minx = h.logical_minimum;
ms->sc_tsscale.maxx = h.logical_maximum;
}
break;
case HUG_Y:
if (ms->sc_flags & HIDMS_ABSY) {
ms->sc_tsscale.miny = h.logical_minimum;
ms->sc_tsscale.maxy = h.logical_maximum;
}
break;
}
}
hid_end_parse(d);
return 0;
}
int32_t
hid_interrupt(bthid_session_p s, uint8_t *data, int32_t len)
{
hid_device_p hid_device;
hid_data_t d;
hid_item_t h;
int32_t report_id, usage, page, val,
mouse_x, mouse_y, mouse_z, mouse_butt,
mevents, kevents, i;
assert(s != NULL);
assert(s->srv != NULL);
assert(data != NULL);
if (len < 3) {
syslog(LOG_ERR, "Got short message (%d bytes) on Interrupt " \
"channel from %s", len, bt_ntoa(&s->bdaddr, NULL));
return (-1);
}
if (data[0] != 0xa1) {
syslog(LOG_ERR, "Got unexpected message 0x%x on " \
"Interrupt channel from %s",
data[0], bt_ntoa(&s->bdaddr, NULL));
return (-1);
}
report_id = data[1];
data ++;
len --;
hid_device = get_hid_device(&s->bdaddr);
assert(hid_device != NULL);
mouse_x = mouse_y = mouse_z = mouse_butt = mevents = kevents = 0;
for (d = hid_start_parse(hid_device->desc, 1 << hid_input, -1);
hid_get_item(d, &h) > 0; ) {
if ((h.flags & HIO_CONST) || (h.report_ID != report_id) ||
(h.kind != hid_input))
continue;
page = HID_PAGE(h.usage);
val = hid_get_data(data, &h);
/*
* When the input field is an array and the usage is specified
* with a range instead of an ID, we have to derive the actual
* usage by using the item value as an index in the usage range
* list.
*/
if ((h.flags & HIO_VARIABLE)) {
usage = HID_USAGE(h.usage);
} else {
const uint32_t usage_offset = val - h.logical_minimum;
usage = HID_USAGE(h.usage_minimum + usage_offset);
}
switch (page) {
case HUP_GENERIC_DESKTOP:
switch (usage) {
case HUG_X:
mouse_x = val;
mevents ++;
break;
case HUG_Y:
mouse_y = val;
mevents ++;
break;
case HUG_WHEEL:
mouse_z = -val;
mevents ++;
break;
case HUG_SYSTEM_SLEEP:
if (val)
syslog(LOG_NOTICE, "Sleep button pressed");
break;
}
break;
case HUP_KEYBOARD:
kevents ++;
if (h.flags & HIO_VARIABLE) {
if (val && usage < kbd_maxkey())
bit_set(s->keys1, usage);
} else {
if (val && val < kbd_maxkey())
bit_set(s->keys1, val);
for (i = 1; i < h.report_count; i++) {
h.pos += h.report_size;
val = hid_get_data(data, &h);
if (val && val < kbd_maxkey())
bit_set(s->keys1, val);
}
}
break;
case HUP_BUTTON:
if (usage != 0) {
if (usage == 2)
usage = 3;
else if (usage == 3)
usage = 2;
mouse_butt |= (val << (usage - 1));
mevents ++;
}
break;
case HUP_CONSUMER:
if (!val)
break;
switch (usage) {
case HUC_AC_PAN:
/* Horizontal scroll */
if (val < 0)
mouse_butt |= (1 << 5);
else
mouse_butt |= (1 << 6);
mevents ++;
val = 0;
break;
case 0xb5: /* Scan Next Track */
val = 0x19;
break;
case 0xb6: /* Scan Previous Track */
val = 0x10;
break;
case 0xb7: /* Stop */
val = 0x24;
break;
case 0xcd: /* Play/Pause */
val = 0x22;
break;
case 0xe2: /* Mute */
val = 0x20;
break;
case 0xe9: /* Volume Up */
val = 0x30;
break;
case 0xea: /* Volume Down */
val = 0x2E;
break;
case 0x183: /* Media Select */
val = 0x6D;
break;
case 0x018a: /* Mail */
val = 0x6C;
break;
case 0x192: /* Calculator */
val = 0x21;
break;
case 0x194: /* My Computer */
val = 0x6B;
break;
case 0x221: /* WWW Search */
val = 0x65;
break;
case 0x223: /* WWW Home */
val = 0x32;
break;
case 0x224: /* WWW Back */
val = 0x6A;
break;
case 0x225: /* WWW Forward */
val = 0x69;
break;
case 0x226: /* WWW Stop */
val = 0x68;
break;
case 0x227: /* WWW Refresh */
val = 0x67;
break;
case 0x22a: /* WWW Favorites */
val = 0x66;
break;
default:
val = 0;
break;
}
/* XXX FIXME - UGLY HACK */
if (val != 0) {
if (hid_device->keyboard) {
int32_t buf[4] = { 0xe0, val,
0xe0, val|0x80 };
assert(s->vkbd != -1);
write(s->vkbd, buf, sizeof(buf));
} else
syslog(LOG_ERR, "Keyboard events " \
"received from non-keyboard " \
"device %s. Please report",
bt_ntoa(&s->bdaddr, NULL));
}
break;
case HUP_MICROSOFT:
switch (usage) {
case 0xfe01:
if (!hid_device->battery_power)
break;
switch (val) {
case 1:
syslog(LOG_INFO, "Battery is OK on %s",
bt_ntoa(&s->bdaddr, NULL));
break;
case 2:
syslog(LOG_NOTICE, "Low battery on %s",
bt_ntoa(&s->bdaddr, NULL));
break;
case 3:
syslog(LOG_WARNING, "Very low battery "\
"on %s",
bt_ntoa(&s->bdaddr, NULL));
break;
}
break;
}
break;
}
}
hid_end_parse(d);
/*
* XXX FIXME Feed keyboard events into kernel.
* The code below works, bit host also needs to track
* and handle repeat.
*
* Key repeat currently works in X, but not in console.
*/
if (kevents > 0) {
if (hid_device->keyboard) {
assert(s->vkbd != -1);
kbd_process_keys(s);
} else
syslog(LOG_ERR, "Keyboard events received from " \
"non-keyboard device %s. Please report",
bt_ntoa(&s->bdaddr, NULL));
}
/*
* XXX FIXME Feed mouse events into kernel.
* The code block below works, but it is not good enough.
* Need to track double-clicks etc.
*
* Double click currently works in X, but not in console.
*/
if (mevents > 0) {
struct mouse_info mi;
mi.operation = MOUSE_ACTION;
mi.u.data.x = mouse_x;
mi.u.data.y = mouse_y;
mi.u.data.z = mouse_z;
mi.u.data.buttons = mouse_butt;
if (ioctl(s->srv->cons, CONS_MOUSECTL, &mi) < 0)
syslog(LOG_ERR, "Could not process mouse events from " \
"%s. %s (%d)", bt_ntoa(&s->bdaddr, NULL),
strerror(errno), errno);
}
return (0);
}
void
dumpdata(int f, report_desc_t rd, int loop)
{
struct hid_data *d;
struct hid_item h, *hids, *n;
int r, dlen;
u_char *dbuf;
u_int32_t colls[100];
int sp = 0;
char namebuf[10000], *namep;
hids = 0;
for (d = hid_start_parse(rd, 1<<hid_input, -1);
hid_get_item(d, &h); ) {
if (h.kind == hid_collection)
colls[++sp] = h.usage;
else if (h.kind == hid_endcollection)
--sp;
if (h.kind != hid_input || (h.flags & HIO_CONST))
continue;
h.next = hids;
h.collection = colls[sp];
hids = malloc(sizeof *hids);
*hids = h;
}
hid_end_parse(d);
rev(&hids);
dlen = hid_report_size(rd, hid_input, -1);
dbuf = malloc(dlen);
if (!loop)
if (hid_set_immed(f, 1) < 0) {
if (errno == EOPNOTSUPP)
warnx("device does not support immediate mode, only changes reported.");
else
err(1, "USB_SET_IMMED");
}
do {
r = read(f, dbuf, dlen);
if (r < 1) {
err(1, "read error");
}
for (n = hids; n; n = n->next) {
if (n->report_ID != 0 && dbuf[0] != n->report_ID)
continue;
namep = namebuf;
namep += sprintf(namep, "%s:%s.",
hid_usage_page(HID_PAGE(n->collection)),
hid_usage_in_page(n->collection));
namep += sprintf(namep, "%s:%s",
hid_usage_page(HID_PAGE(n->usage)),
hid_usage_in_page(n->usage));
if (all || gotname(namebuf)) {
if (!noname)
printf("%s=", namebuf);
prdata(dbuf, n);
printf("\n");
}
}
if (loop)
printf("\n");
} while (loop);
free(dbuf);
}
static void
parceargs(report_desc_t r, int all, int nnames, char **names)
{
struct hid_data *d;
struct hid_item h;
char colls[1000];
char hname[1000], *tmp1, *tmp2;
struct variable *var, **pnext;
int i, instance, cp, t;
pnext = &vars;
if (all) {
if (wflag)
errx(1, "Must not specify -w to read variables");
cp = 0;
for (d = hid_start_parse(r,
1<<hid_input | 1<<hid_output | 1<<hid_feature, -1);
hid_get_item(d, &h); ) {
if (h.kind == hid_collection) {
cp += sprintf(&colls[cp], "%s%s:%s",
cp != 0 ? "." : "",
hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
} else if (h.kind == hid_endcollection) {
tmp1 = strrchr(colls, '.');
if (tmp1 != NULL) {
cp -= strlen(tmp1);
tmp1[0] = 0;
} else {
cp = 0;
colls[0] = 0;
}
}
if ((h.kind != hid_input && h.kind != hid_output &&
h.kind != hid_feature) || (h.flags & HIO_CONST))
continue;
var = malloc(sizeof(*var));
memset(var, 0, sizeof(*var));
asprintf(&var->name, "%s%s%s:%s",
colls, colls[0] != 0 ? "." : "",
hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
var->h = h;
*pnext = var;
pnext = &var->next;
}
hid_end_parse(d);
return;
}
for (i = 0; i < nnames; i++) {
var = malloc(sizeof(*var));
memset(var, 0, sizeof(*var));
tmp1 = tmp2 = strdup(names[i]);
strsep(&tmp2, "=");
var->name = strsep(&tmp1, "#");
if (tmp1 != NULL)
var->instance = atoi(tmp1);
if (tmp2 != NULL) {
if (!wflag)
errx(1, "Must specify -w to write variables");
var->val = atoi(tmp2);
} else
if (wflag)
errx(1, "Must not specify -w to read variables");
*pnext = var;
pnext = &var->next;
instance = 0;
cp = 0;
for (d = hid_start_parse(r,
1<<hid_input | 1<<hid_output | 1<<hid_feature, -1);
hid_get_item(d, &h); ) {
if (h.kind == hid_collection) {
cp += sprintf(&colls[cp], "%s%s:%s",
cp != 0 ? "." : "",
hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
} else if (h.kind == hid_endcollection) {
tmp1 = strrchr(colls, '.');
if (tmp1 != NULL) {
cp -= strlen(tmp1);
tmp1[0] = 0;
} else {
cp = 0;
colls[0] = 0;
}
}
if ((h.kind != hid_input && h.kind != hid_output &&
h.kind != hid_feature) || (h.flags & HIO_CONST))
continue;
snprintf(hname, sizeof(hname), "%s%s%s:%s",
colls, colls[0] != 0 ? "." : "",
hid_usage_page(HID_PAGE(h.usage)),
hid_usage_in_page(h.usage));
t = strlen(hname) - strlen(var->name);
if (t > 0) {
if (strcmp(hname + t, var->name) != 0)
continue;
if (hname[t - 1] != '.')
continue;
} else if (strcmp(hname, var->name) != 0)
continue;
if (var->instance != instance++)
continue;
var->h = h;
break;
}
hid_end_parse(d);
if (var->h.usage == 0)
errx(1, "Unknown item '%s'", var->name);
}
}
void USBJoystick::initJoystick(const char *name)
{
report_desc_t rd;
hid_data *d;
hid_item h;
int report_id;
status = false;
hids = NULL;
num_axis = 0;
if ((fd = open(name, O_RDONLY | O_NONBLOCK)) < 0)
return;
if ((rd = hid_get_report_desc(fd)) == 0) {
close(fd);
return;
}
data_buf_size = hid_report_size(rd, hid_input, &report_id);
if ((data_buf = (char *)malloc(data_buf_size)) == NULL) {
hid_dispose_report_desc(rd);
}
data_buf_offset = (report_id != 0);
int is_joystick = 0;
int interesting_hid = FALSE;
for (d = hid_start_parse(rd, 1 << hid_input); hid_get_item(d, &h); ) {
int page = HID_PAGE(h.usage);
int usage = HID_USAGE(h.usage);
is_joystick = is_joystick ||
(h.kind == hid_collection && page == HUP_GENERIC_DESKTOP &&
(usage == HUG_JOYSTICK || usage == HUG_GAME_PAD));
if (h.kind != hid_input)
continue;
if (!is_joystick)
continue;
interesting_hid = TRUE;
if (page == HUP_GENERIC_DESKTOP) {
int which_axis;
switch (usage) {
case HUG_X:
case HUG_RX: which_axis = 0; break;
case HUG_Y:
case HUG_RY: which_axis = 1; break;
case HUG_Z:
case HUG_RZ: which_axis = 2; break;
default: interesting_hid = FALSE;
}
if (interesting_hid) {
axis_const[which_axis] = 1000 + (2000 * h.logical_maximum) /
(h.logical_minimum - h.logical_maximum);
axis_scale[which_axis] = (2000 * 10000) /
(h.logical_maximum - h.logical_minimum);
axis[which_axis] = (h.logical_minimum + h.logical_maximum) / 2;
if (num_axis < (which_axis + 1))
num_axis = which_axis + 1;
}
}
if (interesting_hid) {
struct hid_item *newhid = new struct hid_item;
if (newhid == NULL) {
close(fd);
return;
}
*newhid = h;
newhid->next = hids;
hids = newhid;
}
}
hid_end_parse(d);
status = true;
}
static void
bthidev_attach(device_t parent, device_t self, void *aux)
{
struct bthidev_softc *sc = device_private(self);
prop_dictionary_t dict = aux;
prop_object_t obj;
device_t dev;
struct bthidev_attach_args bha;
struct bthidev *hidev;
struct hid_data *d;
struct hid_item h;
const void *desc;
int locs[BTHIDBUSCF_NLOCS];
int maxid, rep, dlen;
/*
* Init softc
*/
sc->sc_dev = self;
LIST_INIT(&sc->sc_list);
callout_init(&sc->sc_reconnect, 0);
callout_setfunc(&sc->sc_reconnect, bthidev_timeout, sc);
sc->sc_state = BTHID_CLOSED;
sc->sc_flags = BTHID_CONNECTING;
sc->sc_ctlpsm = L2CAP_PSM_HID_CNTL;
sc->sc_intpsm = L2CAP_PSM_HID_INTR;
sockopt_init(&sc->sc_mode, BTPROTO_L2CAP, SO_L2CAP_LM, 0);
/*
* extract config from proplist
*/
obj = prop_dictionary_get(dict, BTDEVladdr);
bdaddr_copy(&sc->sc_laddr, prop_data_data_nocopy(obj));
obj = prop_dictionary_get(dict, BTDEVraddr);
bdaddr_copy(&sc->sc_raddr, prop_data_data_nocopy(obj));
obj = prop_dictionary_get(dict, BTDEVmode);
if (prop_object_type(obj) == PROP_TYPE_STRING) {
if (prop_string_equals_cstring(obj, BTDEVauth))
sockopt_setint(&sc->sc_mode, L2CAP_LM_AUTH);
else if (prop_string_equals_cstring(obj, BTDEVencrypt))
sockopt_setint(&sc->sc_mode, L2CAP_LM_ENCRYPT);
else if (prop_string_equals_cstring(obj, BTDEVsecure))
sockopt_setint(&sc->sc_mode, L2CAP_LM_SECURE);
else {
aprint_error(" unknown %s\n", BTDEVmode);
return;
}
aprint_verbose(" %s %s", BTDEVmode,
prop_string_cstring_nocopy(obj));
}
obj = prop_dictionary_get(dict, BTHIDEVcontrolpsm);
if (prop_object_type(obj) == PROP_TYPE_NUMBER) {
sc->sc_ctlpsm = prop_number_integer_value(obj);
if (L2CAP_PSM_INVALID(sc->sc_ctlpsm)) {
aprint_error(" invalid %s\n", BTHIDEVcontrolpsm);
return;
}
}
obj = prop_dictionary_get(dict, BTHIDEVinterruptpsm);
if (prop_object_type(obj) == PROP_TYPE_NUMBER) {
sc->sc_intpsm = prop_number_integer_value(obj);
if (L2CAP_PSM_INVALID(sc->sc_intpsm)) {
aprint_error(" invalid %s\n", BTHIDEVinterruptpsm);
return;
}
}
obj = prop_dictionary_get(dict, BTHIDEVdescriptor);
if (prop_object_type(obj) == PROP_TYPE_DATA) {
dlen = prop_data_size(obj);
desc = prop_data_data_nocopy(obj);
} else {
aprint_error(" no %s\n", BTHIDEVdescriptor);
return;
}
obj = prop_dictionary_get(dict, BTHIDEVreconnect);
if (prop_object_type(obj) == PROP_TYPE_BOOL
&& !prop_bool_true(obj))
sc->sc_flags |= BTHID_RECONNECT;
/*
* Parse the descriptor and attach child devices, one per report.
*/
maxid = -1;
h.report_ID = 0;
d = hid_start_parse(desc, dlen, hid_none);
while (hid_get_item(d, &h)) {
if (h.report_ID > maxid)
maxid = h.report_ID;
}
hid_end_parse(d);
if (maxid < 0) {
aprint_error(" no reports found\n");
return;
}
aprint_normal("\n");
for (rep = 0 ; rep <= maxid ; rep++) {
if (hid_report_size(desc, dlen, hid_feature, rep) == 0
&& hid_report_size(desc, dlen, hid_input, rep) == 0
&& hid_report_size(desc, dlen, hid_output, rep) == 0)
continue;
bha.ba_desc = desc;
bha.ba_dlen = dlen;
bha.ba_input = bthidev_null;
bha.ba_feature = bthidev_null;
bha.ba_output = bthidev_output;
bha.ba_id = rep;
locs[BTHIDBUSCF_REPORTID] = rep;
dev = config_found_sm_loc(self, "bthidbus",
locs, &bha, bthidev_print, config_stdsubmatch);
if (dev != NULL) {
hidev = device_private(dev);
hidev->sc_dev = dev;
hidev->sc_parent = self;
hidev->sc_id = rep;
hidev->sc_input = bha.ba_input;
hidev->sc_feature = bha.ba_feature;
LIST_INSERT_HEAD(&sc->sc_list, hidev, sc_next);
}
}
/*
* start bluetooth connections
*/
mutex_enter(bt_lock);
if ((sc->sc_flags & BTHID_RECONNECT) == 0)
bthidev_listen(sc);
if (sc->sc_flags & BTHID_CONNECTING)
bthidev_connect(sc);
mutex_exit(bt_lock);
}
int
jstkOpenDevice_bsd(JoystickDevPtr joystick, Bool probe)
{
int cur_axis;
int is_joystick, report_id = 0;
int got_something;
struct hid_data *d;
struct hid_item h;
report_desc_t rd;
struct jstk_bsd_hid_data *bsddata;
if (joystick->fd == -1) {
if ((joystick->fd = open(joystick->device, O_RDWR | O_NDELAY, 0)) < 0) {
xf86Msg(X_ERROR, "Cannot open joystick '%s' (%s)\n",
joystick->device, strerror(errno));
return -1;
}
}
if ((rd = hid_get_report_desc(joystick->fd)) == 0) {
xf86Msg(X_ERROR, "Joystick: hid_get_report_desc failed: %s\n",
strerror(errno));
jstkCloseDevice_bsd(joystick);
return -1;
}
if (ioctl(joystick->fd, USB_GET_REPORT_ID, &report_id) < 0) {
xf86Msg(X_ERROR, "Joystick: ioctl USB_GET_REPORT_ID failed: %s\n",
strerror(errno));
jstkCloseDevice_bsd(joystick);
return -1;
}
bsddata = (struct jstk_bsd_hid_data*)
malloc(sizeof(struct jstk_bsd_hid_data));
joystick->devicedata = (void*) bsddata;
bsddata->dlen = hid_report_size(rd, hid_input, report_id);
if ((bsddata->data_buf = malloc(bsddata->dlen)) == NULL) {
fprintf(stderr, "error: couldn't malloc %d bytes\n", bsddata->dlen);
hid_dispose_report_desc(rd);
jstkCloseDevice_bsd(joystick);
return -1;
}
is_joystick = 0;
got_something = 0;
cur_axis = 0;
bsddata->hats = 0;
joystick->num_axes = 0;
joystick->num_buttons = 0;
for (d = hid_start_parse(rd, 1 << hid_input, report_id);
hid_get_item(d, &h); )
{
int usage, page;
page = HID_PAGE(h.usage);
usage = HID_USAGE(h.usage);
is_joystick = is_joystick ||
(h.kind == hid_collection &&
page == HUP_GENERIC_DESKTOP &&
(usage == HUG_JOYSTICK || usage == HUG_GAME_PAD));
if (h.kind != hid_input)
continue;
if (!is_joystick)
continue;
if (page == HUP_GENERIC_DESKTOP) {
if (usage == HUG_HAT_SWITCH) {
if ((bsddata->hats < MAXAXES) && (joystick->num_axes <= MAXAXES-2)) {
got_something = 1;
memcpy(&bsddata->hat_item[bsddata->hats], &h, sizeof(h));
bsddata->hats++;
joystick->num_axes += 2;
}
} else {
if (joystick->num_axes < MAXAXES) {
got_something = 1;
memcpy(&bsddata->axis_item[cur_axis], &h, sizeof(h));
cur_axis++;
joystick->num_axes++;
}
}
} else if (page == HUP_BUTTON) {
if (joystick->num_buttons < MAXBUTTONS) {
got_something = 1;
memcpy(&bsddata->button_item[joystick->num_buttons], &h, sizeof(h));
joystick->num_buttons++;
}
}
}
hid_end_parse(d);
if (!got_something) {
free(bsddata->data_buf);
xf86Msg(X_ERROR, "Joystick: Didn't find any usable axes.\n");
jstkCloseDevice_bsd(joystick);
return -1;
}
bsddata->hotdata = 0;
if (probe == TRUE) {
xf86Msg(X_INFO, "Joystick: %d buttons, %d axes\n",
joystick->num_buttons, joystick->num_axes);
}
joystick->open_proc = jstkOpenDevice_bsd;
joystick->read_proc = jstkReadData_bsd;
joystick->close_proc = jstkCloseDevice_bsd;
return joystick->fd;
}
int
SDL_SYS_JoystickOpen(SDL_Joystick *joy)
{
char *path = joynames[joy->index];
struct joystick_hwdata *hw;
struct hid_item hitem;
struct hid_data *hdata;
struct report *rep;
int fd;
int i;
fd = open(path, O_RDONLY);
if (fd == -1) {
SDL_SetError("%s: %s", path, strerror(errno));
return (-1);
}
hw = (struct joystick_hwdata *)SDL_malloc(sizeof(struct joystick_hwdata));
if (hw == NULL) {
SDL_OutOfMemory();
close(fd);
return (-1);
}
joy->hwdata = hw;
hw->fd = fd;
hw->path = strdup(path);
hw->x = 0;
hw->y = 0;
hw->xmin = 0xffff;
hw->ymin = 0xffff;
hw->xmax = 0;
hw->ymax = 0;
if (! SDL_strncmp(path, "/dev/joy", 8)) {
hw->type = BSDJOY_JOY;
joy->naxes = 2;
joy->nbuttons = 2;
joy->nhats = 0;
joy->nballs = 0;
joydevnames[joy->index] = strdup("Gameport joystick");
goto usbend;
} else {
hw->type = BSDJOY_UHID;
}
{
int ax;
for (ax = 0; ax < JOYAXE_count; ax++)
hw->axis_map[ax] = -1;
}
hw->repdesc = hid_get_report_desc(fd);
if (hw->repdesc == NULL) {
SDL_SetError("%s: USB_GET_REPORT_DESC: %s", hw->path,
strerror(errno));
goto usberr;
}
#if defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063)
rep->rid = hid_get_report_id(fd);
if (rep->rid < 0) {
#else
rep = &hw->inreport;
if (ioctl(fd, USB_GET_REPORT_ID, &rep->rid) < 0) {
#endif
rep->rid = -1; /* XXX */
}
if (report_alloc(rep, hw->repdesc, REPORT_INPUT) < 0) {
goto usberr;
}
if (rep->size <= 0) {
SDL_SetError("%s: Input report descriptor has invalid length",
hw->path);
goto usberr;
}
#if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_kernel_version >= 500111)
hdata = hid_start_parse(hw->repdesc, 1 << hid_input, rep->rid);
#else
hdata = hid_start_parse(hw->repdesc, 1 << hid_input);
#endif
if (hdata == NULL) {
SDL_SetError("%s: Cannot start HID parser", hw->path);
goto usberr;
}
joy->naxes = 0;
joy->nbuttons = 0;
joy->nhats = 0;
joy->nballs = 0;
for (i=0; i<JOYAXE_count; i++)
hw->axis_map[i] = -1;
while (hid_get_item(hdata, &hitem) > 0) {
char *sp;
const char *s;
switch (hitem.kind) {
case hid_collection:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP:
switch (HID_USAGE(hitem.usage)) {
case HUG_JOYSTICK:
case HUG_GAME_PAD:
s = hid_usage_in_page(hitem.usage);
sp = SDL_malloc(SDL_strlen(s) + 5);
SDL_snprintf(sp, SDL_strlen(s) + 5, "%s (%d)", s,
joy->index);
joydevnames[joy->index] = sp;
}
}
break;
case hid_input:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP: {
unsigned usage = HID_USAGE(hitem.usage);
int joyaxe = usage_to_joyaxe(usage);
if (joyaxe >= 0) {
hw->axis_map[joyaxe] = 1;
} else if (usage == HUG_HAT_SWITCH) {
joy->nhats++;
}
break;
}
case HUP_BUTTON:
joy->nbuttons++;
break;
default:
break;
}
break;
default:
break;
}
}
hid_end_parse(hdata);
for (i=0; i<JOYAXE_count; i++)
if (hw->axis_map[i] > 0)
hw->axis_map[i] = joy->naxes++;
usbend:
/* The poll blocks the event thread. */
fcntl(fd, F_SETFL, O_NONBLOCK);
return (0);
usberr:
close(hw->fd);
SDL_free(hw->path);
SDL_free(hw);
return (-1);
}
void
SDL_SYS_JoystickUpdate(SDL_Joystick *joy)
{
struct hid_item hitem;
struct hid_data *hdata;
struct report *rep;
int nbutton, naxe = -1;
Sint32 v;
#if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
struct joystick gameport;
if (joy->hwdata->type == BSDJOY_JOY) {
if (read(joy->hwdata->fd, &gameport, sizeof gameport) != sizeof gameport)
return;
if (abs(joy->hwdata->x - gameport.x) > 8) {
joy->hwdata->x = gameport.x;
if (joy->hwdata->x < joy->hwdata->xmin) {
joy->hwdata->xmin = joy->hwdata->x;
}
if (joy->hwdata->x > joy->hwdata->xmax) {
joy->hwdata->xmax = joy->hwdata->x;
}
if (joy->hwdata->xmin == joy->hwdata->xmax) {
joy->hwdata->xmin--;
joy->hwdata->xmax++;
}
v = (Sint32)joy->hwdata->x;
v -= (joy->hwdata->xmax + joy->hwdata->xmin + 1)/2;
v *= 32768/((joy->hwdata->xmax - joy->hwdata->xmin + 1)/2);
SDL_PrivateJoystickAxis(joy, 0, v);
}
if (abs(joy->hwdata->y - gameport.y) > 8) {
joy->hwdata->y = gameport.y;
if (joy->hwdata->y < joy->hwdata->ymin) {
joy->hwdata->ymin = joy->hwdata->y;
}
if (joy->hwdata->y > joy->hwdata->ymax) {
joy->hwdata->ymax = joy->hwdata->y;
}
if (joy->hwdata->ymin == joy->hwdata->ymax) {
joy->hwdata->ymin--;
joy->hwdata->ymax++;
}
v = (Sint32)joy->hwdata->y;
v -= (joy->hwdata->ymax + joy->hwdata->ymin + 1)/2;
v *= 32768/((joy->hwdata->ymax - joy->hwdata->ymin + 1)/2);
SDL_PrivateJoystickAxis(joy, 1, v);
}
if (gameport.b1 != joy->buttons[0]) {
SDL_PrivateJoystickButton(joy, 0, gameport.b1);
}
if (gameport.b2 != joy->buttons[1]) {
SDL_PrivateJoystickButton(joy, 1, gameport.b2);
}
return;
}
#endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */
rep = &joy->hwdata->inreport;
if (read(joy->hwdata->fd, REP_BUF_DATA(rep), rep->size) != rep->size) {
return;
}
#if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_kernel_version >= 500111)
hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input, rep->rid);
#else
hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input);
#endif
if (hdata == NULL) {
fprintf(stderr, "%s: Cannot start HID parser\n",
joy->hwdata->path);
return;
}
for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) {
switch (hitem.kind) {
case hid_input:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP: {
unsigned usage = HID_USAGE(hitem.usage);
int joyaxe = usage_to_joyaxe(usage);
if (joyaxe >= 0) {
naxe = joy->hwdata->axis_map[joyaxe];
/* scaleaxe */
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
v -= (hitem.logical_maximum + hitem.logical_minimum + 1)/2;
v *= 32768/((hitem.logical_maximum - hitem.logical_minimum + 1)/2);
if (v != joy->axes[naxe]) {
SDL_PrivateJoystickAxis(joy, naxe, v);
}
} else if (usage == HUG_HAT_SWITCH) {
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
SDL_PrivateJoystickHat(joy, 0,
hatval_to_sdl(v)-hitem.logical_minimum);
}
break;
}
case HUP_BUTTON:
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
if (joy->buttons[nbutton] != v) {
SDL_PrivateJoystickButton(joy,
nbutton, v);
}
nbutton++;
break;
default:
continue;
}
break;
default:
break;
}
}
hid_end_parse(hdata);
return;
}
/* Function to close a joystick after use */
void
SDL_SYS_JoystickClose(SDL_Joystick *joy)
{
if (SDL_strncmp(joy->hwdata->path, "/dev/joy", 8)) {
report_free(&joy->hwdata->inreport);
hid_dispose_report_desc(joy->hwdata->repdesc);
}
close(joy->hwdata->fd);
SDL_free(joy->hwdata->path);
SDL_free(joy->hwdata);
return;
}
void
SDL_SYS_JoystickQuit(void)
{
int i;
for (i = 0; i < MAX_JOYS; i++) {
if (joynames[i] != NULL)
SDL_free(joynames[i]);
if (joydevnames[i] != NULL)
SDL_free(joydevnames[i]);
}
return;
}
void
SDL_SYS_JoystickUpdate(SDL_Joystick *joy)
{
struct hid_item hitem;
struct hid_data *hdata;
struct report *rep;
int nbutton, naxe = -1;
Sint32 v;
rep = &joy->hwdata->inreport;
if (read(joy->hwdata->fd, REP_BUF_DATA(rep), rep->size) != rep->size) {
return;
}
#if defined(USBHID_NEW) || (defined(__FreeBSD__) && __FreeBSD_version >= 500111)
hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input, rep->rid);
#else
hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input);
#endif
if (hdata == NULL) {
fprintf(stderr, "%s: Cannot start HID parser\n",
joy->hwdata->path);
return;
}
for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) {
switch (hitem.kind) {
case hid_input:
switch (HID_PAGE(hitem.usage)) {
case HUP_GENERIC_DESKTOP: {
unsigned usage = HID_USAGE(hitem.usage);
int joyaxe = usage_to_joyaxe(usage);
if (joyaxe >= 0) {
naxe = joy->hwdata->axis_map[joyaxe];
/* scaleaxe */
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
v -= (hitem.logical_maximum + hitem.logical_minimum + 1)/2;
v *= 32768/((hitem.logical_maximum - hitem.logical_minimum + 1)/2);
if (v != joy->axes[naxe]) {
SDL_PrivateJoystickAxis(joy, naxe, v);
}
} else if (usage == HUG_HAT_SWITCH) {
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
SDL_PrivateJoystickHat(joy, 0, hatval_to_sdl(v));
}
break;
}
case HUP_BUTTON:
v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
&hitem);
if (joy->buttons[nbutton] != v) {
SDL_PrivateJoystickButton(joy,
nbutton, v);
}
nbutton++;
break;
default:
continue;
}
break;
default:
break;
}
}
hid_end_parse(hdata);
return;
}
Static void
uts_attach(device_t parent, device_t self, void *aux)
{
struct uts_softc *sc = device_private(self);
struct uhidev_attach_arg *uha = aux;
struct wsmousedev_attach_args a;
int size;
void *desc;
uint32_t flags;
struct hid_data * d;
struct hid_item item;
aprint_naive("\n");
sc->sc_hdev.sc_dev = self;
sc->sc_hdev.sc_intr = uts_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
uhidev_get_report_desc(uha->parent, &desc, &size);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
/* requires HID usage Generic_Desktop:X */
if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
uha->reportid, hid_input, &sc->sc_loc_x, &flags)) {
aprint_error_dev(sc->sc_hdev.sc_dev,
"touchscreen has no X report\n");
return;
}
switch (flags & TSCREEN_FLAGS_MASK) {
case 0:
sc->flags |= UTS_ABS;
break;
case HIO_RELATIVE:
break;
default:
aprint_error_dev(sc->sc_hdev.sc_dev,
"X report 0x%04x not supported\n", flags);
return;
}
/* requires HID usage Generic_Desktop:Y */
if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
uha->reportid, hid_input, &sc->sc_loc_y, &flags)) {
aprint_error_dev(sc->sc_hdev.sc_dev,
"touchscreen has no Y report\n");
return;
}
switch (flags & TSCREEN_FLAGS_MASK) {
case 0:
sc->flags |= UTS_ABS;
break;
case HIO_RELATIVE:
break;
default:
aprint_error_dev(sc->sc_hdev.sc_dev,
"Y report 0x%04x not supported\n", flags);
return;
}
/* requires HID usage Digitizer:Tip_Switch */
if (!hid_locate(desc, size, HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_SWITCH),
uha->reportid, hid_input, &sc->sc_loc_btn, 0)) {
aprint_error_dev(sc->sc_hdev.sc_dev,
"touchscreen has no tip switch report\n");
return;
}
/* requires HID usage Digitizer:In_Range */
if (!hid_locate(desc, size, HID_USAGE2(HUP_DIGITIZERS, HUD_IN_RANGE),
uha->reportid, hid_input, &sc->sc_loc_z, &flags)) {
aprint_error_dev(sc->sc_hdev.sc_dev,
"touchscreen has no range report\n");
return;
}
/* multi-touch support would need HUD_CONTACTID and HUD_CONTACTMAX */
#ifdef UTS_DEBUG
DPRINTF(("uts_attach: sc=%p\n", sc));
DPRINTF(("uts_attach: X\t%d/%d\n",
sc->sc_loc_x.pos, sc->sc_loc_x.size));
DPRINTF(("uts_attach: Y\t%d/%d\n",
sc->sc_loc_y.pos, sc->sc_loc_y.size));
DPRINTF(("uts_attach: Z\t%d/%d\n",
sc->sc_loc_z.pos, sc->sc_loc_z.size));
#endif
a.accessops = &uts_accessops;
a.accesscookie = sc;
sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint);
/* calibrate the touchscreen */
memset(&sc->sc_calibcoords, 0, sizeof(sc->sc_calibcoords));
sc->sc_calibcoords.maxx = 4095;
sc->sc_calibcoords.maxy = 4095;
sc->sc_calibcoords.samplelen = WSMOUSE_CALIBCOORDS_RESET;
d = hid_start_parse(desc, size, hid_input);
while (hid_get_item(d, &item)) {
if (item.kind != hid_input
|| HID_GET_USAGE_PAGE(item.usage) != HUP_GENERIC_DESKTOP
|| item.report_ID != sc->sc_hdev.sc_report_id)
continue;
if (HID_GET_USAGE(item.usage) == HUG_X) {
sc->sc_calibcoords.minx = item.logical_minimum;
sc->sc_calibcoords.maxx = item.logical_maximum;
}
if (HID_GET_USAGE(item.usage) == HUG_Y) {
sc->sc_calibcoords.miny = item.logical_minimum;
sc->sc_calibcoords.maxy = item.logical_maximum;
}
}
hid_end_parse(d);
tpcalib_init(&sc->sc_tpcalib);
tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS,
(void *)&sc->sc_calibcoords, 0, 0);
return;
}
void
bthidev_attach(struct device *parent, struct device *self, void *aux)
{
struct bthidev_softc *sc = (struct bthidev_softc *)self;
struct btdev_attach_args *bda = (struct btdev_attach_args *)aux;
struct bthidev_attach_args bha;
struct bthidev *hidev;
struct hid_data *d;
struct hid_item h;
int maxid, rep;
/*
* Init softc
*/
LIST_INIT(&sc->sc_list);
timeout_set(&sc->sc_reconnect, bthidev_timeout, sc);
sc->sc_state = BTHID_CLOSED;
sc->sc_flags = BTHID_CONNECTING;
sc->sc_ctlpsm = L2CAP_PSM_HID_CNTL;
sc->sc_intpsm = L2CAP_PSM_HID_INTR;
sc->sc_mode = 0;
/*
* copy in our configuration info
*/
bdaddr_copy(&sc->sc_laddr, &bda->bd_laddr);
bdaddr_copy(&sc->sc_raddr, &bda->bd_raddr);
if (bda->bd_mode != BTDEV_MODE_NONE) {
if (bda->bd_mode == BTDEV_MODE_AUTH) {
sc->sc_mode = L2CAP_LM_AUTH;
printf(" auth");
} else if (bda->bd_mode == BTDEV_MODE_ENCRYPT) {
sc->sc_mode = L2CAP_LM_ENCRYPT;
printf(" encrypt");
} else if (bda->bd_mode == BTDEV_MODE_SECURE) {
sc->sc_mode = L2CAP_LM_SECURE;
printf(" secure");
} else {
printf(" unknown link-mode: %d\n", bda->bd_mode);
return;
}
}
if (!L2CAP_PSM_INVALID(bda->bd_hid.hid_ctl))
sc->sc_ctlpsm = bda->bd_hid.hid_ctl;
if (!L2CAP_PSM_INVALID(bda->bd_hid.hid_int))
sc->sc_intpsm = bda->bd_hid.hid_int;
if (bda->bd_hid.hid_flags & BTHID_INITIATE)
sc->sc_flags |= BTHID_RECONNECT;
if (bda->bd_hid.hid_desc == NULL ||
bda->bd_hid.hid_dlen == 0 ||
bda->bd_hid.hid_dlen > MAX_DESCRIPTOR_LEN) {
printf(": no descriptor\n");
return;
}
sc->sc_dlen = bda->bd_hid.hid_dlen;
sc->sc_desc = malloc(bda->bd_hid.hid_dlen, M_BTHIDEV,
M_WAITOK | M_CANFAIL);
if (sc->sc_desc == NULL) {
printf(": no memory\n");
return;
}
if (copyin(bda->bd_hid.hid_desc, sc->sc_desc, bda->bd_hid.hid_dlen)) {
free(sc->sc_desc, M_BTHIDEV);
printf(": no descriptor");
return;
}
/*
* Parse the descriptor and attach child devices, one per report.
*/
maxid = -1;
h.report_ID = 0;
d = hid_start_parse(sc->sc_desc, sc->sc_dlen, hid_none);
while (hid_get_item(d, &h)) {
if (h.report_ID > maxid)
maxid = h.report_ID;
}
hid_end_parse(d);
if (maxid < 0) {
printf(": no reports found\n");
return;
}
printf("\n");
for (rep = 0 ; rep <= maxid ; rep++) {
if (hid_report_size(sc->sc_desc, sc->sc_dlen, hid_feature, rep) == 0
&& hid_report_size(sc->sc_desc, sc->sc_dlen, hid_input, rep) == 0
&& hid_report_size(sc->sc_desc, sc->sc_dlen, hid_output, rep) == 0)
continue;
bha.ba_desc = sc->sc_desc;
bha.ba_dlen = sc->sc_dlen;
bha.ba_input = bthidev_null;
bha.ba_feature = bthidev_null;
bha.ba_output = bthidev_output;
bha.ba_id = rep;
hidev = (struct bthidev *)config_found_sm(self, &bha,
bthidev_print, bthidevsubmatch);
if (hidev != NULL) {
hidev->sc_parent = &sc->sc_btdev;
hidev->sc_id = rep;
hidev->sc_input = bha.ba_input;
hidev->sc_feature = bha.ba_feature;
LIST_INSERT_HEAD(&sc->sc_list, hidev, sc_next);
}
}
/*
* start bluetooth connections
*/
mutex_enter(&bt_lock);
if ((sc->sc_flags & BTHID_RECONNECT) == 0)
bthidev_listen(sc);
if (sc->sc_flags & BTHID_CONNECTING)
bthidev_connect(sc);
mutex_exit(&bt_lock);
}