usr.sbin/bluetooth/bthidd/hid.c

   1 /*
   2  * hid.c
   3  */
   4
   5 /*-
   6  * Copyright (c) 2006 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $Id: hid.c,v 1.5 2006/09/07 21:06:53 max Exp $
  31  * $FreeBSD$
  32  */
  33
  34 #include <sys/consio.h>
  35 #include <sys/mouse.h>
  36 #include <sys/queue.h>
  37 #include <assert.h>
  38 #include <bluetooth.h>
  39 #include <dev/usb/usb.h>
  40 #include <dev/usb/usbhid.h>
  41 #include <errno.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <syslog.h>
  45 #include <unistd.h>
  46 #include <usbhid.h>
  47 #include "bthid_config.h"
  48 #include "bthidd.h"
  49 #include "kbd.h"
  50
  51 #undef  min
  52 #define min(x, y)       (((x) < (y))? (x) : (y))
  53
  54 #undef  ASIZE
  55 #define ASIZE(a)        (sizeof(a)/sizeof(a[0]))
  56
  57 /*
  58  * Process data from control channel
  59  */
  60
  61 int32_t
  62 hid_control(bthid_session_p s, uint8_t *data, int32_t len)
  63 {
  64         assert(s != NULL);
  65         assert(data != NULL);
  66         assert(len > 0);
  67
  68         switch (data[0] >> 4) {
  69         case 0: /* Handshake (response to command) */
  70                 if (data[0] & 0xf)
  71                         syslog(LOG_ERR, "Got handshake message with error " \
  72                                 "response 0x%x from %s",
  73                                 data[0], bt_ntoa(&s->bdaddr, NULL));
  74                 break;
  75
  76         case 1: /* HID Control */
  77                 switch (data[0] & 0xf) {
  78                 case 0: /* NOP */
  79                         break;
  80
  81                 case 1: /* Hard reset */
  82                 case 2: /* Soft reset */
  83                         syslog(LOG_WARNING, "Device %s requested %s reset",
  84                                 bt_ntoa(&s->bdaddr, NULL),
  85                                 ((data[0] & 0xf) == 1)? "hard" : "soft");
  86                         break;
  87
  88                 case 3: /* Suspend */
  89                         syslog(LOG_NOTICE, "Device %s requested Suspend",
  90                                 bt_ntoa(&s->bdaddr, NULL));
  91                         break;
  92
  93                 case 4: /* Exit suspend */
  94                         syslog(LOG_NOTICE, "Device %s requested Exit Suspend",
  95                                 bt_ntoa(&s->bdaddr, NULL));
  96                         break;
  97
  98                 case 5: /* Virtual cable unplug */
  99                         syslog(LOG_NOTICE, "Device %s unplugged virtual cable",
 100                                 bt_ntoa(&s->bdaddr, NULL));
 101                         session_close(s);
 102                         break;
 103
 104                 default:
 105                         syslog(LOG_WARNING, "Device %s sent unknown " \
 106                                 "HID_Control message 0x%x",
 107                                 bt_ntoa(&s->bdaddr, NULL), data[0]);
 108                         break;
 109                 }
 110                 break;
 111
 112         default:
 113                 syslog(LOG_WARNING, "Got unexpected message 0x%x on Control " \
 114                         "channel from %s", data[0], bt_ntoa(&s->bdaddr, NULL));
 115                 break;
 116         }
 117
 118         return (0);
 119 }
 120
 121 /*
 122  * Process data from the interrupt channel
 123  */
 124
 125 int32_t
 126 hid_interrupt(bthid_session_p s, uint8_t *data, int32_t len)
 127 {
 128         hid_device_p    hid_device;
 129         hid_data_t      d;
 130         hid_item_t      h;
 131         int32_t         report_id, usage, page, val,
 132                         mouse_x, mouse_y, mouse_z, mouse_butt,
 133                         mevents, kevents, i;
 134
 135         assert(s != NULL);
 136         assert(s->srv != NULL);
 137         assert(data != NULL);
 138
 139         if (len < 3) {
 140                 syslog(LOG_ERR, "Got short message (%d bytes) on Interrupt " \
 141                         "channel from %s", len, bt_ntoa(&s->bdaddr, NULL));
 142                 return (-1);
 143         }
 144
 145         if (data[0] != 0xa1) {
 146                 syslog(LOG_ERR, "Got unexpected message 0x%x on " \
 147                         "Interrupt channel from %s",
 148                         data[0], bt_ntoa(&s->bdaddr, NULL));
 149                 return (-1);
 150         }
 151
 152         report_id = data[1];
 153         data ++;
 154         len --;
 155
 156         hid_device = get_hid_device(&s->bdaddr);
 157         assert(hid_device != NULL);
 158
 159         mouse_x = mouse_y = mouse_z = mouse_butt = mevents = kevents = 0;
 160
 161         for (d = hid_start_parse(hid_device->desc, 1 << hid_input, -1);
 162              hid_get_item(d, &h) > 0; ) {
 163                 if ((h.flags & HIO_CONST) || (h.report_ID != report_id) ||
 164                     (h.kind != hid_input))
 165                         continue;
 166
 167                 page = HID_PAGE(h.usage);
 168                 usage = HID_USAGE(h.usage);
 169                 val = hid_get_data(data, &h);
 170
 171                 switch (page) {
 172                 case HUP_GENERIC_DESKTOP:
 173                         switch (usage) {
 174                         case HUG_X:
 175                                 mouse_x = val;
 176                                 mevents ++;
 177                                 break;
 178
 179                         case HUG_Y:
 180                                 mouse_y = val;
 181                                 mevents ++;
 182                                 break;
 183
 184                         case HUG_WHEEL:
 185                                 mouse_z = -val;
 186                                 mevents ++;
 187                                 break;
 188
 189                         case HUG_SYSTEM_SLEEP:
 190                                 if (val)
 191                                         syslog(LOG_NOTICE, "Sleep button pressed");
 192                                 break;
 193                         }
 194                         break;
 195
 196                 case HUP_KEYBOARD:
 197                         kevents ++;
 198
 199                         if (h.flags & HIO_VARIABLE) {
 200                                 if (val && usage < kbd_maxkey())
 201                                         bit_set(s->keys1, usage);
 202                         } else {
 203                                 if (val && val < kbd_maxkey())
 204                                         bit_set(s->keys1, val);
 205
 206                                 for (i = 1; i < h.report_count; i++) {
 207                                         h.pos += h.report_size;
 208                                         val = hid_get_data(data, &h);
 209                                         if (val && val < kbd_maxkey())
 210                                                 bit_set(s->keys1, val);
 211                                 }
 212                         }
 213                         break;
 214
 215                 case HUP_BUTTON:
 216                         if (usage != 0) {
 217                                 if (usage == 2)
 218                                         usage = 3;
 219                                 else if (usage == 3)
 220                                         usage = 2;
 221
 222                                 mouse_butt |= (val << (usage - 1));
 223                                 mevents ++;
 224                         }
 225                         break;
 226
 227                 case HUP_CONSUMER:
 228                         if (!val)
 229                                 break;
 230
 231                         switch (usage) {
 232                         case 0xb5: /* Scan Next Track */
 233                                 val = 0x19;
 234                                 break;
 235
 236                         case 0xb6: /* Scan Previous Track */
 237                                 val = 0x10;
 238                                 break;
 239
 240                         case 0xb7: /* Stop */
 241                                 val = 0x24;
 242                                 break;
 243
 244                         case 0xcd: /* Play/Pause */
 245                                 val = 0x22;
 246                                 break;
 247
 248                         case 0xe2: /* Mute */
 249                                 val = 0x20;
 250                                 break;
 251
 252                         case 0xe9: /* Volume Up */
 253                                 val = 0x30;
 254                                 break;
 255
 256                         case 0xea: /* Volume Down */
 257                                 val = 0x2E;
 258                                 break;
 259
 260                         case 0x183: /* Media Select */
 261                                 val = 0x6D;
 262                                 break;
 263
 264                         case 0x018a: /* Mail */
 265                                 val = 0x6C;
 266                                 break;
 267
 268                         case 0x192: /* Calculator */
 269                                 val = 0x21;
 270                                 break;
 271
 272                         case 0x194: /* My Computer */
 273                                 val = 0x6B;
 274                                 break;
 275
 276                         case 0x221: /* WWW Search */
 277                                 val = 0x65;
 278                                 break;
 279
 280                         case 0x223: /* WWW Home */
 281                                 val = 0x32;
 282                                 break;
 283
 284                         case 0x224: /* WWW Back */
 285                                 val = 0x6A;
 286                                 break;
 287
 288                         case 0x225: /* WWW Forward */
 289                                 val = 0x69;
 290                                 break;
 291
 292                         case 0x226: /* WWW Stop */
 293                                 val = 0x68;
 294                                 break;
 295
 296                         case 0x227: /* WWW Refresh */
 297                                 val = 0x67;
 298                                 break;
 299
 300                         case 0x22a: /* WWW Favorites */
 301                                 val = 0x66;
 302                                 break;
 303
 304                         default:
 305                                 val = 0;
 306                                 break;
 307                         }
 308
 309                         /* XXX FIXME - UGLY HACK */
 310                         if (val != 0) {
 311                                 if (hid_device->keyboard) {
 312                                         int32_t buf[4] = { 0xe0, val,
 313                                                            0xe0, val|0x80 };
 314
 315                                         assert(s->vkbd != -1);
 316                                         write(s->vkbd, buf, sizeof(buf));
 317                                 } else
 318                                         syslog(LOG_ERR, "Keyboard events " \
 319                                                 "received from non-keyboard " \
 320                                                 "device %s. Please report",
 321                                                 bt_ntoa(&s->bdaddr, NULL));
 322                         }
 323                         break;
 324
 325                 case HUP_MICROSOFT:
 326                         switch (usage) {
 327                         case 0xfe01:
 328                                 if (!hid_device->battery_power)
 329                                         break;
 330
 331                                 switch (val) {
 332                                 case 1:
 333                                         syslog(LOG_INFO, "Battery is OK on %s",
 334                                                 bt_ntoa(&s->bdaddr, NULL));
 335                                         break;
 336
 337                                 case 2:
 338                                         syslog(LOG_NOTICE, "Low battery on %s",
 339                                                 bt_ntoa(&s->bdaddr, NULL));
 340                                         break;
 341
 342                                 case 3:
 343                                         syslog(LOG_WARNING, "Very low battery "\
 344                                                 "on %s",
 345                                                 bt_ntoa(&s->bdaddr, NULL));
 346                                         break;
 347                                 }
 348                                 break;
 349                         }
 350                         break;
 351                 }
 352         }
 353         hid_end_parse(d);
 354
 355         /*
 356          * XXX FIXME Feed keyboard events into kernel.
 357          * The code below works, bit host also needs to track
 358          * and handle repeat.
 359          *
 360          * Key repeat currently works in X, but not in console.
 361          */
 362
 363         if (kevents > 0) {
 364                 if (hid_device->keyboard) {
 365                         assert(s->vkbd != -1);
 366                         kbd_process_keys(s);
 367                 } else
 368                         syslog(LOG_ERR, "Keyboard events received from " \
 369                                 "non-keyboard device %s. Please report",
 370                                 bt_ntoa(&s->bdaddr, NULL));
 371         }
 372
 373         /*
 374          * XXX FIXME Feed mouse events into kernel.
 375          * The code block below works, but it is not good enough.
 376          * Need to track double-clicks etc.
 377          *
 378          * Double click currently works in X, but not in console.
 379          */
 380
 381         if (mevents > 0) {
 382                 struct mouse_info       mi;
 383
 384                 mi.operation = MOUSE_ACTION;
 385                 mi.u.data.x = mouse_x;
 386                 mi.u.data.y = mouse_y;
 387                 mi.u.data.z = mouse_z;
 388                 mi.u.data.buttons = mouse_butt;
 389
 390                 if (ioctl(s->srv->cons, CONS_MOUSECTL, &mi) < 0)
 391                         syslog(LOG_ERR, "Could not process mouse events from " \
 392                                 "%s. %s (%d)", bt_ntoa(&s->bdaddr, NULL),
 393                                 strerror(errno), errno);
 394         }
 395
 396         return (0);
 397 }