src/add-ons/kernel/drivers/input/usb_hid/JoystickProtocolHandler.cpp

   1 /*
   2  * Copyright 2011 Michael Lotz <mmlr@mlotz.ch>
   3  * Distributed under the terms of the MIT license.
   4  */
   5
   6
   7 //!     Driver for USB Human Interface Devices.
   8
   9
  10 #include "Driver.h"
  11 #include "JoystickProtocolHandler.h"
  12
  13 #include "HIDCollection.h"
  14 #include "HIDDevice.h"
  15 #include "HIDReport.h"
  16 #include "HIDReportItem.h"
  17
  18 #include <new>
  19 #include <string.h>
  20 #include <usb/USB_hid.h>
  21
  22
  23 JoystickProtocolHandler::JoystickProtocolHandler(HIDReport &report)
  24         :
  25         ProtocolHandler(report.Device(), "joystick/usb/", 0),
  26         fReport(report),
  27         fAxisCount(0),
  28         fAxis(NULL),
  29         fHatCount(0),
  30         fHats(NULL),
  31         fButtonCount(0),
  32         fMaxButton(0),
  33         fButtons(NULL),
  34         fOpenCount(0),
  35         fUpdateThread(-1)
  36 {
  37         mutex_init(&fUpdateLock, "joystick update lock");
  38         memset(&fJoystickModuleInfo, 0, sizeof(joystick_module_info));
  39         memset(&fCurrentValues, 0, sizeof(variable_joystick));
  40
  41         for (uint32 i = 0; i < report.CountItems(); i++) {
  42                 HIDReportItem *item = report.ItemAt(i);
  43                 if (!item->HasData())
  44                         continue;
  45
  46                 switch (item->UsagePage()) {
  47                         case B_HID_USAGE_PAGE_BUTTON:
  48                         {
  49                                 if (item->UsageID() > INT16_MAX)
  50                                         break;
  51
  52                                 HIDReportItem **newButtons = (HIDReportItem **)realloc(fButtons,
  53                                         ++fButtonCount * sizeof(HIDReportItem *));
  54                                 if (newButtons == NULL) {
  55                                         fButtonCount--;
  56                                         break;
  57                                 }
  58
  59                                 fButtons = newButtons;
  60                                 fButtons[fButtonCount - 1] = item;
  61
  62                                 if (fMaxButton < item->UsageID())
  63                                         fMaxButton = item->UsageID();
  64                                 break;
  65                         }
  66
  67                         case B_HID_USAGE_PAGE_GENERIC_DESKTOP:
  68                         {
  69                                 if (item->UsageID() == B_HID_UID_GD_HAT_SWITCH) {
  70                                         HIDReportItem **newHats = (HIDReportItem **)realloc(fHats,
  71                                                 ++fHatCount * sizeof(HIDReportItem *));
  72                                         if (newHats == NULL) {
  73                                                 fHatCount--;
  74                                                 break;
  75                                         }
  76
  77                                         fHats = newHats;
  78                                         fHats[fHatCount - 1] = item;
  79                                         break;
  80                                 }
  81
  82 // TODO: "axis" is set but not used!
  83 //                              uint16 axis = 0;
  84                                 if (item->UsageID() >= B_HID_UID_GD_X
  85                                         && item->UsageID() <= B_HID_UID_GD_WHEEL) {
  86 //                                      axis = item->UsageID() - B_HID_UID_GD_X;
  87                                 } else if (item->UsageID() >= B_HID_UID_GD_VX
  88                                         && item->UsageID() <= B_HID_UID_GD_VNO) {
  89 //                                      axis = item->UsageID() - B_HID_UID_GD_VX;
  90                                 } else
  91                                         break;
  92
  93                                 HIDReportItem **newAxis = (HIDReportItem **)realloc(fAxis,
  94                                         ++fAxisCount * sizeof(HIDReportItem *));
  95                                 if (newAxis == NULL) {
  96                                         fAxisCount--;
  97                                         break;
  98                                 }
  99
 100                                 fAxis = newAxis;
 101                                 fAxis[fAxisCount - 1] = item;
 102                                 break;
 103                         }
 104                 }
 105         }
 106
 107
 108         fCurrentValues.initialize(fAxisCount, fHatCount, fMaxButton);
 109
 110         TRACE("joystick device with %lu buttons, %lu axes and %lu hats\n",
 111                 fButtonCount, fAxisCount, fHatCount);
 112         TRACE("report id: %u\n", report.ID());
 113 }
 114
 115
 116 JoystickProtocolHandler::~JoystickProtocolHandler()
 117 {
 118         free(fCurrentValues.data);
 119         free(fAxis);
 120         free(fHats);
 121         free(fButtons);
 122 }
 123
 124
 125 void
 126 JoystickProtocolHandler::AddHandlers(HIDDevice &device,
 127         HIDCollection &collection, ProtocolHandler *&handlerList)
 128 {
 129         if (collection.UsagePage() != B_HID_USAGE_PAGE_GENERIC_DESKTOP
 130                 || (collection.UsageID() != B_HID_UID_GD_JOYSTICK
 131                         && collection.UsageID() != B_HID_UID_GD_GAMEPAD
 132                         && collection.UsageID() != B_HID_UID_GD_MULTIAXIS)) {
 133                 TRACE("collection not a joystick or gamepad\n");
 134                 return;
 135         }
 136
 137         HIDParser &parser = device.Parser();
 138         uint32 maxReportCount = parser.CountReports(HID_REPORT_TYPE_INPUT);
 139         if (maxReportCount == 0)
 140                 return;
 141
 142         uint32 inputReportCount = 0;
 143         HIDReport *inputReports[maxReportCount];
 144         collection.BuildReportList(HID_REPORT_TYPE_INPUT, inputReports,
 145                 inputReportCount);
 146
 147         for (uint32 i = 0; i < inputReportCount; i++) {
 148                 HIDReport *inputReport = inputReports[i];
 149
 150                 // try to find at least one axis
 151                 bool foundAxis = false;
 152                 for (uint32 j = 0; j < inputReport->CountItems(); j++) {
 153                         HIDReportItem *item = inputReport->ItemAt(j);
 154                         if (item == NULL || !item->HasData())
 155                                 continue;
 156
 157                         if (item->UsagePage() != B_HID_USAGE_PAGE_GENERIC_DESKTOP)
 158                                 continue;
 159
 160                         if (item->UsageID() >= B_HID_UID_GD_X
 161                                 && item->UsageID() <= B_HID_UID_GD_RZ) {
 162                                 foundAxis = true;
 163                                 break;
 164                         }
 165                 }
 166
 167                 if (!foundAxis)
 168                         continue;
 169
 170                 ProtocolHandler *newHandler
 171                         = new(std::nothrow) JoystickProtocolHandler(*inputReport);
 172                 if (newHandler == NULL) {
 173                         TRACE("failed to allocated joystick protocol handler\n");
 174                         continue;
 175                 }
 176
 177                 newHandler->SetNextHandler(handlerList);
 178                 handlerList = newHandler;
 179         }
 180 }
 181
 182
 183 status_t
 184 JoystickProtocolHandler::Open(uint32 flags, uint32 *cookie)
 185 {
 186         if (fCurrentValues.data == NULL)
 187                 return B_NO_INIT;
 188
 189         status_t result = mutex_lock(&fUpdateLock);
 190         if (result != B_OK)
 191                 return result;
 192
 193         if (fUpdateThread < 0) {
 194                 fUpdateThread = spawn_kernel_thread(_UpdateThread, "joystick update",
 195                         B_NORMAL_PRIORITY, (void *)this);
 196
 197                 if (fUpdateThread < 0)
 198                         result = fUpdateThread;
 199                 else
 200                         resume_thread(fUpdateThread);
 201         }
 202
 203         if (result == B_OK)
 204                 fOpenCount++;
 205
 206         mutex_unlock(&fUpdateLock);
 207         if (result != B_OK)
 208                 return result;
 209
 210         return ProtocolHandler::Open(flags, cookie);
 211 }
 212
 213
 214 status_t
 215 JoystickProtocolHandler::Close(uint32 *cookie)
 216 {
 217         status_t result = mutex_lock(&fUpdateLock);
 218         if (result == B_OK) {
 219                 if (--fOpenCount == 0)
 220                         fUpdateThread = -1;
 221                 mutex_unlock(&fUpdateLock);
 222         }
 223
 224         return ProtocolHandler::Close(cookie);
 225 }
 226
 227
 228
 229 status_t
 230 JoystickProtocolHandler::Read(uint32 *cookie, off_t position, void *buffer,
 231         size_t *numBytes)
 232 {
 233         if (*numBytes < fCurrentValues.data_size)
 234                 return B_BUFFER_OVERFLOW;
 235
 236         // this is a polling interface, we just return the current value
 237         status_t result = mutex_lock(&fUpdateLock);
 238         if (result != B_OK) {
 239                 *numBytes = 0;
 240                 return result;
 241         }
 242
 243         memcpy(buffer, fCurrentValues.data, fCurrentValues.data_size);
 244         mutex_unlock(&fUpdateLock);
 245
 246         *numBytes = fCurrentValues.data_size;
 247         return B_OK;
 248 }
 249
 250
 251 status_t
 252 JoystickProtocolHandler::Write(uint32 *cookie, off_t position,
 253         const void *buffer, size_t *numBytes)
 254 {
 255         *numBytes = 0;
 256         return B_NOT_SUPPORTED;
 257 }
 258
 259
 260 status_t
 261 JoystickProtocolHandler::Control(uint32 *cookie, uint32 op, void *buffer,
 262         size_t length)
 263 {
 264         switch (op) {
 265                 case B_JOYSTICK_SET_DEVICE_MODULE:
 266                 {
 267                         if (length < sizeof(joystick_module_info))
 268                                 return B_BAD_VALUE;
 269
 270                         status_t result = mutex_lock(&fUpdateLock);
 271                         if (result != B_OK)
 272                                 return result;
 273
 274                         fJoystickModuleInfo = *(joystick_module_info *)buffer;
 275
 276                         bool supportsVariable = (fJoystickModuleInfo.flags
 277                                 & js_flag_variable_size_reads) != 0;
 278                         if (!supportsVariable) {
 279                                 // We revert to a structure that we can support using only
 280                                 // the data available in an extended_joystick structure.
 281                                 free(fCurrentValues.data);
 282                                 fCurrentValues.initialize_to_extended_joystick();
 283                                 if (fAxisCount > MAX_AXES)
 284                                         fAxisCount = MAX_AXES;
 285                                 if (fHatCount > MAX_HATS)
 286                                         fHatCount = MAX_HATS;
 287                                 if (fMaxButton > MAX_BUTTONS)
 288                                         fMaxButton = MAX_BUTTONS;
 289
 290                                 TRACE_ALWAYS("using joystick in extended_joystick mode\n");
 291                         } else {
 292                                 TRACE_ALWAYS("using joystick in variable mode\n");
 293                         }
 294
 295                         fJoystickModuleInfo.num_axes = fAxisCount;
 296                         fJoystickModuleInfo.num_buttons = fMaxButton;
 297                         fJoystickModuleInfo.num_hats = fHatCount;
 298                         fJoystickModuleInfo.num_sticks = 1;
 299                         fJoystickModuleInfo.config_size = 0;
 300                         mutex_unlock(&fUpdateLock);
 301                         break;
 302                 }
 303
 304                 case B_JOYSTICK_GET_DEVICE_MODULE:
 305                         if (length < sizeof(joystick_module_info))
 306                                 return B_BAD_VALUE;
 307
 308                         *(joystick_module_info *)buffer = fJoystickModuleInfo;
 309                         break;
 310         }
 311
 312         return B_ERROR;
 313 }
 314
 315
 316 int32
 317 JoystickProtocolHandler::_UpdateThread(void *data)
 318 {
 319         JoystickProtocolHandler *handler = (JoystickProtocolHandler *)data;
 320         while (handler->fUpdateThread == find_thread(NULL)) {
 321                 status_t result = handler->_Update();
 322                 if (result != B_OK)
 323                         return result;
 324         }
 325
 326         return B_OK;
 327 }
 328
 329
 330 status_t
 331 JoystickProtocolHandler::_Update()
 332 {
 333         status_t result = fReport.WaitForReport(B_INFINITE_TIMEOUT);
 334         if (result != B_OK) {
 335                 if (fReport.Device()->IsRemoved()) {
 336                         TRACE("device has been removed\n");
 337                         return B_DEV_NOT_READY;
 338                 }
 339
 340                 if (result == B_CANCELED)
 341                         return B_CANCELED;
 342
 343                 if (result != B_INTERRUPTED) {
 344                         // interrupts happen when other reports come in on the same
 345                         // input as ours
 346                         TRACE_ALWAYS("error waiting for report: %s\n", strerror(result));
 347                 }
 348
 349                 // signal that we simply want to try again
 350                 return B_OK;
 351         }
 352
 353         result = mutex_lock(&fUpdateLock);
 354         if (result != B_OK) {
 355                 fReport.DoneProcessing();
 356                 return result;
 357         }
 358
 359         memset(fCurrentValues.data, 0, fCurrentValues.data_size);
 360
 361         for (uint32 i = 0; i < fAxisCount; i++) {
 362                 if (fAxis[i] == NULL)
 363                         continue;
 364
 365                 if (fAxis[i]->Extract() == B_OK && fAxis[i]->Valid())
 366                         fCurrentValues.axes[i] = (int16)fAxis[i]->ScaledData(16, true);
 367         }
 368
 369         for (uint32 i = 0; i < fHatCount; i++) {
 370                 HIDReportItem *hat = fHats[i];
 371                 if (hat == NULL)
 372                         continue;
 373
 374                 if (hat->Extract() != B_OK || !hat->Valid())
 375                         continue;
 376
 377                 fCurrentValues.hats[i] = hat->ScaledRangeData(1, 8);
 378         }
 379
 380         for (uint32 i = 0; i < fButtonCount; i++) {
 381                 HIDReportItem *button = fButtons[i];
 382                 if (button == NULL)
 383                         break;
 384
 385                 uint16 index = button->UsageID() - 1;
 386                 if (index >= fMaxButton)
 387                         continue;
 388
 389                 if (button->Extract() == B_OK && button->Valid()) {
 390                         fCurrentValues.buttons[index / 32]
 391                                 |= (button->Data() & 1) << (index % 32);
 392                 }
 393         }
 394
 395         fReport.DoneProcessing();
 396         TRACE("got joystick report\n");
 397
 398         *fCurrentValues.timestamp = system_time();
 399         mutex_unlock(&fUpdateLock);
 400         return B_OK;
 401 }