![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HIDProcessLocalItem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOHIDSystem / IOHIDDescriptorParser|
Return to HIDProcessLocalItem.c CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOHIDSystem / IOHIDDescriptorParser |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: File: HIDProcessLocalItem.c ! 24: ! 25: Contains: xxx put contents here xxx ! 26: ! 27: Version: xxx put version here xxx ! 28: ! 29: Copyright: � 1999 by Apple Computer, Inc., all rights reserved. ! 30: ! 31: File Ownership: ! 32: ! 33: DRI: xxx put dri here xxx ! 34: ! 35: Other Contact: xxx put other contact here xxx ! 36: ! 37: Technology: xxx put technology here xxx ! 38: ! 39: Writers: ! 40: ! 41: (BWS) Brent Schorsch ! 42: ! 43: Change History (most recent first): ! 44: ! 45: <USB1> 3/5/99 BWS first checked in ! 46: */ ! 47: ! 48: #include "HIDLib.h" ! 49: ! 50: /* ! 51: *------------------------------------------------------------------------------ ! 52: * ! 53: * HIDProcessLocalItem - Process a LocalItem ! 54: * ! 55: * Input: ! 56: * ptDescriptor - The Descriptor Structure ! 57: * ptPreparsedData - The PreParsedData Structure ! 58: * Output: ! 59: * ptPreparsedData - The PreParsedData Structure ! 60: * Returns: ! 61: * kHIDSuccess - Success ! 62: * kHIDNullPointerErr - Argument, Pointer was Null ! 63: * ! 64: *------------------------------------------------------------------------------ ! 65: */ ! 66: OSStatus HIDProcessLocalItem(HIDReportDescriptor *ptDescriptor, ! 67: HIDPreparsedDataPtr ptPreparsedData) ! 68: { ! 69: HIDDesignatorItem *ptDesignatorItem; ! 70: HIDStringItem *ptStringItem; ! 71: HIDP_UsageItem *ptUsageItem; ! 72: HIDItem *ptItem; ! 73: /* ! 74: * Disallow NULL Pointers ! 75: */ ! 76: if ((ptDescriptor == NULL) || (ptPreparsedData == NULL)) ! 77: return kHIDNullPointerErr; ! 78: /* ! 79: * Process the LocalItem by tag ! 80: */ ! 81: ptItem = &ptDescriptor->item; ! 82: switch (ptItem->tag) ! 83: { ! 84: /* ! 85: * Note that Tag = usage Item may represent either ! 86: * a UsagePair with the usagePage implied, or ! 87: * a UsagePair defined by an extended usage ! 88: * If a Tag = usage Item has 1 or 2 bytes of data ! 89: * then the current usagePage is used ! 90: * If a Tag = usage Item has 4 bytes of data ! 91: * then the high order bytes are the usagePage ! 92: * ! 93: * Note that the Microsoft HID Parser uses the last ! 94: * usagePage defined before the MainItem with which ! 95: * the usage is associated rather than the current ! 96: * usagePage. The method used here is more generic ! 97: * although multiple UsagePages for a MainItem are ! 98: * unlikely due to the MS limitation. ! 99: */ ! 100: case kHIDTagUsage: ! 101: ptUsageItem = &ptPreparsedData->usageItems[ptPreparsedData->usageItemCount++]; ! 102: ptUsageItem->isRange = false; ! 103: if (ptItem->byteCount == 4) ! 104: { ! 105: ptUsageItem->usagePage = ptItem->unsignedValue>>16; ! 106: ptUsageItem->usage = ptItem->unsignedValue&0xFFFFL; ! 107: } ! 108: else ! 109: { ! 110: ptUsageItem->usagePage = ptDescriptor->globals.usagePage; ! 111: ptUsageItem->usage = ptItem->unsignedValue; ! 112: } ! 113: break; ! 114: /* ! 115: * Note that Tag = usage Minimum Item may represent either ! 116: * a UsagePair with the usagePage implied, or ! 117: * a UsagePair defined by an extended usage ! 118: * If a Tag = usage Item has 1 or 2 bytes of data ! 119: * then the current usagePage is used ! 120: * If a Tag = usage Item has 4 bytes of data ! 121: * then the high order bytes are the usagePage ! 122: */ ! 123: case kHIDTagUsageMinimum: ! 124: if (ptDescriptor->haveUsageMax) ! 125: { ! 126: ptUsageItem = &ptPreparsedData->usageItems[ptPreparsedData->usageItemCount++]; ! 127: ptUsageItem->isRange = true; ! 128: if (ptItem->byteCount == 4) ! 129: { ! 130: ptUsageItem->usagePage = ptItem->unsignedValue>>16; ! 131: ptUsageItem->usageMinimum = ptItem->unsignedValue&0xFFFFL; ! 132: } ! 133: else ! 134: { ! 135: ptUsageItem->usagePage = ptDescriptor->globals.usagePage; ! 136: ptUsageItem->usageMinimum = ptItem->unsignedValue; ! 137: } ! 138: if (ptUsageItem->usagePage != ptDescriptor->rangeUsagePage) ! 139: return kHIDInvalidRangePageErr; ! 140: ptUsageItem->usageMaximum = ptDescriptor->usageMaximum; ! 141: if (ptUsageItem->usageMaximum < ptUsageItem->usageMinimum) ! 142: return kHIDInvertedUsageRangeErr; ! 143: ptDescriptor->haveUsageMax = false; ! 144: ptDescriptor->haveUsageMin = false; ! 145: } ! 146: else ! 147: { ! 148: if (ptItem->byteCount == 4) ! 149: { ! 150: ptDescriptor->rangeUsagePage = ptItem->unsignedValue>>16; ! 151: ptDescriptor->usageMinimum = ptItem->unsignedValue&0xFFFFL; ! 152: } ! 153: else ! 154: { ! 155: ptDescriptor->rangeUsagePage = ptDescriptor->globals.usagePage; ! 156: ptDescriptor->usageMinimum = ptItem->unsignedValue; ! 157: } ! 158: ptDescriptor->haveUsageMin = true; ! 159: } ! 160: break; ! 161: /* ! 162: * Note that Tag = usage Maximum Item may represent either ! 163: * a UsagePair with the usagePage implied, or ! 164: * a UsagePair defined by an extended usage ! 165: * If a Tag = usage Item has 1 or 2 bytes of data ! 166: * then the current usagePage is used ! 167: * If a Tag = usage Item has 4 bytes of data ! 168: * then the high order bytes are the usagePage ! 169: */ ! 170: case kHIDTagUsageMaximum: ! 171: if (ptDescriptor->haveUsageMin) ! 172: { ! 173: ptUsageItem = &ptPreparsedData->usageItems[ptPreparsedData->usageItemCount++]; ! 174: ptUsageItem->isRange = true; ! 175: if (ptItem->byteCount == 4) ! 176: { ! 177: ptUsageItem->usagePage = ptItem->unsignedValue>>16; ! 178: ptUsageItem->usageMaximum = ptItem->unsignedValue&0xFFFFL; ! 179: } ! 180: else ! 181: { ! 182: ptUsageItem->usagePage = ptDescriptor->globals.usagePage; ! 183: ptUsageItem->usageMaximum = ptItem->unsignedValue; ! 184: } ! 185: if (ptUsageItem->usagePage != ptDescriptor->rangeUsagePage) ! 186: return kHIDInvalidRangePageErr; ! 187: ptUsageItem->usageMinimum = ptDescriptor->usageMinimum; ! 188: if (ptUsageItem->usageMaximum < ptUsageItem->usageMinimum) ! 189: return kHIDInvertedUsageRangeErr; ! 190: ptDescriptor->haveUsageMax = false; ! 191: ptDescriptor->haveUsageMin = false; ! 192: } ! 193: else ! 194: { ! 195: if (ptItem->byteCount == 4) ! 196: { ! 197: ptDescriptor->rangeUsagePage = ptItem->unsignedValue>>16; ! 198: ptDescriptor->usageMaximum = ptItem->unsignedValue&0xFFFFL; ! 199: } ! 200: else ! 201: { ! 202: ptDescriptor->rangeUsagePage = ptDescriptor->globals.usagePage; ! 203: ptDescriptor->usageMaximum = ptItem->unsignedValue; ! 204: } ! 205: ptDescriptor->haveUsageMax = true; ! 206: } ! 207: break; ! 208: /* ! 209: * Designators ! 210: */ ! 211: case kHIDTagDesignatorIndex: ! 212: ptDesignatorItem = &ptPreparsedData->desigItems[ptPreparsedData->desigItemCount++]; ! 213: ptDesignatorItem->isRange = false; ! 214: ptDesignatorItem->index = ptItem->unsignedValue; ! 215: break; ! 216: case kHIDTagDesignatorMinimum: ! 217: if (ptDescriptor->haveDesigMax) ! 218: { ! 219: ptDesignatorItem = &ptPreparsedData->desigItems[ptPreparsedData->desigItemCount++]; ! 220: ptDesignatorItem->isRange = true; ! 221: ptDesignatorItem->minimum = ptItem->unsignedValue; ! 222: ptDesignatorItem->maximum = ptDescriptor->desigMaximum; ! 223: ptDescriptor->haveDesigMin = false; ! 224: ptDescriptor->haveDesigMax = false; ! 225: } ! 226: else ! 227: { ! 228: ptDescriptor->desigMinimum = ptItem->unsignedValue; ! 229: ptDescriptor->haveDesigMin = true; ! 230: } ! 231: break; ! 232: case kHIDTagDesignatorMaximum: ! 233: if (ptDescriptor->haveDesigMin) ! 234: { ! 235: ptDesignatorItem = &ptPreparsedData->desigItems[ptPreparsedData->desigItemCount++]; ! 236: ptDesignatorItem->isRange = true; ! 237: ptDesignatorItem->maximum = ptItem->unsignedValue; ! 238: ptDesignatorItem->minimum = ptDescriptor->desigMinimum; ! 239: ptDescriptor->haveDesigMin = false; ! 240: ptDescriptor->haveDesigMax = false; ! 241: } ! 242: else ! 243: { ! 244: ptDescriptor->desigMaximum = ptItem->unsignedValue; ! 245: ptDescriptor->haveDesigMax = true; ! 246: } ! 247: break; ! 248: /* ! 249: * Strings ! 250: */ ! 251: case kHIDTagStringIndex: ! 252: ptStringItem = &ptPreparsedData->stringItems[ptPreparsedData->stringItemCount++]; ! 253: ptStringItem->isRange = false; ! 254: ptStringItem->index = ptItem->unsignedValue; ! 255: break; ! 256: case kHIDTagStringMinimum: ! 257: if (ptDescriptor->haveStringMax) ! 258: { ! 259: ptStringItem = &ptPreparsedData->stringItems[ptPreparsedData->stringItemCount++]; ! 260: ptStringItem->isRange = true; ! 261: ptStringItem->minimum = ptItem->unsignedValue; ! 262: ptStringItem->maximum = ptDescriptor->stringMaximum; ! 263: ptDescriptor->haveStringMin = false; ! 264: ptDescriptor->haveStringMax = false; ! 265: } ! 266: else ! 267: { ! 268: ptDescriptor->stringMinimum = ptItem->unsignedValue; ! 269: ptDescriptor->haveStringMin = true; ! 270: } ! 271: break; ! 272: case kHIDTagStringMaximum: ! 273: if (ptDescriptor->haveStringMin) ! 274: { ! 275: ptStringItem = &ptPreparsedData->stringItems[ptPreparsedData->stringItemCount++]; ! 276: ptStringItem->isRange = true; ! 277: ptStringItem->maximum = ptItem->unsignedValue; ! 278: ptStringItem->minimum = ptDescriptor->stringMinimum; ! 279: ptDescriptor->haveStringMin = false; ! 280: ptDescriptor->haveStringMax = false; ! 281: } ! 282: else ! 283: { ! 284: ptDescriptor->stringMaximum = ptItem->unsignedValue; ! 285: ptDescriptor->haveStringMax = true; ! 286: } ! 287: break; ! 288: /* ! 289: * Delimiters (are not processed) ! 290: */ ! 291: case kHIDTagSetDelimiter: ! 292: break; ! 293: } ! 294: return kHIDSuccess; ! 295: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.