1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 
  27 #include <sys/usb/usba/usbai_version.h>
  28 #include <sys/usb/usba.h>
  29 #include <sys/usb/clients/hid/hid.h>
  30 #include <sys/usb/clients/hidparser/hidparser.h>
  31 #include <sys/usb/clients/hidparser/hid_parser_driver.h>
  32 #include <sys/usb/clients/hidparser/hidparser_impl.h>
  33 
  34 /*
  35  * hidparser: Parser to generate parse tree for Report Descriptors
  36  * in HID devices.
  37  */
  38 
  39 uint_t hparser_errmask = (uint_t)PRINT_MASK_ALL;
  40 uint_t  hparser_errlevel = (uint_t)USB_LOG_L1;
  41 static usb_log_handle_t hparser_log_handle;
  42 
  43 /*
  44  * Array used to store corresponding strings for the
  45  * different item types for debugging.
  46  */
  47 char            *items[500];    /* Print items */
  48 
  49 /*
  50  * modload support
  51  */
  52 extern struct mod_ops mod_miscops;
  53 
  54 static struct modlmisc modlmisc = {
  55         &mod_miscops,       /* Type of module */
  56         "HID Parser"
  57 };
  58 
  59 static struct modlinkage modlinkage = {
  60         MODREV_1, (void *)&modlmisc, NULL
  61 };
  62 
  63 int
  64 _init(void)
  65 {
  66         int rval = mod_install(&modlinkage);
  67 
  68         if (rval == 0) {
  69                 hparser_log_handle = usb_alloc_log_hdl(NULL, "hidparser",
  70                     &hparser_errlevel, &hparser_errmask, NULL, 0);
  71         }
  72 
  73         return (rval);
  74 }
  75 
  76 int
  77 _fini()
  78 {
  79         int rval = mod_remove(&modlinkage);
  80 
  81         if (rval == 0) {
  82                 usb_free_log_hdl(hparser_log_handle);
  83         }
  84 
  85         return (rval);
  86 }
  87 
  88 int
  89 _info(struct modinfo *modinfop)
  90 {
  91 
  92         return (mod_info(&modlinkage, modinfop));
  93 }
  94 
  95 /*
  96  * These functions are used internally in the parser.
  97  * local declarations
  98  */
  99 static void                     hidparser_scan(hidparser_tok_t  *);
 100 static int                      hidparser_Items(hidparser_tok_t *);
 101 static int                      hidparser_LocalItem(hidparser_tok_t *);
 102 static int                      hidparser_GlobalItem(hidparser_tok_t *);
 103 static int                      hidparser_ItemList(entity_item_t **,
 104                                         hidparser_tok_t *);
 105 static int                      hidparser_ReportDescriptor(entity_item_t **,
 106                                         hidparser_tok_t *);
 107 static int                      hidparser_ReportDescriptorDash(entity_item_t **,
 108                                         hidparser_tok_t *);
 109 static int                      hidparser_MainItem(entity_item_t **,
 110                                         hidparser_tok_t *);
 111 static void                     hidparser_free_attribute_list(
 112                                         entity_attribute_t *);
 113 static entity_item_t            *hidparser_allocate_entity(hidparser_tok_t *);
 114 static void                     hidparser_add_attribute(hidparser_tok_t *);
 115 static entity_attribute_t       *hidparser_cp_attribute_list(
 116                                 entity_attribute_t *);
 117 static entity_attribute_t       *hidparser_find_attribute_end(
 118                                 entity_attribute_t *);
 119 static entity_attribute_t       *hidparser_alloc_attrib_list(int);
 120 static void                     hidparser_report_err(int, int,
 121                                         int, int, char *);
 122 static int                      hidparser_isvalid_item(int);
 123 static entity_attribute_t       *hidparser_lookup_attribute(entity_item_t *,
 124                                         int);
 125 static void                     hidparser_global_err_check(entity_item_t *);
 126 static void                     hidparser_local_err_check(entity_item_t *);
 127 static void                     hidparser_mainitem_err_check(entity_item_t *);
 128 static unsigned int             hidparser_find_unsigned_val(
 129                                         entity_attribute_t *);
 130 static int                      hidparser_find_signed_val(
 131                                         entity_attribute_t *);
 132 static void                     hidparser_check_correspondence(
 133                                         entity_item_t *, int, int, int,
 134                                         int, char *, char *);
 135 static void                     hidparser_check_minmax_val(entity_item_t *,
 136                                         int, int, int, int);
 137 static void                     hidparser_check_minmax_val_signed(
 138                                         entity_item_t *,
 139                                         int, int, int, int);
 140 static void                     hidparser_error_delim(entity_item_t *, int);
 141 static int                      hidparser_get_usage_attribute_report_des(
 142                                         entity_item_t *,
 143                                         uint32_t, uint32_t, uint32_t,
 144                                         uint32_t, uint32_t, int32_t *);
 145 static int                      hidparser_get_packet_size_report_des(
 146                                         entity_item_t *, uint32_t, uint32_t,
 147                                         uint32_t *);
 148 static int                      hidparser_get_main_item_data_descr_main(
 149                                         entity_item_t *, uint32_t,
 150                                         uint32_t, uint32_t, uint32_t,
 151                                         uint32_t        *);
 152 static void                     hidparser_print_entity(
 153                                         entity_item_t *entity,
 154                                         int indent_level);
 155 static void                     hidparser_print_this_attribute(
 156                                         entity_attribute_t *attribute,
 157                                         char *ident_space);
 158 static int                      hidparser_main(unsigned char *, size_t,
 159                                         entity_item_t **);
 160 static void                     hidparser_initialize_items();
 161 static void                     hidparser_free_report_descr_handle(
 162                                         entity_item_t *);
 163 static int                      hidparser_print_report_descr_handle(
 164                                         entity_item_t   *handle,
 165                                         int             indent_level);
 166 static int                      hidparser_get_usage_list_in_order_internal(
 167                                         entity_item_t *parse_handle,
 168                                         uint_t collection_usage,
 169                                         uint_t report_id,
 170                                         uint_t main_item_type,
 171                                         hidparser_rpt_t *rpt);
 172 static void                     hidparser_fill_usage_info(
 173                                         hidparser_usage_info_t *ui,
 174                                         entity_attribute_t *attribute);
 175 static int                      hidparser_get_report_id_list_internal(
 176                                         entity_item_t *parser_handle,
 177                                         uint_t main_item_type,
 178                                         hidparser_report_id_list_t *id_lst);
 179 
 180 /*
 181  * The hidparser_lookup_first(N) of a non-terminal N is stored as an array of
 182  * integer tokens, terminated by 0. Right now there is only one element.
 183  */
 184 static hidparser_terminal_t     first_Items[] = {
 185         R_ITEM_USAGE_PAGE, R_ITEM_LOGICAL_MINIMUM, R_ITEM_LOGICAL_MAXIMUM, \
 186         R_ITEM_PHYSICAL_MINIMUM, R_ITEM_PHYSICAL_MAXIMUM, R_ITEM_UNIT, \
 187         R_ITEM_EXPONENT, R_ITEM_REPORT_SIZE, R_ITEM_REPORT_COUNT, \
 188         R_ITEM_REPORT_ID, \
 189         R_ITEM_USAGE, R_ITEM_USAGE_MIN, R_ITEM_USAGE_MAX, \
 190         R_ITEM_DESIGNATOR_INDEX, \
 191         R_ITEM_DESIGNATOR_MIN, R_ITEM_STRING_INDEX, R_ITEM_STRING_MIN, \
 192         R_ITEM_STRING_MAX, \
 193         R_ITEM_SET_DELIMITER, \
 194         0
 195 };
 196 
 197 
 198 /*
 199  * Each non-terminal is represented by a function. In a top-down parser,
 200  * whenever a non-terminal is encountered on the state diagram, the
 201  * corresponding function is called. Because of the grammar, there is NO
 202  * backtracking. If there is an error in the middle, the parser returns
 203  * HIDPARSER_FAILURE
 204  */
 205 static hidparser_terminal_t *hid_first_list[] = {
 206         first_Items
 207 };
 208 
 209 
 210 /*
 211  * hidparser_parse_report_descriptor:
 212  *      Calls the main parser routine
 213  */
 214 int
 215 hidparser_parse_report_descriptor(
 216                         unsigned char *descriptor,
 217                         size_t size,
 218                         usb_hid_descr_t *hid_descriptor,
 219                         hidparser_handle_t *parse_handle)
 220 {
 221         int     error = 0;
 222         entity_item_t   *root;
 223 
 224         hidparser_initialize_items();
 225 
 226         error = hidparser_main(descriptor, size, &root);
 227 
 228         if (error != HIDPARSER_SUCCESS) {
 229 
 230                 return (HIDPARSER_FAILURE);
 231         } else {
 232                 *parse_handle = kmem_zalloc(
 233                     sizeof (hidparser_handle), KM_SLEEP);
 234                 (*parse_handle)->hidparser_handle_hid_descr = hid_descriptor;
 235                 (*parse_handle)->hidparser_handle_parse_tree = root;
 236 
 237                 return (HIDPARSER_SUCCESS);
 238         }
 239 }
 240 
 241 
 242 /*
 243  * hidparser_free_report_descriptor_handle:
 244  *      Frees the parse_handle which consists of a pointer to the parse
 245  *      tree and a pointer to the Hid descriptor structure
 246  */
 247 int
 248 hidparser_free_report_descriptor_handle(hidparser_handle_t parse_handle)
 249 {
 250         if (parse_handle != NULL) {
 251                 hidparser_free_report_descr_handle(
 252                     parse_handle->hidparser_handle_parse_tree);
 253                 if (parse_handle != NULL) {
 254                         kmem_free(parse_handle, sizeof (hidparser_handle));
 255                 }
 256         }
 257 
 258         return (HIDPARSER_SUCCESS);
 259 }
 260 
 261 
 262 /*
 263  * hidparser_get_country_code:
 264  *      Return the bCountryCode from the Hid Descriptor
 265  *      to the hid module.
 266  */
 267 int
 268 hidparser_get_country_code(hidparser_handle_t parser_handle,
 269                         uint16_t *country_code)
 270 {
 271         if ((parser_handle == NULL) ||
 272             (parser_handle->hidparser_handle_hid_descr == NULL)) {
 273 
 274                 return (HIDPARSER_FAILURE);
 275         }
 276 
 277         *country_code =
 278             parser_handle->hidparser_handle_hid_descr->bCountryCode;
 279 
 280         return (HIDPARSER_SUCCESS);
 281 }
 282 
 283 
 284 /*
 285  * hidparser_get_packet_size:
 286  *      Get the packet size(sum of REPORT_SIZE * REPORT_COUNT)
 287  *      corresponding to a report id and an item type
 288  */
 289 int
 290 hidparser_get_packet_size(hidparser_handle_t parser_handle,
 291                         uint_t report_id,
 292                         uint_t main_item_type,
 293                         uint_t *size)
 294 {
 295         if ((parser_handle == NULL) || (parser_handle->
 296             hidparser_handle_parse_tree == NULL)) {
 297 
 298                 return (HIDPARSER_FAILURE);
 299         }
 300 
 301         *size = 0;
 302 
 303         return (hidparser_get_packet_size_report_des(
 304             parser_handle->hidparser_handle_parse_tree,
 305             report_id, main_item_type, size));
 306 }
 307 
 308 
 309 /*
 310  * hidparser_get_packet_size_report_des:
 311  *      Get the packet size(sum of REPORT_SIZE * REPORT_COUNT)
 312  *      corresponding to a report id and an item type
 313  */
 314 int
 315 hidparser_get_packet_size_report_des(entity_item_t *parser_handle,
 316                         uint32_t report_id,
 317                         uint32_t main_item_type,
 318                         uint32_t *size)
 319 {
 320         entity_item_t   *current = parser_handle;
 321         entity_attribute_t *attribute;
 322         uint32_t        temp;
 323         uchar_t         foundsize, foundcount, foundreportid, right_report_id;
 324 
 325         foundsize = 0;
 326         foundcount = 0;
 327         right_report_id = 0;
 328 
 329         while (current) {
 330                 if (current->entity_item_type == R_ITEM_COLLECTION) {
 331                         (void) hidparser_get_packet_size_report_des(
 332                             current->info.child, report_id, main_item_type,
 333                             size);
 334                 } else if (current->entity_item_type == main_item_type) {
 335                         temp = 1;
 336                         foundsize = 0;
 337                         foundcount = 0;
 338 
 339                         foundreportid = 0;
 340                         attribute = current->entity_item_attributes;
 341                         while (attribute != NULL) {
 342                                 if (attribute->entity_attribute_tag ==
 343                                     R_ITEM_REPORT_ID) {
 344                                         foundreportid = 1;
 345                                         if ((attribute->
 346                                             entity_attribute_value[0]) ==
 347                                             report_id) {
 348                                                 right_report_id = 1;
 349                                         }
 350                                 } else if (attribute->entity_attribute_tag ==
 351                                     R_ITEM_REPORT_SIZE) {
 352                                         foundsize = 1;
 353                                         temp *= hidparser_find_unsigned_val(
 354                                             attribute);
 355                                         if (foundcount == 1) {
 356                                                 if (report_id &&
 357                                                     right_report_id) {
 358                                                         break;
 359                                                 }
 360                                         }
 361                                 } else if (attribute->entity_attribute_tag ==
 362                                     R_ITEM_REPORT_COUNT) {
 363                                         foundcount = 1;
 364                                         temp *= hidparser_find_unsigned_val(
 365                                             attribute);
 366                                         if (foundsize == 1) {
 367                                                 if (report_id &&
 368                                                     right_report_id) {
 369                                                         break;
 370                                                 }
 371                                         }
 372                                 }
 373                                 attribute = attribute->entity_attribute_next;
 374                         } /* end while */
 375 
 376                         if (foundreportid) {
 377                                 if (right_report_id) {
 378                                         *size = *size + temp;
 379                                 }
 380                         } else if (report_id == HID_REPORT_ID_UNDEFINED) {
 381                                 /* Just sanity checking */
 382                                 *size = *size + temp;
 383                         }
 384                         right_report_id = 0;
 385                 } /* end else if */
 386 
 387                 current = current->entity_item_right_sibling;
 388         } /* end while current */
 389 
 390 
 391         return (HIDPARSER_SUCCESS);
 392 }
 393 
 394 
 395 /*
 396  * hidparser_get_usage_attribute:
 397  *      Get the attribute value corresponding to a particular
 398  *      report id, main item and usage
 399  */
 400 int
 401 hidparser_get_usage_attribute(hidparser_handle_t parser_handle,
 402                         uint_t report_id,
 403                         uint_t main_item_type,
 404                         uint_t usage_page,
 405                         uint_t usage_id,
 406                         uint_t usage_attribute,
 407                         int *usage_attribute_value)
 408 {
 409 
 410         return (hidparser_get_usage_attribute_report_des(
 411             parser_handle->hidparser_handle_parse_tree,
 412             report_id, main_item_type, usage_page,
 413             usage_id, usage_attribute, usage_attribute_value));
 414 }
 415 
 416 
 417 /*
 418  * hidparser_get_usage_attribute_report_des:
 419  *      Called by the wrapper function hidparser_get_usage_attribute()
 420  */
 421 static int
 422 hidparser_get_usage_attribute_report_des(entity_item_t *parser_handle,
 423                         uint_t report_id,
 424                         uint_t main_item_type,
 425                         uint_t usage_page,
 426                         uint_t usage_id,
 427                         uint_t usage_attribute,
 428                         int *usage_attribute_value)
 429 
 430 {
 431         entity_item_t *current = parser_handle;
 432         entity_attribute_t *attribute;
 433         uchar_t found_page, found_ret_value, found_usage_id;
 434         uchar_t foundreportid, right_report_id;
 435         uint32_t usage;
 436         short attvalue;
 437 
 438         found_page = 0;
 439         found_ret_value = 0;
 440         found_usage_id = 0;
 441         foundreportid = 0;
 442         right_report_id = 0;
 443 
 444         while (current) {
 445                 if (usage_id == HID_USAGE_UNDEFINED) {
 446                         found_usage_id = 1;
 447                 }
 448                 if (current->entity_item_type == R_ITEM_COLLECTION) {
 449 
 450                         if (hidparser_get_usage_attribute_report_des(
 451                             current->info.child, report_id, main_item_type,
 452                             usage_page, usage_id, usage_attribute,
 453                             usage_attribute_value) ==
 454                             HIDPARSER_SUCCESS) {
 455 
 456                                 return (HIDPARSER_SUCCESS);
 457                         }
 458 
 459                 } else if (current->entity_item_type == main_item_type) {
 460                         /* Match Item Type */
 461                         attribute = current->entity_item_attributes;
 462 
 463                         while (attribute != NULL) {
 464                                 if (attribute->entity_attribute_tag ==
 465                                     R_ITEM_USAGE) {
 466                                         usage = hidparser_find_unsigned_val(
 467                                             attribute);
 468                                         if (usage_id == HID_USAGE_ID(usage)) {
 469 
 470                                                 found_usage_id = 1;
 471                                         } else {
 472                                                 /*
 473                                                  * If we are trying to find out
 474                                                  * say, report size of usage =
 475                                                  * 0, a m.i with a valid usage
 476                                                  * will not contain that
 477                                                  */
 478                                                 if (usage_id ==
 479                                                     HID_USAGE_UNDEFINED) {
 480                                                         found_usage_id = 0;
 481                                                 }
 482                                         }
 483 
 484                                         if (found_usage_id && attribute->
 485                                             entity_attribute_length == 3) {
 486                                                 /*
 487                                                  * This is an extended usage ie.
 488                                                  * usage page in upper 16 bits
 489                                                  * or-ed with usage in the lower
 490                                                  * 16 bits.
 491                                                  */
 492                                                 if (HID_USAGE_PAGE(usage) &&
 493                                                     HID_USAGE_PAGE(usage) ==
 494                                                     usage_page) {
 495 
 496                                                         found_page = 1;
 497                                                 } else {
 498 
 499                                                         found_usage_id = 0;
 500                                                 }
 501                                         }
 502                                 } else if (attribute->entity_attribute_tag ==
 503                                     R_ITEM_USAGE_PAGE) {
 504                                         if (attribute->
 505                                             entity_attribute_value[0] ==
 506                                             usage_page) {
 507                                                 /* Match Usage Page */
 508                                                 found_page = 1;
 509                                         }
 510                                 } else if (attribute->entity_attribute_tag ==
 511                                     R_ITEM_REPORT_ID) {
 512                                         foundreportid = 1;
 513                                         if (attribute->
 514                                             entity_attribute_value[0] ==
 515                                             report_id) {
 516                                                 right_report_id = 1;
 517                                         }
 518                                 }
 519                                 if (attribute->entity_attribute_tag ==
 520                                     usage_attribute) {
 521                                         /* Match attribute */
 522                                         found_ret_value = 1;
 523                                         *usage_attribute_value =
 524                                         attribute->entity_attribute_value[0];
 525                                         if (attribute->
 526                                             entity_attribute_length == 2) {
 527                                                 attvalue =
 528                                                     (attribute->
 529                                                     entity_attribute_value[0] &
 530                                                     0xff) |
 531                                                     (attribute->
 532                                                     entity_attribute_value[1] <<
 533                                                     8);
 534                                                 *usage_attribute_value =
 535                                                     attvalue;
 536                                         }
 537                                 }
 538                                 attribute = attribute->entity_attribute_next;
 539                         }
 540 
 541                         if (found_usage_id && found_page && found_ret_value) {
 542 
 543                                 if (foundreportid) {
 544                                         if (right_report_id) {
 545 
 546                                                 return (HIDPARSER_SUCCESS);
 547                                         } else if (report_id ==
 548                                             HID_REPORT_ID_UNDEFINED) {
 549 
 550                                                 return (HIDPARSER_SUCCESS);
 551                                         }
 552                                 } else {
 553 
 554                                         return (HIDPARSER_SUCCESS);
 555                                 }
 556                         }
 557                 }
 558 
 559                 /*
 560                  * search the next main item, right sibling of this one
 561                  */
 562                 if (current->entity_item_right_sibling != NULL) {
 563 
 564                         current = current->entity_item_right_sibling;
 565                         found_usage_id = found_page = found_ret_value = 0;
 566                         /* Don't change foundreportid */
 567                         right_report_id = 0;
 568                 } else {
 569 
 570                         break;
 571                 }
 572         }
 573         /* Don't give junk result */
 574         *usage_attribute_value = 0;
 575 
 576         return (HIDPARSER_NOT_FOUND);
 577 }
 578 
 579 
 580 /*
 581  * hidparser_get_main_item_data_descr:
 582  *      Get the data value corresponding to a particular
 583  *      Main Item (Input, Output, Feature)
 584  */
 585 int
 586 hidparser_get_main_item_data_descr(hidparser_handle_t parser_handle,
 587                         uint_t report_id,
 588                         uint_t main_item_type,
 589                         uint_t usage_page,
 590                         uint_t usage_id,
 591                         uint_t *main_item_descr_value)
 592 {
 593 
 594         return hidparser_get_main_item_data_descr_main(
 595             parser_handle->hidparser_handle_parse_tree,
 596             report_id, main_item_type, usage_page, usage_id,
 597             main_item_descr_value);
 598 }
 599 
 600 
 601 /*
 602  * hidparser_get_main_item_data_descr_main:
 603  *      Called by the wrapper function hidparser_get_main_item_data_descr()
 604  */
 605 static int
 606 hidparser_get_main_item_data_descr_main(entity_item_t *parser_handle,
 607                         uint_t report_id,
 608                         uint_t main_item_type,
 609                         uint_t usage_page,
 610                         uint_t usage_id,
 611                         uint_t *main_item_descr_value)
 612 {
 613         entity_item_t *current = parser_handle;
 614         entity_attribute_t *attribute;
 615 
 616         uchar_t found_page, found_usage_id;
 617         uchar_t foundreportid, right_report_id;
 618         uint32_t usage;
 619 
 620         found_page = 0;
 621         found_usage_id = 0;
 622         foundreportid = 0;
 623         right_report_id = 0;
 624 
 625         while (current) {
 626                 if (usage_id == HID_USAGE_UNDEFINED) {
 627                         found_usage_id = 1;
 628                 }
 629                 if (current->entity_item_type == R_ITEM_COLLECTION) {
 630 
 631                         if (hidparser_get_main_item_data_descr_main(
 632                             current->info.child, report_id, main_item_type,
 633                             usage_page, usage_id, main_item_descr_value) ==
 634                             HIDPARSER_SUCCESS) {
 635 
 636                                 return (HIDPARSER_SUCCESS);
 637                         }
 638                 } else if (current->entity_item_type == main_item_type) {
 639                         /* Match Item Type */
 640                         attribute = current->entity_item_attributes;
 641 
 642                         if (report_id == HID_REPORT_ID_UNDEFINED) {
 643                                 foundreportid = right_report_id = 1;
 644                         }
 645 
 646                         while (attribute != NULL) {
 647                                 if (attribute->entity_attribute_tag ==
 648                                     R_ITEM_USAGE) {
 649                                         usage = hidparser_find_unsigned_val(
 650                                             attribute);
 651                                         if (usage_id == HID_USAGE_ID(usage)) {
 652                                                 found_usage_id = 1;
 653                                                 if (attribute->
 654                                                     entity_attribute_length ==
 655                                                     3) {
 656                                                         if (HID_USAGE_PAGE(
 657                                                             usage) &&
 658                                                             HID_USAGE_PAGE(
 659                                                             usage) ==
 660                                                             usage_page) {
 661 
 662                                                                 found_page = 1;
 663                                                         } else {
 664 
 665                                                         found_usage_id = 0;
 666                                                         }
 667                                                 }
 668 
 669                                                 if (found_usage_id &&
 670                                                     found_page &&
 671                                                     foundreportid &&
 672                                                     right_report_id) {
 673                                                 *main_item_descr_value =
 674                                                     current->
 675                                                     entity_item_params[0];
 676                                                 break;
 677                                                 }
 678                                         }
 679                                 } else if ((attribute->entity_attribute_tag ==
 680                                     R_ITEM_USAGE_PAGE) &&
 681                                     (attribute->entity_attribute_value[0] ==
 682                                     usage_page)) {
 683 
 684                                         /* Match Usage Page */
 685                                         found_page = 1;
 686                                         if (found_usage_id && foundreportid &&
 687                                             right_report_id) {
 688                                                 *main_item_descr_value =
 689                                                     current->
 690                                                     entity_item_params[0];
 691                                                 break;
 692                                         }
 693                                 } else if (attribute->entity_attribute_tag ==
 694                                     R_ITEM_REPORT_ID) {
 695                                         foundreportid = 1;
 696                                         if (attribute->
 697                                             entity_attribute_value[0] ==
 698                                             report_id) {
 699                                                 right_report_id = 1;
 700                                         } else {
 701                                                 break;
 702                                         }
 703                                 }
 704 
 705                                 attribute = attribute->entity_attribute_next;
 706                         }
 707 
 708                         if (foundreportid) {
 709                                 if (right_report_id) {
 710                                         if (found_usage_id && found_page) {
 711 
 712                                                 return (HIDPARSER_SUCCESS);
 713                                         }
 714                                 }
 715                         }
 716                 }
 717 
 718                 /*
 719                  * search the next main item, right sibling of this one
 720                  */
 721                 if (current->entity_item_right_sibling != NULL) {
 722 
 723                         current = current->entity_item_right_sibling;
 724                         found_page = found_usage_id = right_report_id = 0;
 725                 } else {
 726 
 727                         break;
 728                 }
 729         }
 730 
 731         *main_item_descr_value = (uint_t)NULL;
 732 
 733         return (HIDPARSER_NOT_FOUND);
 734 }
 735 
 736 /*
 737  * hidparser_lookup_usage_collection:
 738  *      Look up the collection specified by the usage page and usage id
 739  */
 740 int
 741 hidparser_lookup_usage_collection(hidparser_handle_t parse_handle,
 742                         uint_t lusage_page,
 743                         uint_t lusage_id)
 744 {
 745         entity_item_t *current;
 746         entity_attribute_t *attribute;
 747         int found_usage_id = 0;
 748         int found_page = 0;
 749         uint32_t usage;
 750         uint_t usage_page;
 751         uint_t usage_id;
 752 
 753         if ((parse_handle == NULL) ||
 754             (parse_handle->hidparser_handle_parse_tree == NULL))
 755                 return (HIDPARSER_FAILURE);
 756 
 757         current = parse_handle->hidparser_handle_parse_tree;
 758         while (current != NULL) {
 759 
 760                 if (current->entity_item_type != R_ITEM_COLLECTION) {
 761                         current = current->entity_item_right_sibling;
 762                         continue;
 763                 }
 764 
 765                 attribute = current->entity_item_attributes;
 766                 found_usage_id = 0;
 767                 found_page = 0;
 768 
 769                 while (attribute != NULL) {
 770                         if (attribute->entity_attribute_tag == R_ITEM_USAGE) {
 771                                 found_usage_id = 1;
 772                                 usage = hidparser_find_unsigned_val(attribute);
 773                                 usage_id = HID_USAGE_ID(usage);
 774                                 if (attribute->entity_attribute_length == 3) {
 775                                         if (HID_USAGE_PAGE(usage)) {
 776                                                 found_page = 1;
 777                                                 usage_page =
 778                                                     HID_USAGE_PAGE(usage);
 779                                         }
 780                                 }
 781                                 if (found_page) {
 782                                         goto check_usage;
 783                                 }
 784                         } else if (attribute->entity_attribute_tag ==
 785                             R_ITEM_USAGE_PAGE) {
 786                                 found_page = 1;
 787                                 usage_page =
 788                                     attribute->entity_attribute_value[0];
 789                                 if (found_usage_id) {
 790                                         goto check_usage;
 791                                 }
 792                         }
 793                         attribute = attribute->entity_attribute_next;
 794                 }
 795 check_usage:
 796                 if ((usage_page == lusage_page) && (usage_id == lusage_id))
 797                         return (HIDPARSER_SUCCESS);
 798                 else
 799                         current = current->entity_item_right_sibling;
 800         }
 801 
 802         return (HIDPARSER_FAILURE);
 803 }
 804 
 805 
 806 /*
 807  * hidparser_get_top_level_collection_usage:
 808  *      Get the usage page and usage for the top level collection item
 809  */
 810 int
 811 hidparser_get_top_level_collection_usage(hidparser_handle_t parse_handle,
 812                         uint_t *usage_page,
 813                         uint_t *usage_id)
 814 {
 815         entity_item_t *current;
 816         entity_attribute_t *attribute;
 817         int found_usage_id = 0;
 818         int found_page = 0;
 819         uint32_t usage;
 820 
 821         if ((parse_handle == NULL) ||
 822             (parse_handle->hidparser_handle_parse_tree == NULL))
 823 
 824                 return (HIDPARSER_FAILURE);
 825 
 826         current = parse_handle->hidparser_handle_parse_tree;
 827 
 828         if (current->entity_item_type != R_ITEM_COLLECTION) {
 829 
 830                 return (HIDPARSER_FAILURE);
 831         }
 832         attribute = current->entity_item_attributes;
 833         while (attribute != NULL) {
 834                 if (attribute->entity_attribute_tag == R_ITEM_USAGE) {
 835                         found_usage_id = 1;
 836                         usage = hidparser_find_unsigned_val(attribute);
 837                         *usage_id = HID_USAGE_ID(usage);
 838                         if (attribute->entity_attribute_length == 3) {
 839                                 if (HID_USAGE_PAGE(usage)) {
 840                                         found_page = 1;
 841                                         *usage_page = HID_USAGE_PAGE(usage);
 842                                 }
 843                         }
 844                         if (found_usage_id && found_page) {
 845 
 846                                 return (HIDPARSER_SUCCESS);
 847                         }
 848                 } else if (attribute->entity_attribute_tag ==
 849                     R_ITEM_USAGE_PAGE) {
 850                         found_page = 1;
 851                         *usage_page = attribute->entity_attribute_value[0];
 852                         if (found_usage_id && found_page) {
 853 
 854                                 return (HIDPARSER_SUCCESS);
 855                         }
 856                 }
 857                 attribute = attribute->entity_attribute_next;
 858         }
 859 
 860         return (HIDPARSER_FAILURE);
 861 }
 862 
 863 
 864 /*
 865  * hidparser_get_usage_list_in_order:
 866  *      Find all the usages corresponding to a main item and report id.
 867  *      Note that only short items are supported.
 868  *
 869  * Arguments:
 870  *      parser_handle:
 871  *              hid parser handle
 872  *      report id:
 873  *              report id of the particular report where the usages belong to
 874  *      main_item_type:
 875  *              type of report, either Input, Output, or Feature
 876  *      usage_list:
 877  *              Filled in with the pointer to the first element of the
 878  *              usage list
 879  *
 880  * Return values:
 881  *      HIDPARSER_SUCCESS - returned success
 882  *      HIDPARSER_NOT_FOUND - usage specified by the parameters was not found
 883  *      HIDPARSER_FAILURE - unspecified failure
 884  */
 885 int
 886 hidparser_get_usage_list_in_order(hidparser_handle_t parser_handle,
 887                         uint_t report_id,
 888                         uint_t main_item_type,
 889                         hidparser_rpt_t *rpt)
 890 {
 891 
 892         if ((parser_handle == NULL) ||
 893             (parser_handle->hidparser_handle_parse_tree == NULL)) {
 894 
 895                 return (HIDPARSER_FAILURE);
 896         }
 897 
 898         rpt->no_of_usages = 0;
 899 
 900         return (hidparser_get_usage_list_in_order_internal(
 901             parser_handle->hidparser_handle_parse_tree, HID_USAGE_UNDEFINED,
 902             report_id, main_item_type, rpt));
 903 }
 904 
 905 
 906 static int
 907 hidparser_get_usage_list_in_order_internal(entity_item_t *parser_handle,
 908                         uint_t collection_usage,
 909                         uint_t report_id,
 910                         uint_t main_item_type,
 911                         hidparser_rpt_t *rpt)
 912 {
 913 
 914         /* setup wrapper function */
 915         entity_item_t *current = parser_handle;
 916         entity_attribute_t *attribute;
 917         uchar_t foundreportid, right_report_id, valid_usage;
 918         uchar_t found_usage_min, found_usage_max, found_usage;
 919         int i, j;
 920         int rval;
 921         uint32_t usage, usage_min, usage_max, usage_id[USAGE_MAX];
 922         hidparser_usage_info_t *ui;
 923 
 924         found_usage_min = 0;
 925         found_usage_max = 0;
 926         foundreportid = 0;
 927         right_report_id = 0;
 928 
 929         while (current) {
 930 
 931                 if (current->entity_item_type == R_ITEM_COLLECTION) {
 932 
 933                         /*
 934                          * find collection usage information for this
 935                          * collection
 936                          */
 937                         valid_usage = 0;
 938 
 939                         attribute = current->entity_item_attributes;
 940 
 941                         while (attribute != NULL) {
 942                                 if (attribute->entity_attribute_tag ==
 943                                     R_ITEM_USAGE) {
 944                                         usage = hidparser_find_unsigned_val(
 945                                             attribute);
 946                                         valid_usage = 1;
 947                                 }
 948                                 attribute = attribute->entity_attribute_next;
 949                         }
 950 
 951                         if (!valid_usage) {
 952                                 usage = HID_USAGE_UNDEFINED;
 953                         }
 954 
 955                         rval = hidparser_get_usage_list_in_order_internal(
 956                             current->info.child, usage,
 957                             report_id, main_item_type, rpt);
 958                         if (rval != HIDPARSER_SUCCESS) {
 959 
 960                                 return (rval);
 961                         }
 962 
 963                 } else if (current->entity_item_type == main_item_type) {
 964                         /* Match Item Type */
 965 
 966                         foundreportid = 0;
 967                         right_report_id = 0;
 968                         found_usage_min = 0;
 969                         found_usage_max = 0;
 970                         found_usage = 0;
 971                         valid_usage = 0;
 972 
 973                         attribute = current->entity_item_attributes;
 974 
 975                         while (attribute != NULL) {
 976                                 switch (attribute->entity_attribute_tag) {
 977                                 case R_ITEM_REPORT_ID:
 978                                         foundreportid = 1;
 979 
 980                                         if (attribute->
 981                                             entity_attribute_value[0] ==
 982                                             report_id) {
 983                                                 right_report_id = 1;
 984                                         } else {
 985                                                 /* different report id */
 986                                                 valid_usage = 1;
 987                                         }
 988 
 989                                         break;
 990                                 case R_ITEM_USAGE:
 991                                         if (found_usage >= USAGE_MAX) {
 992 
 993                                                 return (HIDPARSER_FAILURE);
 994                                         }
 995                                         usage = hidparser_find_unsigned_val(
 996                                             attribute);
 997                                         if (usage) {
 998                                                 usage_id[found_usage] = usage;
 999                                                 found_usage++;
1000                                         }
1001 
1002                                         break;
1003                                 case R_ITEM_USAGE_MIN:
1004                                         found_usage_min = 1;
1005                                         usage_min = hidparser_find_unsigned_val(
1006                                             attribute);
1007 
1008                                         break;
1009                                 case R_ITEM_USAGE_MAX:
1010                                         found_usage_max = 1;
1011                                         usage_max = hidparser_find_unsigned_val(
1012                                             attribute);
1013 
1014                                         break;
1015                                 case R_ITEM_SET_DELIMITER:
1016                                         /* skip over alternate usages */
1017                                         do {
1018                                                 attribute = attribute->
1019                                                     entity_attribute_next;
1020                                         } while (attribute->
1021                                             entity_attribute_tag !=
1022                                             R_ITEM_SET_DELIMITER);
1023 
1024                                         break;
1025                                 }
1026 
1027                                 attribute = attribute->entity_attribute_next;
1028                         }
1029 
1030                         /*
1031                          * If we have a report id match (or report ids
1032                          * are not present), and have a usage item or
1033                          * usage min&max, put the usage item into the
1034                          * list. Don't put undefined usage items
1035                          * (HID_USAGE_UNDEFINED, 0) into the list;
1036                          * a 0 usage item is used to match padding
1037                          * fields that don't have an attached usage.
1038                          */
1039                         if (!foundreportid ||
1040                             (foundreportid && right_report_id)) {
1041 
1042                                 for (j = 0; j < found_usage; j++) {
1043 
1044                                         /* Put in usage list */
1045                                         if (rpt->no_of_usages >= USAGE_MAX) {
1046 
1047                                                 return (HIDPARSER_FAILURE);
1048                                         }
1049 
1050                                         i = rpt->no_of_usages++;
1051                                         ui = &(rpt->usage_descr[i]);
1052 
1053                                         hidparser_fill_usage_info(ui,
1054                                             current->entity_item_attributes);
1055 
1056                                         ui->rptcnt /= found_usage;
1057                                         ui->collection_usage = collection_usage;
1058                                         ui->usage_id = HID_USAGE_ID(
1059                                             usage_id[j]);
1060 
1061                                         /*
1062                                          * This is an extended usage ie.
1063                                          * usage page in upper 16 bits
1064                                          * or-ed with usage in the lower
1065                                          * 16 bits.
1066                                          */
1067                                         if (usage_id[j] >> 16) {
1068                                                 ui->usage_page =
1069                                                     HID_USAGE_PAGE(usage_id[j]);
1070                                         }
1071 
1072                                         rpt->report_id = report_id;
1073                                         valid_usage = 1;
1074                                 }
1075 
1076                                 if (found_usage_min && found_usage_max) {
1077 
1078                                         /* Put in usage list */
1079                                         if (rpt->no_of_usages >= USAGE_MAX) {
1080 
1081                                                 return (HIDPARSER_FAILURE);
1082                                         }
1083 
1084                                         if (found_usage) {
1085 
1086                                                 /* handle duplication */
1087                                                 ui->usage_min = HID_USAGE_ID(
1088                                                     usage_min);
1089                                                 ui->usage_max = HID_USAGE_ID(
1090                                                     usage_max);
1091                                         } else {
1092                                                 i = rpt->no_of_usages++;
1093                                                 ui = &(rpt->usage_descr[i]);
1094 
1095                                                 hidparser_fill_usage_info(ui,
1096                                                     current->
1097                                                     entity_item_attributes);
1098 
1099                                                 ui->collection_usage =
1100                                                     collection_usage;
1101                                                 ui->usage_min = HID_USAGE_ID(
1102                                                     usage_min);
1103                                                 ui->usage_max = HID_USAGE_ID(
1104                                                     usage_max);
1105 
1106                                                 rpt->report_id = report_id;
1107                                                 valid_usage = 1;
1108                                         }
1109 
1110                                         /*
1111                                          * This is an extended usage ie.
1112                                          * usage page in upper 16 bits
1113                                          * or-ed with usage_max in the lower
1114                                          * 16 bits.
1115                                          */
1116                                         if (usage_max >> 16) {
1117                                                 ui->usage_page =
1118                                                     HID_USAGE_PAGE(usage_max);
1119                                         }
1120                                 }
1121                         }
1122 
1123                         /*
1124                          * This main item contains no usage
1125                          * Fill in with usage "UNDEFINED".
1126                          * If report id is valid, only the
1127                          * main item with matched report id
1128                          * can be filled in.
1129                          */
1130                         if (!valid_usage) {
1131 
1132                                 if (rpt->no_of_usages >= USAGE_MAX) {
1133 
1134                                         return (HIDPARSER_FAILURE);
1135                                 }
1136 
1137                                 i = rpt->no_of_usages++;
1138                                 ui = &(rpt->usage_descr[i]);
1139 
1140                                 hidparser_fill_usage_info(ui,
1141                                     current->entity_item_attributes);
1142 
1143                                 ui->collection_usage = collection_usage;
1144                                 ui->usage_id = HID_USAGE_UNDEFINED;
1145 
1146                                 rpt->report_id = report_id;
1147                         }
1148 
1149                 }
1150 
1151                 current = current->entity_item_right_sibling;
1152 
1153         } /* end while current */
1154 
1155         return (HIDPARSER_SUCCESS);
1156 }
1157 
1158 
1159 /*
1160  * hidparser_fill_usage_info():
1161  *      Fill in the mandatory item information for a main item.
1162  *      See HID 6.2.2.
1163  */
1164 static void
1165 hidparser_fill_usage_info(hidparser_usage_info_t *ui,
1166                         entity_attribute_t *attribute)
1167 {
1168         bzero(ui, sizeof (*ui));
1169 
1170         while (attribute) {
1171                 switch (attribute->entity_attribute_tag) {
1172                 case R_ITEM_LOGICAL_MINIMUM:
1173                         ui->lmin = hidparser_find_signed_val(attribute);
1174 
1175                         break;
1176                 case R_ITEM_LOGICAL_MAXIMUM:
1177                         ui->lmax = hidparser_find_signed_val(attribute);
1178 
1179                         break;
1180                 case R_ITEM_REPORT_COUNT:
1181                         ui->rptcnt = hidparser_find_unsigned_val(attribute);
1182 
1183                         break;
1184                 case R_ITEM_REPORT_SIZE:
1185                         ui->rptsz = hidparser_find_unsigned_val(attribute);
1186 
1187                         break;
1188                 case R_ITEM_USAGE_PAGE:
1189                         ui->usage_page = hidparser_find_unsigned_val(attribute)
1190                             & 0xffff;
1191 
1192                         break;
1193                 }
1194 
1195                 attribute = attribute->entity_attribute_next;
1196         }
1197 }
1198 
1199 
1200 /*
1201  * hidparser_get_report_id_list:
1202  *      Return a list of all report ids used for descriptor items
1203  *      corresponding to a main item.
1204  *
1205  * Arguments:
1206  *      parser_handle:
1207  *              hid parser handle
1208  *      main_item_type:
1209  *              type of report, either Input, Output, or Feature
1210  *      report_id_list:
1211  *              Filled in with a list of report ids found in the descriptor
1212  *
1213  * Return values:
1214  *      HIDPARSER_SUCCESS - returned success
1215  *      HIDPARSER_FAILURE - unspecified failure
1216  */
1217 int
1218 hidparser_get_report_id_list(hidparser_handle_t parser_handle,
1219                         uint_t main_item_type,
1220                         hidparser_report_id_list_t *report_id_list)
1221 {
1222 
1223         if ((parser_handle == NULL) ||
1224             (parser_handle->hidparser_handle_parse_tree == NULL)) {
1225 
1226                 return (HIDPARSER_FAILURE);
1227         }
1228 
1229         report_id_list->no_of_report_ids = 0;
1230 
1231         return (hidparser_get_report_id_list_internal(
1232             parser_handle->hidparser_handle_parse_tree,
1233             main_item_type, report_id_list));
1234 }
1235 
1236 
1237 /*
1238  * hidparser_get_report_id_list_internal:
1239  *      internal function that generates list of all report ids
1240  */
1241 int
1242 hidparser_get_report_id_list_internal(
1243                         entity_item_t *parser_handle,
1244                         uint_t main_item_type,
1245                         hidparser_report_id_list_t *id_lst)
1246 {
1247         /* setup wrapper function */
1248         entity_item_t *current = parser_handle;
1249         entity_attribute_t *attribute;
1250         uint_t report_id = 0;
1251         int i = 0;
1252         int rval;
1253 
1254         while (current) {
1255 
1256                 if (current->entity_item_type == R_ITEM_COLLECTION) {
1257 
1258                         rval = hidparser_get_report_id_list_internal(
1259                             current->info.child, main_item_type, id_lst);
1260                         if (rval != HIDPARSER_SUCCESS) {
1261 
1262                                 return (rval);
1263                         }
1264 
1265                 } else if (current->entity_item_type == main_item_type) {
1266                         /* Match Item Type */
1267                         attribute = current->entity_item_attributes;
1268 
1269                         while (attribute != NULL) {
1270 
1271                                 if (attribute->entity_attribute_tag ==
1272                                     R_ITEM_REPORT_ID) {
1273 
1274                                         /* Found a Report ID */
1275                                         report_id = attribute->
1276                                             entity_attribute_value[0];
1277 
1278                                         /* Report ID already in list? */
1279                                         for (i = 0;
1280                                             i < id_lst->no_of_report_ids;
1281                                             i++) {
1282                                                 if (report_id == id_lst->
1283                                                     report_id[i]) {
1284 
1285                                                         break;
1286                                                 }
1287                                         }
1288 
1289                                         if (i >= id_lst->no_of_report_ids) {
1290                                                 /*
1291                                                  * New Report ID found, put
1292                                                  * in list
1293                                                  */
1294                                                 if (i >= REPORT_ID_MAX) {
1295 
1296                                                         return
1297                                                             (HIDPARSER_FAILURE);
1298                                                 }
1299 
1300                                                 id_lst->report_id[i] =
1301                                                     report_id;
1302                                                 id_lst->no_of_report_ids++;
1303                                         }
1304                                 }
1305 
1306                                 attribute = attribute->entity_attribute_next;
1307                         }
1308                 }
1309 
1310                 current = current->entity_item_right_sibling;
1311 
1312         } /* end while current */
1313 
1314         return (HIDPARSER_SUCCESS);
1315 }
1316 
1317 
1318 /*
1319  * hidparser_print_report_descr_handle:
1320  *      Functions to print the parse tree. Currently not
1321  *      being called.
1322  */
1323 static int
1324 hidparser_print_report_descr_handle(entity_item_t *handle,
1325                         int indent_level)
1326 {
1327         entity_item_t *current = handle;
1328 
1329         while (current) {
1330                 if (current->info.child) {
1331                         hidparser_print_entity(current, indent_level);
1332                         /* do children */
1333                         (void) hidparser_print_report_descr_handle(
1334                             current->info.child, indent_level+1);
1335                 } else /* just a regular entity */ {
1336                         hidparser_print_entity(current, indent_level);
1337                 }
1338                 current = current->entity_item_right_sibling;
1339         }
1340 
1341         return (HIDPARSER_SUCCESS);
1342 }
1343 
1344 
1345 #define SPACE_PER_LEVEL 5
1346 
1347 /*
1348  * hidparser_print_entity ;
1349  * Prints the entity items recursively
1350  */
1351 static void
1352 hidparser_print_entity(entity_item_t *entity, int indent_level)
1353 {
1354         char indent_space[256];
1355         int count;
1356         entity_attribute_t *attr;
1357 
1358         indent_level *= SPACE_PER_LEVEL;
1359 
1360         for (count = 0; indent_level--; count++)
1361                 indent_space[count] = ' ';
1362 
1363         indent_space[count] = 0;
1364 
1365         attr = entity->entity_item_attributes;
1366         while (attr) {
1367                 hidparser_print_this_attribute(attr, indent_space);
1368                 attr = attr->entity_attribute_next;
1369         }
1370 
1371         USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle, "%s%s(0x%x)",
1372             indent_space, items[entity->entity_item_type],
1373             (entity->entity_item_params_leng ?
1374             entity->entity_item_params[0] & 0xFF : 0x00));
1375 }
1376 
1377 
1378 /*
1379  * hidparser_print_this_attribute:
1380  *      Prints the attribute passed in the argument
1381  */
1382 static void
1383 hidparser_print_this_attribute(entity_attribute_t *attribute,
1384                         char *ident_space)
1385 {
1386         if (ident_space == NULL) {
1387 
1388                 USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle,
1389                     "%s(0x%X)",
1390                     items[attribute->entity_attribute_tag],
1391                     hidparser_find_unsigned_val(attribute));
1392         } else {
1393                 USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle,
1394                     "%s%s(0x%X)", ident_space,
1395                     items[attribute->entity_attribute_tag],
1396                     hidparser_find_unsigned_val(attribute));
1397 
1398         }
1399 }
1400 
1401 
1402 /*
1403  * The next few functions will be used for parsing using the
1404  * grammar:
1405  *
1406  *      Start                   -> ReportDescriptor <EOF>
1407  *
1408  *      ReportDescriptor        -> ItemList
1409  *
1410  *      ItemList                -> Items MainItem ItemList
1411  *                                 | epsilon
1412  *
1413  *      MainItem                -> BeginCollection ItemList  EndCollection
1414  *                                | Input
1415  *                                | Output
1416  *                                | Feature
1417  *
1418  *      Items                   -> GlobalItem  Items
1419  *                                 | LocalItem Items
1420  *                                 | SetDelimiterOpen LocalItemList
1421  *                                      SetDelimiterClose Items
1422  *                                 | epsilon
1423  *
1424  *      LocalItemList           -> LocalItem Temp2
1425  *
1426  *      Temp2                   -> LocalItem Temp2
1427  *                                 | epsilon
1428  *
1429  *      GlobalItem              -> UsagePage
1430  *                                 | LogicalMinimum
1431  *                                 | LogicalMaximum
1432  *                                 | PhysicalMinimum
1433  *                                 | PhysicalMaximum
1434  *                                 | Unit
1435  *                                 | Exponent
1436  *                                 | ReportSize
1437  *                                 | ReportCount
1438  *                                 | ReportID
1439  *
1440  *      LocalItem               -> Usage
1441  *                                 | UsageMinimum
1442  *                                 | UsageMaximum
1443  *                                 | DesignatorIndex
1444  *                                 | DesignatorMinimum
1445  *                                 | StringIndex
1446  *                                 | StringMinimum
1447  *                                 | StringMaximum
1448  *
1449  */
1450 
1451 
1452 /*
1453  * hidparser_lookup_first:
1454  *      Looks up if token belongs to the FIRST of the function tag
1455  *      that is passed through the first argument
1456  */
1457 static int
1458 hidparser_lookup_first(int func_index,
1459                         int token)
1460 {
1461         int     *itemp;
1462 
1463         itemp = hid_first_list[func_index];
1464         while (*itemp != 0) {
1465                 /* get the next terminal on the list */
1466                 if (*itemp == token) {
1467 
1468                         return (HIDPARSER_SUCCESS);
1469                 }
1470                 itemp++;
1471         }
1472 
1473         /* token is not on the FIRST list */
1474 
1475         return (HIDPARSER_FAILURE);
1476 }
1477 
1478 
1479 /*
1480  * hidparser_main:
1481  *      Function called from hidparser_parse_report_descriptor()
1482  *      to parse the Report Descriptor
1483  */
1484 static int
1485 hidparser_main(unsigned char *descriptor,
1486                         size_t size,
1487                         entity_item_t **item_ptr)
1488 {
1489         hidparser_tok_t *scan_ifp;
1490         int retval;
1491 
1492         scan_ifp = kmem_zalloc(sizeof (hidparser_tok_t), KM_SLEEP);
1493         scan_ifp->hidparser_tok_text =
1494             kmem_zalloc(HIDPARSER_TEXT_LENGTH, KM_SLEEP);
1495         scan_ifp->hidparser_tok_max_bsize = size;
1496         scan_ifp->hidparser_tok_entity_descriptor = descriptor;
1497 
1498         *item_ptr = NULL;
1499         retval =  hidparser_ReportDescriptorDash(item_ptr, scan_ifp);
1500 
1501         /*
1502          * Free the Local & Global item list
1503          * It maybe the case that no tree has been built
1504          * up but there have been allocation in the attribute
1505          * & control lists
1506          */
1507         if (scan_ifp->hidparser_tok_gitem_head) {
1508                 hidparser_free_attribute_list(
1509                     scan_ifp->hidparser_tok_gitem_head);
1510         }
1511 
1512         if (scan_ifp->hidparser_tok_litem_head) {
1513                 hidparser_free_attribute_list(
1514                     scan_ifp->hidparser_tok_litem_head);
1515         }
1516         kmem_free(scan_ifp->hidparser_tok_text, HIDPARSER_TEXT_LENGTH);
1517         kmem_free(scan_ifp, sizeof (hidparser_tok_t));
1518 
1519         return (retval);
1520 }
1521 
1522 
1523 /*
1524  * hidparser_ReportDescriptorDash:
1525  *      Synthetic start symbol, implements
1526  *      hidparser_ReportDescriptor <EOF>
1527  */
1528 static int
1529 hidparser_ReportDescriptorDash(entity_item_t ** item_ptr,
1530                         hidparser_tok_t *scan_ifp)
1531 {
1532 
1533         if ((hidparser_ReportDescriptor(item_ptr, scan_ifp) ==
1534             HIDPARSER_SUCCESS) && (scan_ifp->hidparser_tok_token == 0)) {
1535 
1536                 return (HIDPARSER_SUCCESS);
1537         }
1538 
1539         /*
1540          * In case of failure, free the kernel memory
1541          * allocated for partial building of the tree,
1542          * if any
1543          */
1544         if (*item_ptr != NULL) {
1545                 (void) hidparser_free_report_descr_handle(*item_ptr);
1546         }
1547 
1548         *item_ptr = NULL;
1549 
1550         return (HIDPARSER_FAILURE);
1551 }
1552 
1553 
1554 /*
1555  * hidparser_ReportDescriptor:
1556  *      Implements the Rule:
1557  *      ReportDescriptor -> ItemList
1558  */
1559 static int
1560 hidparser_ReportDescriptor(entity_item_t ** item_ptr,
1561                         hidparser_tok_t *scan_ifp)
1562 {
1563         hidparser_scan(scan_ifp);
1564 
1565         /*
1566          * We do not search for the token in FIRST(ReportDescriptor)
1567          * since -
1568          *
1569          * FIRST(ReportDescriptor) == FIRST(ItemList)
1570          * ReportDescriptor ----> ItemList
1571          */
1572         if (hidparser_ItemList(item_ptr, scan_ifp) == HIDPARSER_SUCCESS) {
1573 
1574                 return (HIDPARSER_SUCCESS);
1575         }
1576 
1577         return (HIDPARSER_FAILURE);
1578 }
1579 
1580 
1581 /*
1582  * hidparser_ItemList:
1583  *      Implements the Rule:
1584  *      ItemList -> Items MainItem ItemList | epsilon
1585  *
1586  *      This function constructs the tree on which depends the "hidparser"
1587  *      consumer functions. Basically the structure of the tree is
1588  *
1589  *      C--[RS]->EC--[RS]->C--[RS]->EC..(and so on)
1590  *      |
1591  *    [CH] <== This relationship is true for other "C's"
1592  *      |      also.
1593  *      v
1594  *     C/-------------/I/O/F <== [ Any of these ]
1595  *     |              ------
1596  *     |                |
1597  *     v                v
1598  *    [CH      | RS]  [ RS ]
1599  *     C/I/O/F | EC    I/O/F
1600  *     |
1601  *     |
1602  *    and so on...
1603  *
1604  *      where    C = Collection
1605  *              EC = EndCollection
1606  *               I = Input
1607  *               O = Output
1608  *               F = Feature "Main" Items.
1609  *
1610  *      and the relationships are  [RS] for right sibling and [CH] for
1611  *      child. [CH | RS ] stands for "child or right sibling" with the
1612  *      possible values below it.
1613  */
1614 static int
1615 hidparser_ItemList(entity_item_t ** item_ptr, hidparser_tok_t *scan_ifp)
1616 {
1617         entity_item_t   *curr_ei, *cache_ei, *prev_ei, *tmp_ei;
1618         boolean_t       root_coll = B_FALSE;
1619 
1620         curr_ei = cache_ei = prev_ei = tmp_ei = NULL;
1621 
1622         while (scan_ifp->hidparser_tok_token != 0) {
1623                 if (hidparser_Items(scan_ifp) == HIDPARSER_FAILURE) {
1624 
1625                         return (HIDPARSER_FAILURE);
1626                 }
1627 
1628                 if (hidparser_MainItem(&curr_ei, scan_ifp) ==
1629                     HIDPARSER_FAILURE) {
1630                         USB_DPRINTF_L2(PRINT_MASK_ALL,
1631                             hparser_log_handle,
1632                             "Invalid MAIN item 0x%x in input stream",
1633                             scan_ifp->hidparser_tok_token);
1634 
1635                         return (HIDPARSER_FAILURE);
1636                 }
1637                 if (curr_ei->entity_item_type == R_ITEM_COLLECTION) {
1638                         if (root_coll == B_FALSE) {
1639                                 *item_ptr = curr_ei;
1640                                 root_coll = B_TRUE;
1641                         }
1642                         curr_ei->prev_coll = cache_ei;
1643                         cache_ei = curr_ei;
1644 
1645                                 USB_DPRINTF_L3(PRINT_MASK_ALL,
1646                                     hparser_log_handle,
1647                                     "Start Collection:cache_ei = 0x%p,"
1648                                     " curr_ei = 0x%p",
1649                                     (void *)cache_ei, (void *)curr_ei);
1650 
1651                         if (prev_ei == NULL) {
1652                                 prev_ei = curr_ei;
1653 
1654                                 continue;
1655                         }
1656                         if (prev_ei->entity_item_type ==
1657                             R_ITEM_COLLECTION) {
1658                                 prev_ei->info.child = curr_ei;
1659                         } else {
1660                                 prev_ei->entity_item_right_sibling =
1661                                     curr_ei;
1662                         }
1663                 } else if (curr_ei->entity_item_type ==
1664                     R_ITEM_END_COLLECTION) {
1665                         tmp_ei = cache_ei->prev_coll;
1666                         cache_ei->entity_item_right_sibling = curr_ei;
1667                         USB_DPRINTF_L3(PRINT_MASK_ALL,
1668                             hparser_log_handle,
1669                             "End Collection: cache_ei = 0x%p, "
1670                             "curr_ei = 0x%p",
1671                             (void *)cache_ei, (void *)curr_ei);
1672                         if (tmp_ei != NULL) {
1673                                 /*
1674                                  * As will be the case for final end
1675                                  * collection.
1676                                  */
1677                                 cache_ei = tmp_ei;
1678                         }
1679                         tmp_ei = NULL;
1680                 } else {
1681                         if (prev_ei == NULL) {
1682                                 USB_DPRINTF_L2(PRINT_MASK_ALL,
1683                                     hparser_log_handle,
1684                                     "Invalid First MAIN item 0x%x",
1685                                     scan_ifp->hidparser_tok_token);
1686 
1687                                 return (HIDPARSER_FAILURE);
1688                         }
1689                         if (prev_ei->entity_item_type ==
1690                             R_ITEM_COLLECTION) {
1691                                 USB_DPRINTF_L3(PRINT_MASK_ALL,
1692                                     hparser_log_handle,
1693                                     "Main Item: token = 0x%x, "
1694                                     "curr_ei = 0x%p "
1695                                     "will be the child of prev_ei "
1696                                     "= 0x%p, "
1697                                     "cache_ei being 0x%p",
1698                                     curr_ei->entity_item_type,
1699                                     (void *)curr_ei, (void *)prev_ei,
1700                                     (void *)cache_ei);
1701                                 prev_ei->info.child = curr_ei;
1702                         } else {
1703                                 USB_DPRINTF_L3(PRINT_MASK_ALL,
1704                                     hparser_log_handle,
1705                                     "Main Item: token = 0x%x, "
1706                                     "curr_ei = 0x%p "
1707                                     "will be the right sibling of "
1708                                     "prev_ei = 0x%p, "
1709                                     "cache_ei being 0x%p",
1710                                     curr_ei->entity_item_type,
1711                                     (void *)curr_ei, (void *)prev_ei,
1712                                     (void *)cache_ei);
1713                                 prev_ei->entity_item_right_sibling =
1714                                     curr_ei;
1715                         }
1716                 }
1717                 prev_ei = curr_ei;
1718         }
1719         if (*item_ptr != cache_ei) {
1720                 /* Something wrong happened */
1721                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
1722                     "Failed to parse report descriptor");
1723 
1724                 return (HIDPARSER_FAILURE);
1725         }
1726         (void) hidparser_print_report_descr_handle(cache_ei, 0);
1727 
1728         return (HIDPARSER_SUCCESS);
1729 }
1730 
1731 
1732 /*
1733  * hidparser_MainItem:
1734  *      Implements the Rule:
1735  *      MainItem ->  BeginCollection ItemList  EndCollection
1736  *                      | Input
1737  *                      | Output
1738  *                      | Feature
1739  */
1740 static int
1741 hidparser_MainItem(entity_item_t ** item_ptr,
1742                         hidparser_tok_t *scan_ifp)
1743 {
1744         switch (scan_ifp->hidparser_tok_token) {
1745                 case R_ITEM_INPUT:
1746                         /* FALLTHRU */
1747                 case R_ITEM_OUTPUT:
1748                         /* FALLTHRU */
1749                 case R_ITEM_FEATURE:
1750                 case R_ITEM_COLLECTION:
1751                 case R_ITEM_END_COLLECTION:
1752                         *item_ptr = hidparser_allocate_entity(scan_ifp);
1753                         USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle,
1754                             "hidparser_MainItem:index = 0x%lx token = 0x%x",
1755                             scan_ifp->hidparser_tok_index -
1756                             (*item_ptr)->entity_item_params_leng - 1,
1757                             scan_ifp->hidparser_tok_token);
1758                         hidparser_scan(scan_ifp);
1759                         hidparser_global_err_check(*item_ptr);
1760                         hidparser_local_err_check(*item_ptr);
1761                         hidparser_mainitem_err_check(*item_ptr);
1762 
1763                         return (HIDPARSER_SUCCESS);
1764 
1765                 default:
1766                         break;
1767         }
1768 
1769         *item_ptr = NULL;
1770 
1771         return (HIDPARSER_FAILURE);
1772 }
1773 
1774 
1775 /*
1776  * hidparser_Items:
1777  *      Implements the Rule:
1778  *      Items ->     GlobalItem  Items
1779  *                      | LocalItem Items
1780  *                      | SetDelimiterOpen LocalItemList
1781  *                              SetDelimiterClose Items
1782  *                      | epsilon
1783  */
1784 static int
1785 hidparser_Items(hidparser_tok_t *scan_ifp)
1786 {
1787         boolean_t delim_pre = B_FALSE;
1788 
1789         int     token = scan_ifp->hidparser_tok_token;
1790 
1791         while (hidparser_lookup_first(HIDPARSER_ITEMS, token) ==
1792             HIDPARSER_SUCCESS) {
1793                 if (token == R_ITEM_SET_DELIMITER) {
1794                         if (delim_pre == B_FALSE) {
1795                                 if (scan_ifp->hidparser_tok_text[0] != 1) {
1796                                         hidparser_error_delim(NULL,
1797                                             HIDPARSER_DELIM_ERR1);
1798                                 } else {
1799                                         delim_pre = B_TRUE;
1800                                 }
1801                         } else {
1802                                 if (scan_ifp->hidparser_tok_text[0] !=
1803                                     0) {
1804                                         hidparser_error_delim(NULL,
1805                                             HIDPARSER_DELIM_ERR2);
1806                                 } else {
1807                                         delim_pre = B_FALSE;
1808                                 }
1809                         }
1810                         (void) hidparser_LocalItem(scan_ifp);
1811                         token = scan_ifp->hidparser_tok_token;
1812                 } else if (hidparser_GlobalItem(scan_ifp) ==
1813                     HIDPARSER_SUCCESS) {
1814                         token = scan_ifp->hidparser_tok_token;
1815                 } else if (hidparser_LocalItem(scan_ifp) == HIDPARSER_SUCCESS) {
1816                         token = scan_ifp->hidparser_tok_token;
1817                 }
1818         }
1819 
1820         return (HIDPARSER_SUCCESS);     /* epsilon */
1821 }
1822 
1823 
1824 /*
1825  * hidparser_GlobalItem:
1826  *      Implements the Rule:
1827  *      GlobalItem ->        UsagePage
1828  *                      | LogicalMinimum
1829  *                      | LocgicalMaximum
1830  *                      | PhysicalMinimum
1831  *                      | PhysicalMaximum
1832  *                      | Unit
1833  *                      | Exponent
1834  *                      | ReportSize
1835  *                      | ReportCount
1836  *                      | ReportID
1837  */
1838 static int
1839 hidparser_GlobalItem(hidparser_tok_t    *scan_ifp)
1840 {
1841 
1842         int i;
1843         entity_attribute_stack_t        *elem;
1844 
1845         switch (scan_ifp->hidparser_tok_token) {
1846                 case R_ITEM_USAGE_PAGE:
1847                         /* Error check */
1848                         for (i = 0; i < scan_ifp->hidparser_tok_leng; i++) {
1849                                 /* Undefined data value: 0 */
1850                                 if (scan_ifp->hidparser_tok_text[i] == 0) {
1851                                         hidparser_report_err(
1852                                             HIDPARSER_ERR_WARN,
1853                                             HIDPARSER_ERR_STANDARD,
1854                                             R_ITEM_USAGE_PAGE,
1855                                             0,
1856                                             "Data field should be non-Zero");
1857                                 }
1858                                 /* Reserved values 0x0A-0xFE */
1859                                 else if ((scan_ifp->hidparser_tok_text[i] >=
1860                                     0x0a) &&
1861                                     (scan_ifp->hidparser_tok_text[i] <=
1862                                     0xFE)) {
1863                                         hidparser_report_err(
1864                                             HIDPARSER_ERR_WARN,
1865                                             HIDPARSER_ERR_STANDARD,
1866                                             R_ITEM_USAGE_PAGE,
1867                                             1,
1868                                             "Data field should not use "
1869                                             "reserved values");
1870                                 }
1871                         }
1872                         break;
1873                 case R_ITEM_UNIT:
1874                         /* FALLTHRU */
1875                 case R_ITEM_EXPONENT:
1876                         /*
1877                          * Error check:
1878                          * Nibble 7 should be zero
1879                          */
1880                         if (scan_ifp->hidparser_tok_leng == 4) {
1881                                 if ((scan_ifp->hidparser_tok_text[3] &
1882                                     0xf0) != 0) {
1883                                         hidparser_report_err(
1884                                             HIDPARSER_ERR_WARN,
1885                                             HIDPARSER_ERR_STANDARD,
1886                                             scan_ifp->hidparser_tok_token,
1887                                             0,
1888                                             "Data field reserved bits should "
1889                                             "be Zero");
1890                                 }
1891                         }
1892                         break;
1893                 case R_ITEM_REPORT_COUNT:
1894                         /*
1895                          * Error Check:
1896                          * Report Count should be nonzero
1897                          */
1898                         for (i = 0; i < scan_ifp->hidparser_tok_leng; i++) {
1899                                 if (scan_ifp->hidparser_tok_text[i])
1900                                         break;
1901                         }
1902                         if (i == scan_ifp->hidparser_tok_leng) {
1903                                 hidparser_report_err(
1904                                     HIDPARSER_ERR_ERROR,
1905                                     HIDPARSER_ERR_STANDARD,
1906                                     R_ITEM_REPORT_COUNT,
1907                                     0,
1908                                     "Report Count = 0");
1909                         }
1910                         break;
1911                 case R_ITEM_REPORT_ID:
1912                         /*
1913                          * Error check:
1914                          * Report Id should be nonzero & <= 255
1915                          */
1916                         if (scan_ifp->hidparser_tok_leng != 1)       {
1917                                 hidparser_report_err(
1918                                     HIDPARSER_ERR_ERROR,
1919                                     HIDPARSER_ERR_STANDARD,
1920                                     R_ITEM_REPORT_ID,
1921                                     1,
1922                                     "Must be contained in a byte");
1923                         }
1924                         if (!scan_ifp->hidparser_tok_text[0]) {
1925                                 hidparser_report_err(
1926                                     HIDPARSER_ERR_ERROR,
1927                                     HIDPARSER_ERR_STANDARD,
1928                                     R_ITEM_REPORT_ID,
1929                                     0,
1930                                     "Report Id must be non-zero");
1931                         }
1932                         break;
1933                 case R_ITEM_LOGICAL_MINIMUM:
1934                         break;
1935                 case R_ITEM_LOGICAL_MAXIMUM:
1936                         break;
1937                 case R_ITEM_PHYSICAL_MINIMUM:
1938                         break;
1939                 case R_ITEM_PHYSICAL_MAXIMUM:
1940                         break;
1941                 case R_ITEM_REPORT_SIZE:
1942                         break;
1943                 case R_ITEM_PUSH:
1944                         if (scan_ifp->hidparser_tok_leng != 0)       {
1945                                 hidparser_report_err(
1946                                     HIDPARSER_ERR_ERROR,
1947                                     HIDPARSER_ERR_STANDARD,
1948                                     scan_ifp->hidparser_tok_token,
1949                                     0,
1950                                     "Data Field size should be zero");
1951                         } else {
1952                                 elem = (entity_attribute_stack_t *)kmem_zalloc(
1953                                     sizeof (entity_attribute_stack_t),
1954                                     KM_SLEEP);
1955 
1956                                 elem->list = hidparser_cp_attribute_list(
1957                                     scan_ifp->hidparser_tok_gitem_head);
1958                                 if (scan_ifp->hidparser_head) {
1959                                         elem->next = scan_ifp->hidparser_head;
1960                                 }
1961                                 scan_ifp->hidparser_head = elem;
1962                         }
1963 
1964                         break;
1965                 case R_ITEM_POP:
1966                         if (scan_ifp->hidparser_tok_leng != 0)       {
1967                                 hidparser_report_err(
1968                                     HIDPARSER_ERR_ERROR,
1969                                     HIDPARSER_ERR_STANDARD,
1970                                     scan_ifp->hidparser_tok_token,
1971                                     0,
1972                                     "Data Field size should be zero");
1973                         } else {
1974                                 /* Free the current global list */
1975                                 hidparser_free_attribute_list(scan_ifp->
1976                                     hidparser_tok_gitem_head);
1977                                 scan_ifp->hidparser_tok_gitem_head =
1978                                     scan_ifp->hidparser_head->list;
1979                                 scan_ifp->hidparser_head->list = NULL;
1980                                 elem = scan_ifp->hidparser_head;
1981                                 scan_ifp->hidparser_head = elem->next;
1982                                 kmem_free(elem,
1983                                     sizeof (entity_attribute_stack_t));
1984                         }
1985 
1986                         break;
1987                 default:
1988 
1989                         return (HIDPARSER_FAILURE);
1990 
1991                         /*NOTREACHED*/
1992         }
1993 
1994         hidparser_add_attribute(scan_ifp);
1995         USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle,
1996             "hidparser_GlobalItem:index = 0x%lx token = 0x%x",
1997             scan_ifp->hidparser_tok_index -
1998             scan_ifp->hidparser_tok_leng - 1,
1999             scan_ifp->hidparser_tok_token);
2000         hidparser_scan(scan_ifp);
2001 
2002         return (HIDPARSER_SUCCESS);
2003 }
2004 
2005 
2006 /*
2007  * hidparser_LocalItem:
2008  *      Implements the Rule:
2009  *      LocalItem -> Usage
2010  *                      | UsageMinimum
2011  *                      | UsageMaximum
2012  *                      | DesignatorIndex
2013  *                      | DesignatorMinimum
2014  *                      | StringIndex
2015  *                      | StringMinimum
2016  *                      | StringMaximum
2017  */
2018 static int
2019 hidparser_LocalItem(hidparser_tok_t     *scan_ifp)
2020 {
2021         int i;
2022 
2023         switch (scan_ifp->hidparser_tok_token) {
2024                 case R_ITEM_USAGE:
2025                         /*
2026                          * Error Check:
2027                          * Data Field should be nonzero
2028                          */
2029                         for (i = 0; i < scan_ifp->hidparser_tok_leng; i++) {
2030                                 if (scan_ifp->hidparser_tok_text[i])
2031                                         break;
2032                         }
2033                         if (i == scan_ifp->hidparser_tok_leng) {
2034                                 hidparser_report_err(
2035                                     HIDPARSER_ERR_WARN,
2036                                     HIDPARSER_ERR_STANDARD,
2037                                     R_ITEM_USAGE,
2038                                     0,
2039                                     "Data Field should be non-zero");
2040                         }
2041                         /* FALLTHRU */
2042                 case R_ITEM_USAGE_MIN:
2043                         /* FALLTHRU */
2044                 case R_ITEM_USAGE_MAX:
2045                         /* FALLTHRU */
2046                 case R_ITEM_DESIGNATOR_INDEX:
2047                         /* FALLTHRU */
2048                 case R_ITEM_DESIGNATOR_MIN:
2049                         /* FALLTHRU */
2050                 case R_ITEM_STRING_INDEX:
2051                         /* FALLTHRU */
2052                 case R_ITEM_STRING_MIN:
2053                         /* FALLTHRU */
2054                 case R_ITEM_STRING_MAX:
2055                         /* FALLTHRU */
2056                 case R_ITEM_SET_DELIMITER:
2057                         hidparser_add_attribute(scan_ifp);
2058                         USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle,
2059                             "hidparser_LocalItem:index = 0x%lx token = 0x%x",
2060                             scan_ifp->hidparser_tok_index -
2061                             scan_ifp->hidparser_tok_leng - 1,
2062                             scan_ifp->hidparser_tok_token);
2063                         hidparser_scan(scan_ifp);
2064 
2065                         return (HIDPARSER_SUCCESS);
2066 
2067                         /*NOTREACHED*/
2068                 default:
2069                         break;
2070         }
2071 
2072         return (HIDPARSER_FAILURE);
2073 }
2074 
2075 
2076 /*
2077  * hidparser_allocate_entity:
2078  *      Allocate Item of type 'type', length 'leng' and
2079  *      params 'text'. Fill in the attributes allocated
2080  *      so far from both the local and global item lists.
2081  *      Make the child and sibling of the item NULL.
2082  */
2083 static entity_item_t *
2084 hidparser_allocate_entity(hidparser_tok_t       *scan_ifp)
2085 {
2086         entity_item_t *entity;
2087         entity_attribute_t *aend;
2088 
2089         int     entity_type = scan_ifp->hidparser_tok_token;
2090         unsigned char   *text = scan_ifp->hidparser_tok_text;
2091         int     len = scan_ifp->hidparser_tok_leng;
2092 
2093         entity = kmem_zalloc(sizeof (entity_item_t), KM_SLEEP);
2094         entity->entity_item_type = entity_type;
2095         entity->entity_item_params_leng = len;
2096 
2097         if (len != 0) {
2098                 entity->entity_item_params = kmem_zalloc(len, KM_SLEEP);
2099                 (void) bcopy(text, entity->entity_item_params, len);
2100         }
2101 
2102         /*
2103          * Copy attributes from entity attribute state table if not
2104          * end collection.
2105          */
2106         if (entity_type != R_ITEM_END_COLLECTION) {
2107                 entity->entity_item_attributes = hidparser_cp_attribute_list(
2108                     scan_ifp->hidparser_tok_gitem_head);
2109 
2110                 /*
2111                  * append the control attributes, then clear out the control
2112                  * attribute state table list
2113                  */
2114                 if (entity->entity_item_attributes) {
2115                         aend = hidparser_find_attribute_end(
2116                             entity->entity_item_attributes);
2117                         aend->entity_attribute_next =
2118                             scan_ifp->hidparser_tok_litem_head;
2119                         scan_ifp->hidparser_tok_litem_head = NULL;
2120                 } else {
2121                         entity->entity_item_attributes =
2122                             scan_ifp->hidparser_tok_litem_head;
2123                         scan_ifp->hidparser_tok_litem_head = NULL;
2124                 }
2125         }
2126 
2127         entity->info.child = entity->entity_item_right_sibling = 0;
2128 
2129         return (entity);
2130 }
2131 
2132 
2133 /*
2134  * hidparser_add_attribute:
2135  *      Add an attribute to the global or local item list
2136  *      If the last 4th bit from right is 1, add to the local item list
2137  *      Else add to the global item list
2138  */
2139 static void
2140 hidparser_add_attribute(hidparser_tok_t *scan_ifp)
2141 {
2142         entity_attribute_t *newattrib, **previous, *elem;
2143         int     entity = scan_ifp->hidparser_tok_token;
2144         unsigned char   *text = scan_ifp->hidparser_tok_text;
2145         int     len = scan_ifp->hidparser_tok_leng;
2146 
2147         if (len == 0) {
2148                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
2149                     "hidparser_add_attribute: len = 0 for item = 0x%x",
2150                     entity);
2151 
2152                 return;
2153         }
2154 
2155         if (entity & HIDPARSER_ISLOCAL_MASK) {
2156                 previous = &scan_ifp->hidparser_tok_litem_head;
2157         } else {
2158                 previous = &scan_ifp->hidparser_tok_gitem_head;
2159         }
2160 
2161         elem = *previous;
2162 
2163         /*
2164          * remove attribute if it is already on list, except
2165          * for control attributes(local items), as we could have
2166          * multiple usages...
2167          * unless we want to hassle with checking for unique parameters.
2168          */
2169         while (elem) {
2170                 if (elem->entity_attribute_tag == entity &&
2171                     !(entity & HIDPARSER_ISLOCAL_MASK)) {
2172                         *previous = elem->entity_attribute_next;
2173                         kmem_free(elem->entity_attribute_value,
2174                             elem->entity_attribute_length);
2175                         kmem_free(elem, sizeof (entity_attribute_t));
2176                         elem = *previous;
2177                 } else {
2178                         previous = &elem->entity_attribute_next;
2179                         elem = elem->entity_attribute_next;
2180                 }
2181         }
2182 
2183         /* create new attribute for this entry */
2184         newattrib = hidparser_alloc_attrib_list(1);
2185         newattrib->entity_attribute_tag = entity;
2186         newattrib->entity_attribute_value = kmem_zalloc(len, KM_SLEEP);
2187         (void) bcopy(text, newattrib->entity_attribute_value, len);
2188         newattrib->entity_attribute_length = len;
2189 
2190         /* attach to end of list */
2191         *previous = newattrib;
2192 }
2193 
2194 
2195 /*
2196  * hidparser_alloc_attrib_list:
2197  *      Allocate space for n attributes , create a linked list and
2198  *      return the head
2199  */
2200 static entity_attribute_t *
2201 hidparser_alloc_attrib_list(int count)
2202 {
2203         entity_attribute_t *head, *current;
2204 
2205         if (count <= 0) {
2206 
2207                 return (NULL);
2208         }
2209 
2210         head = kmem_zalloc(sizeof (entity_attribute_t), KM_SLEEP);
2211         count--;
2212         current = head;
2213         while (count--) {
2214                 current->entity_attribute_next = kmem_zalloc(
2215                     sizeof (entity_attribute_t), KM_SLEEP);
2216                 current = current->entity_attribute_next;
2217         }
2218         current->entity_attribute_next = NULL;
2219 
2220         return (head);
2221 }
2222 
2223 
2224 /*
2225  * hidparser_cp_attribute_list:
2226  *      Copies the Global item list pointed to by head
2227  *      We create a clone of the global item list here
2228  *      because we want to retain the Global items to
2229  *      the next Main Item.
2230  */
2231 static entity_attribute_t *
2232 hidparser_cp_attribute_list(entity_attribute_t *head)
2233 {
2234         entity_attribute_t *return_value, *current_src, *current_dst;
2235 
2236         if (!head) {
2237 
2238                 return (NULL);
2239         }
2240 
2241         current_src = head;
2242         current_dst = return_value = hidparser_alloc_attrib_list(1);
2243 
2244         while (current_src) {
2245                 current_dst->entity_attribute_tag =
2246                     current_src->entity_attribute_tag;
2247                 current_dst->entity_attribute_length =
2248                     current_src->entity_attribute_length;
2249                 current_dst->entity_attribute_value = kmem_zalloc(
2250                     current_dst->entity_attribute_length, KM_SLEEP);
2251                 (void) bcopy(current_src->entity_attribute_value,
2252                     current_dst->entity_attribute_value,
2253                     current_src->entity_attribute_length);
2254                 if (current_src->entity_attribute_next) {
2255                         current_dst->entity_attribute_next =
2256                             hidparser_alloc_attrib_list(1);
2257                 } else {
2258                         current_dst->entity_attribute_next = NULL;
2259                 }
2260                 current_src = current_src->entity_attribute_next;
2261                 current_dst = current_dst->entity_attribute_next;
2262         }
2263 
2264         return (return_value);
2265 }
2266 
2267 
2268 /*
2269  * hidparser_find_attribute_end:
2270  *      Find the last item in the attribute list pointed to by head
2271  */
2272 static entity_attribute_t *
2273 hidparser_find_attribute_end(entity_attribute_t *head)
2274 {
2275         if (head == NULL) {
2276 
2277                 return (NULL);
2278         }
2279         while (head->entity_attribute_next != NULL) {
2280                 head = head->entity_attribute_next;
2281         }
2282 
2283         return (head);
2284 }
2285 
2286 
2287 /*
2288  * hidparser_free_report_descr_handle:
2289  *      Free the parse tree pointed to by handle
2290  */
2291 static void
2292 hidparser_free_report_descr_handle(entity_item_t *handle)
2293 {
2294         entity_item_t *next, *current, *child;
2295 
2296         current = handle;
2297 
2298         while (current) {
2299                 child = current->info.child;
2300                 next = current->entity_item_right_sibling;
2301                 if (current->entity_item_type == R_ITEM_COLLECTION) {
2302                         if (current->entity_item_params != NULL)
2303                                 kmem_free(current->entity_item_params,
2304                                     current->entity_item_params_leng);
2305                         if (current->entity_item_attributes != NULL)
2306                                 hidparser_free_attribute_list(
2307                                     current->entity_item_attributes);
2308                         USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle,
2309                             "FREE 1: %s",
2310                             items[current->entity_item_type]);
2311                         kmem_free(current, sizeof (entity_item_t));
2312                         (void) hidparser_free_report_descr_handle(child);
2313                 } else {
2314                         if (current->entity_item_params != NULL) {
2315                                 kmem_free(current->entity_item_params,
2316                                     current->entity_item_params_leng);
2317                         }
2318                         if (current->entity_item_attributes != NULL) {
2319                                 hidparser_free_attribute_list(
2320                                     current->entity_item_attributes);
2321                         }
2322                         USB_DPRINTF_L4(PRINT_MASK_ALL,
2323                             hparser_log_handle, "FREE 2: %s",
2324                             items[current->entity_item_type]);
2325                         kmem_free(current, sizeof (entity_item_t));
2326                 }
2327                 current = next;
2328         }
2329 
2330 }
2331 
2332 
2333 /*
2334  * hidparser_free_attribute_list:
2335  *      Free the attribute list pointed to by head
2336  */
2337 static void
2338 hidparser_free_attribute_list(entity_attribute_t *head)
2339 {
2340         entity_attribute_t *next, *current;
2341 
2342         current = head;
2343 
2344         while (current) {
2345                 next = current->entity_attribute_next;
2346                 USB_DPRINTF_L4(PRINT_MASK_ALL,
2347                     hparser_log_handle, "FREE: %s value_length = %d",
2348                     items[current->entity_attribute_tag],
2349                     current->entity_attribute_length);
2350 
2351                 if (current->entity_attribute_value != NULL) {
2352                         USB_DPRINTF_L4(PRINT_MASK_ALL,
2353                             hparser_log_handle,
2354                             "\tvalue = 0x%x",
2355                             current->entity_attribute_value[0]);
2356                         kmem_free(current->entity_attribute_value,
2357                             current->entity_attribute_length);
2358                 }
2359 
2360                 kmem_free(current, sizeof (entity_attribute_t));
2361                 current = next;
2362         }
2363 }
2364 
2365 
2366 /*
2367  * hidparser_initialize_items:
2368  *      Initialize items array before start scanning and parsing.
2369  *      This array of strings are used for printing purpose.
2370  */
2371 static void
2372 hidparser_initialize_items(void)
2373 {
2374         items[R_ITEM_USAGE] = "Usage";
2375         items[R_ITEM_USAGE_MIN] = "Usage Minimum";
2376         items[R_ITEM_USAGE_MAX] = "Usage Maximum";
2377         items[R_ITEM_DESIGNATOR_INDEX] = "Designator Index";
2378         items[R_ITEM_DESIGNATOR_MIN] = "Designator Minimum";
2379         items[R_ITEM_DESIGNATOR_MAX] = "Designator Maximum";
2380         items[R_ITEM_STRING_INDEX] = "String Index";
2381         items[R_ITEM_STRING_MIN] = "String Minimum";
2382         items[R_ITEM_STRING_MAX] = "String Maximum";
2383 
2384 
2385         items[R_ITEM_USAGE_PAGE] = "Usage Page";
2386         items[R_ITEM_LOGICAL_MINIMUM] = "Logical Minimum";
2387         items[R_ITEM_LOGICAL_MAXIMUM] = "Logical Maximum";
2388         items[R_ITEM_PHYSICAL_MINIMUM] = "Physical Minimum";
2389         items[R_ITEM_PHYSICAL_MAXIMUM] = "Physical Maximum";
2390         items[R_ITEM_EXPONENT] = "Exponent";
2391         items[R_ITEM_UNIT] = "Unit";
2392         items[R_ITEM_REPORT_SIZE] = "Report Size";
2393         items[R_ITEM_REPORT_ID] = "Report Id";
2394         items[R_ITEM_REPORT_COUNT] = "Report Count";
2395         items[R_ITEM_PUSH] = "Push";
2396         items[R_ITEM_POP] = "Pop";
2397 
2398 
2399         items[R_ITEM_INPUT] = "Input";
2400         items[R_ITEM_OUTPUT] = "Output";
2401         items[R_ITEM_COLLECTION] = "Collection";
2402         items[R_ITEM_FEATURE] = "Feature";
2403         items[R_ITEM_END_COLLECTION] = "End Collection";
2404 
2405         items[R_ITEM_SET_DELIMITER] = "Delimiter";
2406 }
2407 
2408 
2409 /*
2410  * hidparser_scan:
2411  *      This function scans the input entity descriptor, sees the data
2412  *      length, returns the next token, data bytes and length in the
2413  *      scan_ifp structure.
2414  */
2415 static void
2416 hidparser_scan(hidparser_tok_t  *scan_ifp)
2417 {
2418         int count;
2419         int ch;
2420         int parsed_length;
2421         unsigned char *parsed_text;
2422         unsigned char *entity_descriptor;
2423         char err_str[32];
2424         size_t  entity_buffer_size, index;
2425 
2426         index = scan_ifp->hidparser_tok_index;
2427         entity_buffer_size = scan_ifp->hidparser_tok_max_bsize;
2428         parsed_length = 0;
2429         parsed_text = scan_ifp->hidparser_tok_text;
2430         entity_descriptor = scan_ifp->hidparser_tok_entity_descriptor;
2431 
2432 next_item:
2433         if (index <= entity_buffer_size -1) {
2434 
2435                 ch = 0xFF & entity_descriptor[index];
2436                 USB_DPRINTF_L4(PRINT_MASK_ALL,
2437                     hparser_log_handle, "scanner: index  = 0x%lx ch = 0x%x",
2438                     index, ch);
2439 
2440                 index++;
2441 
2442                 /*
2443                  * Error checking:
2444                  * Unrecognized items should be passed over
2445                  * by the parser.
2446                  * Section 5.4
2447                  */
2448                 if (!(hidparser_isvalid_item(ch))) {
2449                         (void) sprintf(err_str, "%s: 0x%2x",
2450                             "Unknown or reserved item", ch);
2451                         hidparser_report_err(HIDPARSER_ERR_ERROR,
2452                             HIDPARSER_ERR_STANDARD, 0, 0x3F, err_str);
2453                         goto next_item;
2454                 }
2455 
2456                 if (ch == EXTENDED_ITEM) {
2457                         parsed_length = entity_descriptor[index++];
2458                         ch = entity_descriptor[index++];
2459                         hidparser_report_err(HIDPARSER_ERR_WARN,
2460                             HIDPARSER_ERR_STANDARD,
2461                             0,
2462                             0x3E,
2463                             "Long item defined");
2464                 } else {
2465                         parsed_length = ch & 0x03;
2466                         USB_DPRINTF_L4(PRINT_MASK_ALL,
2467                             hparser_log_handle,
2468                             "scanner: parsed_length = %x", parsed_length);
2469                         /* 3 really means 4.. see p.21 HID */
2470                         if (parsed_length == 3)
2471                                 parsed_length++;
2472                 }
2473                 for (count = 0; count < parsed_length; count++) {
2474                         parsed_text[count] = entity_descriptor[index];
2475                         USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle,
2476                             "scanner: parsed_text[%d] = 0x%x,"
2477                             "index = 0x%lx",
2478                             count, parsed_text[count], index);
2479                         index++;
2480                 }
2481 
2482                 USB_DPRINTF_L4(PRINT_MASK_ALL,
2483                     hparser_log_handle, "scanner: lexical analyzer found 0x%x "
2484                     "before translation", ch);
2485 
2486                 scan_ifp->hidparser_tok_index = index;
2487                 scan_ifp->hidparser_tok_leng = parsed_length;
2488                 scan_ifp->hidparser_tok_token = ch & 0xFC;
2489                 USB_DPRINTF_L4(PRINT_MASK_ALL,
2490                     hparser_log_handle, "scanner: aindex  = 0x%lx", index);
2491         } else {
2492                 USB_DPRINTF_L4(PRINT_MASK_ALL,
2493                     hparser_log_handle, "scanner: eindex  = 0x%lx", index);
2494                 scan_ifp->hidparser_tok_leng = 0;
2495                 scan_ifp->hidparser_tok_token = 0;   /* EOF */
2496         }
2497 }
2498 
2499 
2500 /*
2501  * hidparser_report_err:
2502  *      Construct and print the error code
2503  *      Ref: Hidview error check list
2504  */
2505 static void
2506 hidparser_report_err(int err_level,
2507                         int err_type,
2508                         int tag,
2509                         int subcode,
2510                         char *msg)
2511 {
2512         unsigned int    BmParserErrorCode = 0;
2513 
2514         if (err_level) {
2515                 BmParserErrorCode |= HIDPARSER_ERR_ERROR;
2516         }
2517         if (err_type) {
2518                 BmParserErrorCode |= HIDPARSER_ERR_STANDARD;
2519         }
2520         BmParserErrorCode |= (tag << 8) & HIDPARSER_ERR_TAG_MASK;
2521         BmParserErrorCode |= subcode & HIDPARSER_ERR_SUBCODE_MASK;
2522 
2523         if (err_level) {
2524                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
2525                     "err code = 0x%4x, err str = %s",
2526                     BmParserErrorCode, msg);
2527 
2528         } else {
2529                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
2530                     "wrn code = 0x%4x, wrn str = %s",
2531                     BmParserErrorCode, msg);
2532         }
2533 }
2534 
2535 
2536 /*
2537  * hidparser_isvalid_item:
2538  *      Find if the item tag is a valid one
2539  */
2540 static int
2541 hidparser_isvalid_item(int tag)
2542 {
2543         if (tag == EXTENDED_ITEM) {
2544 
2545                 return (1);
2546         }
2547 
2548         tag &= 0xFC;
2549         if ((tag == R_ITEM_INPUT) ||
2550             (tag == R_ITEM_OUTPUT) ||
2551             (tag == R_ITEM_COLLECTION) ||
2552             (tag == R_ITEM_FEATURE) ||
2553             (tag == R_ITEM_END_COLLECTION) ||
2554             (tag == R_ITEM_USAGE_PAGE) ||
2555             (tag == R_ITEM_LOGICAL_MINIMUM) ||
2556             (tag == R_ITEM_LOGICAL_MAXIMUM) ||
2557             (tag == R_ITEM_PHYSICAL_MINIMUM) ||
2558             (tag == R_ITEM_PHYSICAL_MAXIMUM) ||
2559             (tag == R_ITEM_EXPONENT) ||
2560             (tag == R_ITEM_UNIT) ||
2561             (tag == R_ITEM_REPORT_SIZE) ||
2562             (tag == R_ITEM_REPORT_ID) ||
2563             (tag == R_ITEM_REPORT_COUNT) ||
2564             (tag == R_ITEM_PUSH) ||
2565             (tag == R_ITEM_POP) ||
2566             (tag == R_ITEM_USAGE) ||
2567             (tag == R_ITEM_USAGE_MIN) ||
2568             (tag == R_ITEM_USAGE_MAX) ||
2569             (tag == R_ITEM_DESIGNATOR_INDEX) ||
2570             (tag == R_ITEM_DESIGNATOR_MIN) ||
2571             (tag == R_ITEM_DESIGNATOR_MAX) ||
2572             (tag == R_ITEM_STRING_INDEX) ||
2573             (tag == R_ITEM_STRING_MIN) ||
2574             (tag == R_ITEM_STRING_MAX) ||
2575             (tag == R_ITEM_SET_DELIMITER)) {
2576 
2577                 return (1);
2578         } else {
2579 
2580                 return (0);
2581         }
2582 }
2583 
2584 
2585 /*
2586  * hidparser_lookup_attribute:
2587  *      Takes an item pointer(report structure) and a tag(e.g Logical
2588  *      Min) as input. Returns the corresponding attribute structure.
2589  *      Presently used for error checking only.
2590  */
2591 static entity_attribute_t *
2592 hidparser_lookup_attribute(entity_item_t *item, int attr_tag)
2593 {
2594         entity_attribute_t *temp;
2595 
2596         if (item == NULL) {
2597 
2598                 return (NULL);
2599         }
2600 
2601         temp = item->entity_item_attributes;
2602         while (temp != NULL) {
2603                 if (temp->entity_attribute_tag == attr_tag) {
2604 
2605                         return (temp);
2606                 }
2607 
2608                 temp = temp->entity_attribute_next;
2609         }
2610 
2611         return (NULL);
2612 }
2613 
2614 
2615 /*
2616  * hidparser_global_err_check:
2617  *      Error checking for Global Items that need to be
2618  *      performed in MainItem
2619  */
2620 static void
2621 hidparser_global_err_check(entity_item_t *mainitem)
2622 {
2623         hidparser_check_minmax_val_signed(mainitem, R_ITEM_LOGICAL_MINIMUM,
2624             R_ITEM_LOGICAL_MAXIMUM, 0, 0);
2625         hidparser_check_minmax_val_signed(mainitem, R_ITEM_PHYSICAL_MINIMUM,
2626             R_ITEM_PHYSICAL_MAXIMUM, 0, 0);
2627         hidparser_check_correspondence(mainitem, R_ITEM_PHYSICAL_MINIMUM,
2628             R_ITEM_PHYSICAL_MAXIMUM, 0, 0,
2629             "Must have a corresponding Physical min",
2630             "Must have a corresponding Physical max");
2631         hidparser_check_correspondence(mainitem, R_ITEM_PUSH, R_ITEM_POP,
2632             1, 0, "Should have a corresponding Pop",
2633             "Must have a corresponding Push");
2634 
2635 }
2636 
2637 
2638 /*
2639  * hidparser_mainitem_err_check:
2640  *      Error checking for Main Items
2641  */
2642 static void
2643 hidparser_mainitem_err_check(entity_item_t *mainitem)
2644 {
2645         int     itemmask = 0;
2646         entity_attribute_t *attr;
2647 
2648         attr = mainitem->entity_item_attributes;
2649 
2650         if (attr != NULL) {
2651                 while (attr) {
2652                         switch (attr->entity_attribute_tag) {
2653                                 case R_ITEM_LOGICAL_MINIMUM:
2654                                         itemmask |= 0x01;
2655                                         break;
2656                                 case R_ITEM_LOGICAL_MAXIMUM:
2657                                         itemmask |= 0x02;
2658                                         break;
2659                                 case R_ITEM_REPORT_SIZE:
2660                                         itemmask |= 0x04;
2661                                         break;
2662                                 case R_ITEM_REPORT_COUNT:
2663                                         itemmask |= 0x08;
2664                                         break;
2665                                 case R_ITEM_USAGE_PAGE:
2666                                         itemmask |= 0x10;
2667                                         break;
2668                                 default:
2669                                         break;
2670                         } /* switch */
2671                         attr = attr->entity_attribute_next;
2672                 } /* while */
2673         } /* if */
2674 
2675         if ((mainitem->entity_item_type == R_ITEM_COLLECTION) ||
2676             (mainitem->entity_item_type == R_ITEM_END_COLLECTION)) {
2677 
2678                 return;
2679         }
2680         if (itemmask != 0x1f) {
2681                         hidparser_report_err(
2682                             HIDPARSER_ERR_ERROR,
2683                             HIDPARSER_ERR_STANDARD,
2684                             mainitem->entity_item_type,
2685                             0,
2686                             "Required Global/Local items must be defined");
2687         }
2688 }
2689 
2690 
2691 /*
2692  * hidparser_local_err_check:
2693  *      Error checking for Local items that is done when a MainItem
2694  *      is encountered
2695  */
2696 static void
2697 hidparser_local_err_check(entity_item_t *mainitem)
2698 {
2699         hidparser_check_correspondence(mainitem, R_ITEM_USAGE_MIN,
2700             R_ITEM_USAGE_MAX, 0, 0,
2701             "Must have a corresponding Usage Min",
2702             "Must have a corresponding Usage Max");
2703         hidparser_check_minmax_val(mainitem, R_ITEM_USAGE_MIN,
2704             R_ITEM_USAGE_MAX, 1, 1);
2705         hidparser_check_correspondence(mainitem, R_ITEM_DESIGNATOR_MIN,
2706             R_ITEM_DESIGNATOR_MAX, 0, 0,
2707             "Must have a corresponding Designator min",
2708             "Must have a corresponding Designator Max");
2709         hidparser_check_minmax_val(mainitem, R_ITEM_DESIGNATOR_MIN,
2710             R_ITEM_DESIGNATOR_MAX, 1, 1);
2711         hidparser_check_correspondence(mainitem, R_ITEM_STRING_MIN,
2712             R_ITEM_STRING_MAX, 0, 0,
2713             "Must have a corresponding String min",
2714             "Must have a corresponding String Max");
2715         hidparser_check_minmax_val(mainitem, R_ITEM_STRING_MIN,
2716             R_ITEM_STRING_MAX, 1, 1);
2717 }
2718 
2719 
2720 /*
2721  * hidparser_find_unsigned_val:
2722  *      Find the value for multibyte data
2723  *      Ref: Section 5.8 of HID Spec 1.0
2724  */
2725 static unsigned int
2726 hidparser_find_unsigned_val(entity_attribute_t *attr)
2727 {
2728         char *text;
2729         int len, i;
2730         unsigned int ret = 0;
2731 
2732         text = attr->entity_attribute_value;
2733         len = attr->entity_attribute_length;
2734         for (i = 0; i < len; i++) {
2735                 ret |= ((text[i] & 0xff) << (8*i));
2736         }
2737 
2738         return (ret);
2739 }
2740 
2741 
2742 /*
2743  * hidparser_find_signed_val:
2744  *      Find the value for signed multibyte data
2745  *      Ref: Section 5.8 of HID Spec 1.0
2746  */
2747 static signed int
2748 hidparser_find_signed_val(entity_attribute_t *attr)
2749 {
2750         char *text;
2751         int len, i;
2752         int ret = 0;
2753 
2754         text = attr->entity_attribute_value;
2755         len = attr->entity_attribute_length;
2756 
2757         for (i = 0; i < len - 1; i++) {
2758                 ret |= ((text[i] & 0xff) << (8 * i));
2759         }
2760 
2761         if (len > 0) {
2762                 ret |= (text[i] << (8 * i));
2763         }
2764 
2765         return (ret);
2766 }
2767 
2768 
2769 /*
2770  * hidparser_check_correspondence:
2771  *      Check if the item item2 corresponding to item1 exists and vice versa
2772  *      If not report the appropriate error
2773  */
2774 static void
2775 hidparser_check_correspondence(entity_item_t *mainitem,
2776                         int item_tag1,
2777                         int item_tag2,
2778                         int val1,
2779                         int val2,
2780                         char *str1,
2781                         char *str2)
2782 {
2783         entity_attribute_t *temp1, *temp2;
2784 
2785         temp1 = hidparser_lookup_attribute(mainitem, item_tag1);
2786         temp2 = hidparser_lookup_attribute(mainitem, item_tag2);
2787         if ((temp1 != NULL) && (temp2 == NULL)) {
2788                 hidparser_report_err(
2789                     HIDPARSER_ERR_ERROR,
2790                     HIDPARSER_ERR_STANDARD,
2791                     item_tag1,
2792                     val1,
2793                     str1);
2794         }
2795         if ((temp2 != NULL) && (temp1 == NULL)) {
2796                 hidparser_report_err(
2797                     HIDPARSER_ERR_ERROR,
2798                     HIDPARSER_ERR_STANDARD,
2799                     item_tag2,
2800                     val2,
2801                     str2);
2802         }
2803 }
2804 
2805 
2806 /*
2807  * hidparser_check_minmax_val:
2808  *      Check if the Min value <= Max and vice versa
2809  *      Print for warnings and errors have been taken care separately.
2810  */
2811 static void
2812 hidparser_check_minmax_val(entity_item_t *mainitem,
2813                         int item_tag1,
2814                         int item_tag2,
2815                         int val1,
2816                         int val2)
2817 {
2818         entity_attribute_t *temp1, *temp2;
2819 
2820         temp1 = hidparser_lookup_attribute(mainitem, item_tag1);
2821         temp2 = hidparser_lookup_attribute(mainitem, item_tag2);
2822         if ((temp1 != NULL) && (temp2 != NULL)) {
2823                 if (hidparser_find_unsigned_val(temp1) >
2824                     hidparser_find_unsigned_val(temp2)) {
2825                         if ((item_tag1 == R_ITEM_LOGICAL_MINIMUM) ||
2826                             (item_tag1 == R_ITEM_PHYSICAL_MINIMUM)) {
2827                                 hidparser_report_err(
2828                                     HIDPARSER_ERR_WARN,
2829                                     HIDPARSER_ERR_STANDARD,
2830                                     item_tag1,
2831                                     val1,
2832                                     "unsigned: Min should be <= to Max");
2833                         } else {
2834                                 hidparser_report_err(
2835                                     HIDPARSER_ERR_ERROR,
2836                                     HIDPARSER_ERR_STANDARD,
2837                                     item_tag1,
2838                                     val1,
2839                                     "Min must be <= to Max");
2840                         }
2841                 }
2842                 if (hidparser_find_unsigned_val(temp2) <
2843                     hidparser_find_unsigned_val(temp1)) {
2844                         if ((item_tag2 == R_ITEM_LOGICAL_MAXIMUM) ||
2845                             (item_tag2 == R_ITEM_PHYSICAL_MAXIMUM)) {
2846                                 hidparser_report_err(
2847                                     HIDPARSER_ERR_ERROR,
2848                                     HIDPARSER_ERR_STANDARD,
2849                                     item_tag2,
2850                                     val2,
2851                                     "unsigned: Max should be >= to Min");
2852                         } else {
2853                                 hidparser_report_err(
2854                                     HIDPARSER_ERR_ERROR,
2855                                     HIDPARSER_ERR_STANDARD,
2856                                     item_tag2,
2857                                     val2,
2858                                     "Max must be >= to Min");
2859                         }
2860                 }
2861         }       /* if (temp1 != NULL) && (temp2 != NULL) */
2862 }
2863 
2864 
2865 /*
2866  * hidparser_check_minmax_val_signed:
2867  *      Check if the Min value <= Max and vice versa
2868  *      Print for warnings and errors have been taken care separately.
2869  */
2870 static void
2871 hidparser_check_minmax_val_signed(entity_item_t *mainitem,
2872                         int item_tag1,
2873                         int item_tag2,
2874                         int val1,
2875                         int val2)
2876 {
2877         entity_attribute_t *temp1, *temp2;
2878 
2879         temp1 = hidparser_lookup_attribute(mainitem, item_tag1);
2880         temp2 = hidparser_lookup_attribute(mainitem, item_tag2);
2881         if ((temp1 != NULL) && (temp2 != NULL)) {
2882                 if (hidparser_find_signed_val(temp1) >
2883                     hidparser_find_signed_val(temp2)) {
2884                         if ((item_tag1 == R_ITEM_LOGICAL_MINIMUM) ||
2885                             (item_tag1 == R_ITEM_PHYSICAL_MINIMUM)) {
2886                                 hidparser_report_err(
2887                                     HIDPARSER_ERR_WARN,
2888                                     HIDPARSER_ERR_STANDARD,
2889                                     item_tag1,
2890                                     val1,
2891                                     "signed: Min should be <= to Max");
2892                         } else {
2893                                 hidparser_report_err(
2894                                     HIDPARSER_ERR_ERROR,
2895                                     HIDPARSER_ERR_STANDARD,
2896                                     item_tag1,
2897                                     val1,
2898                                     "Min must be <= to Max");
2899                         }
2900                 }
2901                 if (hidparser_find_signed_val(temp2) <
2902                     hidparser_find_signed_val(temp1)) {
2903                         if ((item_tag2 == R_ITEM_LOGICAL_MAXIMUM) ||
2904                             (item_tag2 == R_ITEM_PHYSICAL_MAXIMUM)) {
2905                                 hidparser_report_err(
2906                                     HIDPARSER_ERR_ERROR,
2907                                     HIDPARSER_ERR_STANDARD,
2908                                     item_tag2,
2909                                     val2,
2910                                     "signed: Max should be >= to Min");
2911                         } else {
2912                                 hidparser_report_err(
2913                                     HIDPARSER_ERR_ERROR,
2914                                     HIDPARSER_ERR_STANDARD,
2915                                     item_tag2,
2916                                     val2,
2917                                     "Max must be >= to Min");
2918                         }
2919                 }
2920         }       /* if (temp1 != NULL) && (temp2 != NULL) */
2921 }
2922 
2923 
2924 /*
2925  * hidparser_error_delim:
2926  *      Error check for Delimiter Sets
2927  */
2928 static void
2929 hidparser_error_delim(entity_item_t *item, int err)
2930 {
2931         entity_attribute_t *attr;
2932         switch (err) {
2933                 case HIDPARSER_DELIM_ERR1:
2934                         hidparser_report_err(
2935                             HIDPARSER_ERR_ERROR,
2936                             HIDPARSER_ERR_STANDARD,
2937                             R_ITEM_SET_DELIMITER,
2938                             0,
2939                             "Must be Delimiter Open");
2940 
2941                         break;
2942                 case HIDPARSER_DELIM_ERR2:
2943                         hidparser_report_err(
2944                             HIDPARSER_ERR_ERROR,
2945                             HIDPARSER_ERR_STANDARD,
2946                             R_ITEM_SET_DELIMITER,
2947                             0,
2948                             "Must be Delimiter Close");
2949 
2950                         break;
2951                 case HIDPARSER_DELIM_ERR3:
2952                         attr = item->entity_item_attributes;
2953                         while (attr != NULL) {
2954                                 if ((attr->entity_attribute_tag !=
2955                                     R_ITEM_USAGE) &&
2956                                     (attr->entity_attribute_tag !=
2957                                     R_ITEM_USAGE_MIN) &&
2958                                     (attr->entity_attribute_tag !=
2959                                     R_ITEM_USAGE_MAX)) {
2960                                         hidparser_report_err(
2961                                             HIDPARSER_ERR_ERROR,
2962                                             HIDPARSER_ERR_STANDARD,
2963                                             R_ITEM_SET_DELIMITER,
2964                                             3,
2965                                             "May only contain Usage, "
2966                                             "Usage Min and Usage Max");
2967                                 }
2968                                 attr = attr->entity_attribute_next;
2969                         }
2970 
2971                         break;
2972                 default:
2973 
2974                         break;
2975         }
2976 }
2977 
2978 
2979 /*
2980  * hidparser_find_max_packet_size_from_report_descriptor:
2981  *      find packet size of the largest report in the report descriptor
2982  */
2983 void
2984 hidparser_find_max_packet_size_from_report_descriptor(
2985                         hidparser_handle_t hparser_handle,
2986                         hidparser_packet_info_t *hpack)
2987 {
2988 
2989         int                             rval, i;
2990         uint_t                          packet_size;
2991         uint_t                          max_packet_size;
2992         uint_t                          max_report_id;
2993         hidparser_report_id_list_t      report_id_list;
2994 
2995         USB_DPRINTF_L4(PRINT_MASK_ALL, hparser_log_handle,
2996             "hidparser_find_max_packet_size_from_report_descriptor");
2997 
2998         /* get a list of input reports */
2999         rval = hidparser_get_report_id_list(hparser_handle,
3000             R_ITEM_INPUT, &report_id_list);
3001         if (rval != HIDPARSER_SUCCESS) {
3002                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
3003                     "No report id used");
3004         } else {
3005                 USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle,
3006                     "%d unique report IDs found in hid report descriptor",
3007                     report_id_list.no_of_report_ids);
3008 
3009                 for (i = 0; i < (report_id_list.no_of_report_ids); i++) {
3010                         USB_DPRINTF_L3(PRINT_MASK_ALL, hparser_log_handle,
3011                             "report_id: %d", report_id_list.report_id[i]);
3012                 }
3013         }
3014 
3015         if ((rval != HIDPARSER_SUCCESS) ||
3016             (report_id_list.no_of_report_ids == 0)) {
3017                 /*
3018                  * since no report id is used, get the packet size
3019                  * for the only report available
3020                  */
3021                 (void) hidparser_get_packet_size(hparser_handle,
3022                     0, R_ITEM_INPUT, &packet_size);
3023                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
3024                     "Not using report id prefix. HID packet size = %d",
3025                     packet_size);
3026 
3027                 hpack->max_packet_size = packet_size;
3028                 hpack->report_id = HID_REPORT_ID_UNDEFINED;
3029         } else {
3030                 /*
3031                  * hid device uses multiple reports with report id prefix byte.
3032                  * Find the longest input report.
3033                  * See HID 8.4.
3034                  */
3035                 max_packet_size = 0;
3036                 max_report_id = 0;
3037 
3038                 for (i = 0; i < (report_id_list.no_of_report_ids); i++) {
3039                         (void) hidparser_get_packet_size(hparser_handle,
3040                             report_id_list.report_id[i], R_ITEM_INPUT,
3041                             &packet_size);
3042                         if (packet_size > max_packet_size) {
3043                                 max_packet_size = packet_size;
3044                                 max_report_id = report_id_list.report_id[i];
3045                         }
3046                         USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
3047                             "Report ID %d has a packet size of %d",
3048                             report_id_list.report_id[i], packet_size);
3049                 }
3050 
3051                 hpack->max_packet_size = max_packet_size;
3052                 hpack->report_id = max_report_id;
3053 
3054                 USB_DPRINTF_L2(PRINT_MASK_ALL, hparser_log_handle,
3055                     "Report ID %d has the maximum packet size of %d",
3056                     max_report_id, max_packet_size);
3057         }
3058 }