src/joystick/bsd/SDL_sysjoystick.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2012 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19     Sam Lantinga
  20     slouken@libsdl.org
  21 */
  22 #include "SDL_config.h"
  23
  24 #ifdef SDL_JOYSTICK_USBHID
  25
  26 /*
  27  * Joystick driver for the uhid(4) interface found in OpenBSD,
  28  * NetBSD and FreeBSD.
  29  *
  30  * Maintainer: <vedge at csoft.org>
  31  */
  32
  33 #include <sys/param.h>
  34
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <errno.h>
  38
  39 #ifndef __FreeBSD_kernel_version
  40 #define __FreeBSD_kernel_version __FreeBSD_version
  41 #endif
  42
  43 #if defined(HAVE_USB_H)
  44 #include <usb.h>
  45 #endif
  46 #ifdef __DragonFly__
  47 #include <bus/usb/usb.h>
  48 #include <bus/usb/usbhid.h>
  49 #else
  50 #include <dev/usb/usb.h>
  51 #include <dev/usb/usbhid.h>
  52 #endif
  53
  54 #if defined(HAVE_USBHID_H)
  55 #include <usbhid.h>
  56 #elif defined(HAVE_LIBUSB_H)
  57 #include <libusb.h>
  58 #elif defined(HAVE_LIBUSBHID_H)
  59 #include <libusbhid.h>
  60 #endif
  61
  62 #if defined(__FREEBSD__) || defined(__FreeBSD_kernel__)
  63 #ifndef __DragonFly__
  64 #include <osreldate.h>
  65 #endif
  66 #if __FreeBSD_kernel_version > 800063
  67 #include <dev/usb/usb_ioctl.h>
  68 #endif
  69 #include <sys/joystick.h>
  70 #endif
  71
  72 #if SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H
  73 #include <machine/joystick.h>
  74 #endif
  75
  76 #include "SDL_joystick.h"
  77 #include "../SDL_sysjoystick.h"
  78 #include "../SDL_joystick_c.h"
  79
  80 #define MAX_UHID_JOYS   4
  81 #define MAX_JOY_JOYS    2
  82 #define MAX_JOYS        (MAX_UHID_JOYS + MAX_JOY_JOYS)
  83
  84 struct report {
  85 #if defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063)
  86         struct  usb_gen_descriptor *buf;        /* Buffer */
  87 #else
  88         struct  usb_ctl_report *buf;    /* Buffer */
  89 #endif
  90         size_t  size;                   /* Buffer size */
  91         int     rid;                    /* Report ID */
  92         enum {
  93                 SREPORT_UNINIT,
  94                 SREPORT_CLEAN,
  95                 SREPORT_DIRTY
  96         } status;
  97 };
  98
  99 static struct {
 100         int     uhid_report;
 101         hid_kind_t kind;
 102         const   char *name;
 103 } const repinfo[] = {
 104         { UHID_INPUT_REPORT,    hid_input,      "input" },
 105         { UHID_OUTPUT_REPORT,   hid_output,     "output" },
 106         { UHID_FEATURE_REPORT,  hid_feature,    "feature" }
 107 };
 108
 109 enum {
 110         REPORT_INPUT = 0,
 111         REPORT_OUTPUT = 1,
 112         REPORT_FEATURE = 2
 113 };
 114
 115 enum {
 116         JOYAXE_X,
 117         JOYAXE_Y,
 118         JOYAXE_Z,
 119         JOYAXE_SLIDER,
 120         JOYAXE_WHEEL,
 121         JOYAXE_RX,
 122         JOYAXE_RY,
 123         JOYAXE_RZ,
 124         JOYAXE_count
 125 };
 126
 127 struct joystick_hwdata {
 128         int     fd;
 129         char    *path;
 130         enum {
 131                 BSDJOY_UHID,    /* uhid(4) */
 132                 BSDJOY_JOY      /* joy(4) */
 133         } type;
 134         struct  report_desc *repdesc;
 135         struct  report inreport;
 136         int     axis_map[JOYAXE_count]; /* map present JOYAXE_* to 0,1,..*/
 137         int     x;
 138         int     y;
 139         int     xmin;
 140         int     ymin;
 141         int     xmax;
 142         int     ymax;
 143 };
 144
 145 static char *joynames[MAX_JOYS];
 146 static char *joydevnames[MAX_JOYS];
 147
 148 static int      report_alloc(struct report *, struct report_desc *, int);
 149 static void     report_free(struct report *);
 150
 151 #if defined(USBHID_UCR_DATA) || defined(__FreeBSD_kernel__)
 152 #define REP_BUF_DATA(rep) ((rep)->buf->ucr_data)
 153 #elif (defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063))
 154 #define REP_BUF_DATA(rep) ((rep)->buf->ugd_data)
 155 #else
 156 #define REP_BUF_DATA(rep) ((rep)->buf->data)
 157 #endif
 158
 159 int
 160 SDL_SYS_JoystickInit(void)
 161 {
 162         char s[16];
 163         int i, fd;
 164
 165         SDL_numjoysticks = 0;
 166
 167         SDL_memset(joynames, 0, sizeof(joynames));
 168         SDL_memset(joydevnames, 0, sizeof(joydevnames));
 169
 170         for (i = 0; i < MAX_UHID_JOYS; i++) {
 171                 SDL_Joystick nj;
 172
 173                 SDL_snprintf(s, SDL_arraysize(s), "/dev/uhid%d", i);
 174
 175                 nj.index = SDL_numjoysticks;
 176                 joynames[nj.index] = strdup(s);
 177
 178                 if (SDL_SYS_JoystickOpen(&nj) == 0) {
 179                         SDL_SYS_JoystickClose(&nj);
 180                         SDL_numjoysticks++;
 181                 } else {
 182                         SDL_free(joynames[nj.index]);
 183                         joynames[nj.index] = NULL;
 184                 }
 185         }
 186         for (i = 0; i < MAX_JOY_JOYS; i++) {
 187                 SDL_snprintf(s, SDL_arraysize(s), "/dev/joy%d", i);
 188                 fd = open(s, O_RDONLY);
 189                 if (fd != -1) {
 190                         joynames[SDL_numjoysticks++] = strdup(s);
 191                         close(fd);
 192                 }
 193         }
 194
 195         /* Read the default USB HID usage table. */
 196         hid_init(NULL);
 197
 198         return (SDL_numjoysticks);
 199 }
 200
 201 const char *
 202 SDL_SYS_JoystickName(int index)
 203 {
 204         if (joydevnames[index] != NULL) {
 205                 return (joydevnames[index]);
 206         }
 207         return (joynames[index]);
 208 }
 209
 210 static int
 211 usage_to_joyaxe(unsigned usage)
 212 {
 213     int joyaxe;
 214     switch (usage) {
 215     case HUG_X:
 216         joyaxe = JOYAXE_X; break;
 217     case HUG_Y:
 218         joyaxe = JOYAXE_Y; break;
 219     case HUG_Z:
 220         joyaxe = JOYAXE_Z; break;
 221     case HUG_SLIDER:
 222         joyaxe = JOYAXE_SLIDER; break;
 223     case HUG_WHEEL:
 224         joyaxe = JOYAXE_WHEEL; break;
 225     case HUG_RX:
 226         joyaxe = JOYAXE_RX; break;
 227     case HUG_RY:
 228         joyaxe = JOYAXE_RY; break;
 229     case HUG_RZ:
 230         joyaxe = JOYAXE_RZ; break;
 231     default:
 232         joyaxe = -1;
 233     }
 234     return joyaxe;
 235 }
 236
 237 static unsigned
 238 hatval_to_sdl(Sint32 hatval)
 239 {
 240     static const unsigned hat_dir_map[8] = {
 241         SDL_HAT_UP, SDL_HAT_RIGHTUP, SDL_HAT_RIGHT, SDL_HAT_RIGHTDOWN,
 242         SDL_HAT_DOWN, SDL_HAT_LEFTDOWN, SDL_HAT_LEFT, SDL_HAT_LEFTUP
 243     };
 244     unsigned result;
 245     if ((hatval & 7) == hatval)
 246         result = hat_dir_map[hatval];
 247     else
 248         result = SDL_HAT_CENTERED;
 249     return result;
 250 }
 251
 252
 253 int
 254 SDL_SYS_JoystickOpen(SDL_Joystick *joy)
 255 {
 256         char *path = joynames[joy->index];
 257         struct joystick_hwdata *hw;
 258         struct hid_item hitem;
 259         struct hid_data *hdata;
 260         struct report *rep;
 261         int fd;
 262         int i;
 263
 264         fd = open(path, O_RDONLY);
 265         if (fd == -1) {
 266                 SDL_SetError("%s: %s", path, strerror(errno));
 267                 return (-1);
 268         }
 269
 270         hw = (struct joystick_hwdata *)SDL_malloc(sizeof(struct joystick_hwdata));
 271         if (hw == NULL) {
 272                 SDL_OutOfMemory();
 273                 close(fd);
 274                 return (-1);
 275         }
 276         joy->hwdata = hw;
 277         hw->fd = fd;
 278         hw->path = strdup(path);
 279         hw->x = 0;
 280         hw->y = 0;
 281         hw->xmin = 0xffff;
 282         hw->ymin = 0xffff;
 283         hw->xmax = 0;
 284         hw->ymax = 0;
 285         if (! SDL_strncmp(path, "/dev/joy", 8)) {
 286                 hw->type = BSDJOY_JOY;
 287                 joy->naxes = 2;
 288                 joy->nbuttons = 2;
 289                 joy->nhats = 0;
 290                 joy->nballs = 0;
 291                 joydevnames[joy->index] = strdup("Gameport joystick");
 292                 goto usbend;
 293         } else {
 294                 hw->type = BSDJOY_UHID;
 295         }
 296
 297         {
 298             int ax;
 299             for (ax = 0; ax < JOYAXE_count; ax++)
 300                 hw->axis_map[ax] = -1;
 301         }
 302         hw->repdesc = hid_get_report_desc(fd);
 303         if (hw->repdesc == NULL) {
 304                 SDL_SetError("%s: USB_GET_REPORT_DESC: %s", hw->path,
 305                     strerror(errno));
 306                 goto usberr;
 307         }
 308         rep = &hw->inreport;
 309 #if defined(__FREEBSD__) && (__FreeBSD_kernel_version > 800063) || defined(__FreeBSD_kernel__)
 310        rep->rid = hid_get_report_id(fd);
 311        if (rep->rid < 0) {
 312 #else
 313         if (ioctl(fd, USB_GET_REPORT_ID, &rep->rid) < 0) {
 314 #endif
 315                 rep->rid = -1; /* XXX */
 316         }
 317         if (report_alloc(rep, hw->repdesc, REPORT_INPUT) < 0) {
 318                 goto usberr;
 319         }
 320         if (rep->size <= 0) {
 321                 SDL_SetError("%s: Input report descriptor has invalid length",
 322                     hw->path);
 323                 goto usberr;
 324         }
 325
 326 #if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_kernel_version >= 500111) || defined(__FreeBSD_kernel__)
 327         hdata = hid_start_parse(hw->repdesc, 1 << hid_input, rep->rid);
 328 #else
 329         hdata = hid_start_parse(hw->repdesc, 1 << hid_input);
 330 #endif
 331         if (hdata == NULL) {
 332                 SDL_SetError("%s: Cannot start HID parser", hw->path);
 333                 goto usberr;
 334         }
 335         joy->naxes = 0;
 336         joy->nbuttons = 0;
 337         joy->nhats = 0;
 338         joy->nballs = 0;
 339         for (i=0; i<JOYAXE_count; i++)
 340                 hw->axis_map[i] = -1;
 341
 342         while (hid_get_item(hdata, &hitem) > 0) {
 343                 char *sp;
 344                 const char *s;
 345
 346                 switch (hitem.kind) {
 347                 case hid_collection:
 348                         switch (HID_PAGE(hitem.usage)) {
 349                         case HUP_GENERIC_DESKTOP:
 350                                 switch (HID_USAGE(hitem.usage)) {
 351                                 case HUG_JOYSTICK:
 352                                 case HUG_GAME_PAD:
 353                                         s = hid_usage_in_page(hitem.usage);
 354                                         sp = SDL_malloc(SDL_strlen(s) + 5);
 355                                         SDL_snprintf(sp, SDL_strlen(s) + 5, "%s (%d)", s,
 356                                             joy->index);
 357                                         joydevnames[joy->index] = sp;
 358                                 }
 359                         }
 360                         break;
 361                 case hid_input:
 362                         switch (HID_PAGE(hitem.usage)) {
 363                         case HUP_GENERIC_DESKTOP: {
 364                             unsigned usage = HID_USAGE(hitem.usage);
 365                             int joyaxe = usage_to_joyaxe(usage);
 366                             if (joyaxe >= 0) {
 367                                 hw->axis_map[joyaxe] = 1;
 368                             } else if (usage == HUG_HAT_SWITCH) {
 369                                 joy->nhats++;
 370                             }
 371                             break;
 372                         }
 373                         case HUP_BUTTON:
 374                                 joy->nbuttons++;
 375                                 break;
 376                         default:
 377                                 break;
 378                         }
 379                         break;
 380                 default:
 381                         break;
 382                 }
 383         }
 384         hid_end_parse(hdata);
 385         for (i=0; i<JOYAXE_count; i++)
 386                 if (hw->axis_map[i] > 0)
 387                         hw->axis_map[i] = joy->naxes++;
 388
 389 usbend:
 390         /* The poll blocks the event thread. */
 391         fcntl(fd, F_SETFL, O_NONBLOCK);
 392
 393         return (0);
 394 usberr:
 395         close(hw->fd);
 396         SDL_free(hw->path);
 397         SDL_free(hw);
 398         return (-1);
 399 }
 400
 401 void
 402 SDL_SYS_JoystickUpdate(SDL_Joystick *joy)
 403 {
 404         struct hid_item hitem;
 405         struct hid_data *hdata;
 406         struct report *rep;
 407         int nbutton, naxe = -1;
 408         Sint32 v;
 409
 410 #if defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H || defined(__FreeBSD_kernel__)
 411         struct joystick gameport;
 412
 413         if (joy->hwdata->type == BSDJOY_JOY) {
 414                 if (read(joy->hwdata->fd, &gameport, sizeof gameport) != sizeof gameport)
 415                         return;
 416                 if (abs(joy->hwdata->x - gameport.x) > 8) {
 417                         joy->hwdata->x = gameport.x;
 418                         if (joy->hwdata->x < joy->hwdata->xmin) {
 419                                 joy->hwdata->xmin = joy->hwdata->x;
 420                         }
 421                         if (joy->hwdata->x > joy->hwdata->xmax) {
 422                                 joy->hwdata->xmax = joy->hwdata->x;
 423                         }
 424                         if (joy->hwdata->xmin == joy->hwdata->xmax) {
 425                                 joy->hwdata->xmin--;
 426                                 joy->hwdata->xmax++;
 427                         }
 428                         v = (Sint32)joy->hwdata->x;
 429                         v -= (joy->hwdata->xmax + joy->hwdata->xmin + 1)/2;
 430                         v *= 32768/((joy->hwdata->xmax - joy->hwdata->xmin + 1)/2);
 431                         SDL_PrivateJoystickAxis(joy, 0, v);
 432                 }
 433                 if (abs(joy->hwdata->y - gameport.y) > 8) {
 434                         joy->hwdata->y = gameport.y;
 435                         if (joy->hwdata->y < joy->hwdata->ymin) {
 436                                 joy->hwdata->ymin = joy->hwdata->y;
 437                         }
 438                         if (joy->hwdata->y > joy->hwdata->ymax) {
 439                                 joy->hwdata->ymax = joy->hwdata->y;
 440                         }
 441                         if (joy->hwdata->ymin == joy->hwdata->ymax) {
 442                                 joy->hwdata->ymin--;
 443                                 joy->hwdata->ymax++;
 444                         }
 445                         v = (Sint32)joy->hwdata->y;
 446                         v -= (joy->hwdata->ymax + joy->hwdata->ymin + 1)/2;
 447                         v *= 32768/((joy->hwdata->ymax - joy->hwdata->ymin + 1)/2);
 448                         SDL_PrivateJoystickAxis(joy, 1, v);
 449                 }
 450                 if (gameport.b1 != joy->buttons[0]) {
 451                         SDL_PrivateJoystickButton(joy, 0, gameport.b1);
 452                 }
 453                 if (gameport.b2 != joy->buttons[1]) {
 454                         SDL_PrivateJoystickButton(joy, 1, gameport.b2);
 455                 }
 456                 return;
 457         }
 458 #endif /* defined(__FREEBSD__) || SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */
 459
 460         rep = &joy->hwdata->inreport;
 461
 462         if (read(joy->hwdata->fd, REP_BUF_DATA(rep), rep->size) != rep->size) {
 463                 return;
 464         }
 465 #if defined(USBHID_NEW) || (defined(__FREEBSD__) && __FreeBSD_kernel_version >= 500111) || defined(__FreeBSD_kernel__)
 466         hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input, rep->rid);
 467 #else
 468         hdata = hid_start_parse(joy->hwdata->repdesc, 1 << hid_input);
 469 #endif
 470         if (hdata == NULL) {
 471                 fprintf(stderr, "%s: Cannot start HID parser\n",
 472                     joy->hwdata->path);
 473                 return;
 474         }
 475
 476         for (nbutton = 0; hid_get_item(hdata, &hitem) > 0;) {
 477                 switch (hitem.kind) {
 478                 case hid_input:
 479                         switch (HID_PAGE(hitem.usage)) {
 480                         case HUP_GENERIC_DESKTOP: {
 481                             unsigned usage = HID_USAGE(hitem.usage);
 482                             int joyaxe = usage_to_joyaxe(usage);
 483                             if (joyaxe >= 0) {
 484                                 naxe = joy->hwdata->axis_map[joyaxe];
 485                                 /* scaleaxe */
 486                                 v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
 487                                                          &hitem);
 488                                 v -= (hitem.logical_maximum + hitem.logical_minimum + 1)/2;
 489                                 v *= 32768/((hitem.logical_maximum - hitem.logical_minimum + 1)/2);
 490                                 if (v != joy->axes[naxe]) {
 491                                     SDL_PrivateJoystickAxis(joy, naxe, v);
 492                                 }
 493                             } else if (usage == HUG_HAT_SWITCH) {
 494                                 v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
 495                                                          &hitem);
 496                                 SDL_PrivateJoystickHat(joy, 0,
 497                                         hatval_to_sdl(v)-hitem.logical_minimum);
 498                             }
 499                             break;
 500                         }
 501                         case HUP_BUTTON:
 502                                 v = (Sint32)hid_get_data(REP_BUF_DATA(rep),
 503                                     &hitem);
 504                                 if (joy->buttons[nbutton] != v) {
 505                                         SDL_PrivateJoystickButton(joy,
 506                                             nbutton, v);
 507                                 }
 508                                 nbutton++;
 509                                 break;
 510                         default:
 511                                 continue;
 512                         }
 513                         break;
 514                 default:
 515                         break;
 516                 }
 517         }
 518         hid_end_parse(hdata);
 519
 520         return;
 521 }
 522
 523 /* Function to close a joystick after use */
 524 void
 525 SDL_SYS_JoystickClose(SDL_Joystick *joy)
 526 {
 527         if (SDL_strncmp(joy->hwdata->path, "/dev/joy", 8))      {
 528                 report_free(&joy->hwdata->inreport);
 529                 hid_dispose_report_desc(joy->hwdata->repdesc);
 530         }
 531         close(joy->hwdata->fd);
 532         SDL_free(joy->hwdata->path);
 533         SDL_free(joy->hwdata);
 534
 535         return;
 536 }
 537
 538 void
 539 SDL_SYS_JoystickQuit(void)
 540 {
 541         int i;
 542
 543         for (i = 0; i < MAX_JOYS; i++) {
 544                 if (joynames[i] != NULL)
 545                         SDL_free(joynames[i]);
 546                 if (joydevnames[i] != NULL)
 547                         SDL_free(joydevnames[i]);
 548         }
 549
 550         return;
 551 }
 552
 553 static int
 554 report_alloc(struct report *r, struct report_desc *rd, int repind)
 555 {
 556         int len;
 557
 558 #ifdef __DragonFly__
 559         len = hid_report_size(rd, r->rid, repinfo[repind].kind);
 560 #elif __FREEBSD__
 561 # if (__FreeBSD_kernel_version >= 460000) || defined(__FreeBSD_kernel__)
 562 #  if (__FreeBSD_kernel_version <= 500111)
 563         len = hid_report_size(rd, r->rid, repinfo[repind].kind);
 564 #  else
 565         len = hid_report_size(rd, repinfo[repind].kind, r->rid);
 566 #  endif
 567 # else
 568         len = hid_report_size(rd, repinfo[repind].kind, &r->rid);
 569 # endif
 570 #else
 571 # ifdef USBHID_NEW
 572         len = hid_report_size(rd, repinfo[repind].kind, r->rid);
 573 # else
 574         len = hid_report_size(rd, repinfo[repind].kind, &r->rid);
 575 # endif
 576 #endif
 577
 578         if (len < 0) {
 579                 SDL_SetError("Negative HID report size");
 580                 return (-1);
 581         }
 582         r->size = len;
 583
 584         if (r->size > 0) {
 585                 r->buf = SDL_malloc(sizeof(*r->buf) - sizeof(REP_BUF_DATA(r)) +
 586                     r->size);
 587                 if (r->buf == NULL) {
 588                         SDL_OutOfMemory();
 589                         return (-1);
 590                 }
 591         } else {
 592                 r->buf = NULL;
 593         }
 594
 595         r->status = SREPORT_CLEAN;
 596         return (0);
 597 }
 598
 599 static void
 600 report_free(struct report *r)
 601 {
 602         if (r->buf != NULL) {
 603                 SDL_free(r->buf);
 604         }
 605         r->status = SREPORT_UNINIT;
 606 }
 607
 608 #endif /* SDL_JOYSTICK_USBHID */