t_hid.c revision 1.6
1 /* $NetBSD: t_hid.c,v 1.6 2016/05/02 17:24:06 jakllsch Exp $ */ 2 3 /* 4 * Copyright (c) 2016 Jonathan A. Kollasch 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 26 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __RCSID("$NetBSD: t_hid.c,v 1.6 2016/05/02 17:24:06 jakllsch Exp $"); 31 32 #include <machine/types.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <stdio.h> 36 #include <atf-c.h> 37 38 #include <rump/rump.h> 39 40 #define hid_start_parse rumpns_hid_start_parse 41 #define hid_end_parse rumpns_hid_end_parse 42 #define hid_get_item rumpns_hid_get_item 43 #define hid_locate rumpns_hid_locate 44 #define hid_report_size rumpns_hid_report_size 45 #define hid_get_data rumpns_hid_get_data 46 #define hid_get_udata rumpns_hid_get_udata 47 #define uhidevdebug rumpns_uhidevdebug 48 #include <usb.h> 49 #include <usbhid.h> 50 #include <hid.h> 51 52 #include "../../lib/libusbhid/hid_test_data.c" 53 54 #define MYd_ATF_CHECK_EQ(d, v) \ 55 ATF_CHECK_EQ_MSG(d, v, "== %d", (d)) 56 57 #define MYld_ATF_CHECK_EQ(d, v) \ 58 ATF_CHECK_EQ_MSG(d, v, "== %ld", (d)) 59 60 #define MYu_ATF_CHECK_EQ(d, v) \ 61 ATF_CHECK_EQ_MSG(d, v, "== %u", (d)) 62 63 #define MYlu_ATF_CHECK_EQ(d, v) \ 64 ATF_CHECK_EQ_MSG(d, v, "== %lu", (d)) 65 66 #define MYx_ATF_CHECK_EQ(d, v) \ 67 ATF_CHECK_EQ_MSG(d, v, "== 0x%x", (d)) 68 69 #define MYlx_ATF_CHECK_EQ(d, v) \ 70 ATF_CHECK_EQ_MSG(d, v, "== 0x%lx", (d)) 71 72 int uhidevdebug; 73 74 ATF_TC(khid); 75 76 ATF_TC_HEAD(khid, tc) 77 { 78 79 atf_tc_set_md_var(tc, "descr", "check kernel hid.c"); 80 } 81 82 static int 83 locate_item(const void *desc, int size, u_int32_t u, u_int8_t id, 84 enum hid_kind k, struct hid_item *hip) 85 { 86 struct hid_data *d; 87 struct hid_item h; 88 89 h.report_ID = 0; 90 for (d = hid_start_parse(desc, size, k); hid_get_item(d, &h); ) { 91 if (h.kind == k && !(h.flags & HIO_CONST) && 92 (/*XXX*/uint32_t)h.usage == u && h.report_ID == id) { 93 if (hip != NULL) 94 *hip = h; 95 hid_end_parse(d); 96 return (1); 97 } 98 } 99 hid_end_parse(d); 100 return (0); 101 } 102 103 ATF_TC_BODY(khid, tc) 104 { 105 int ret; 106 struct hid_item hi; 107 108 uhidevdebug = 0; 109 110 rump_init(); 111 112 ret = locate_item(range_test_report_descriptor, 113 sizeof(range_test_report_descriptor), 0xff000003, 0, hid_input, 114 &hi); 115 ATF_REQUIRE(ret > 0); 116 MYu_ATF_CHECK_EQ(hi.loc.size, 32); 117 MYu_ATF_CHECK_EQ(hi.loc.count, 1); 118 MYu_ATF_CHECK_EQ(hi.loc.pos, 0); 119 MYx_ATF_CHECK_EQ(hi.flags, 0); 120 MYd_ATF_CHECK_EQ(hi.logical_minimum, -2147483648); 121 MYd_ATF_CHECK_EQ(hi.logical_maximum, 2147483647); 122 MYd_ATF_CHECK_EQ(hi.physical_minimum, -2147483648); 123 MYd_ATF_CHECK_EQ(hi.physical_maximum, 2147483647); 124 MYld_ATF_CHECK_EQ(hid_get_data(range_test_minimum_report, 125 &hi.loc), -2147483648); 126 MYld_ATF_CHECK_EQ(hid_get_data(range_test_negative_one_report, 127 &hi.loc), -1); 128 MYld_ATF_CHECK_EQ(hid_get_data(range_test_positive_one_report, 129 &hi.loc), 1); 130 MYld_ATF_CHECK_EQ(hid_get_data(range_test_maximum_report, 131 &hi.loc), 2147483647); 132 133 ret = locate_item(range_test_report_descriptor, 134 sizeof(range_test_report_descriptor), 0xff000002, 0, hid_input, 135 &hi); 136 ATF_REQUIRE(ret > 0); 137 MYu_ATF_CHECK_EQ(hi.loc.size, 16); 138 MYu_ATF_CHECK_EQ(hi.loc.count, 1); 139 MYu_ATF_CHECK_EQ(hi.loc.pos, 32); 140 MYx_ATF_CHECK_EQ(hi.flags, 0); 141 MYd_ATF_CHECK_EQ(hi.logical_minimum, -32768); 142 MYd_ATF_CHECK_EQ(hi.logical_maximum, 32767); 143 MYd_ATF_CHECK_EQ(hi.physical_minimum, -32768); 144 MYd_ATF_CHECK_EQ(hi.physical_maximum, 32767); 145 MYld_ATF_CHECK_EQ(hid_get_data(range_test_minimum_report, 146 &hi.loc), -32768); 147 MYld_ATF_CHECK_EQ(hid_get_data(range_test_negative_one_report, 148 &hi.loc), -1); 149 MYld_ATF_CHECK_EQ(hid_get_data(range_test_positive_one_report, 150 &hi.loc), 1); 151 MYld_ATF_CHECK_EQ(hid_get_data(range_test_maximum_report, 152 &hi.loc), 32767); 153 154 ret = locate_item(range_test_report_descriptor, 155 sizeof(range_test_report_descriptor), 0xff000001, 0, hid_input, 156 &hi); 157 ATF_REQUIRE(ret > 0); 158 MYu_ATF_CHECK_EQ(hi.loc.size, 8); 159 MYu_ATF_CHECK_EQ(hi.loc.count, 1); 160 MYu_ATF_CHECK_EQ(hi.loc.pos, 48); 161 MYx_ATF_CHECK_EQ(hi.flags, 0); 162 MYd_ATF_CHECK_EQ(hi.logical_minimum, -128); 163 MYd_ATF_CHECK_EQ(hi.logical_maximum, 127); 164 MYd_ATF_CHECK_EQ(hi.physical_minimum, -128); 165 MYd_ATF_CHECK_EQ(hi.physical_maximum, 127); 166 MYld_ATF_CHECK_EQ(hid_get_data(range_test_minimum_report, 167 &hi.loc), -128); 168 MYld_ATF_CHECK_EQ(hid_get_data(range_test_negative_one_report, 169 &hi.loc), -1); 170 MYld_ATF_CHECK_EQ(hid_get_data(range_test_positive_one_report, 171 &hi.loc), 1); 172 MYld_ATF_CHECK_EQ(hid_get_data(range_test_maximum_report, 173 &hi.loc), 127); 174 175 176 ret = locate_item(unsigned_range_test_report_descriptor, 177 sizeof(unsigned_range_test_report_descriptor), 0xff000013, 0, 178 hid_input, &hi); 179 ATF_REQUIRE(ret > 0); 180 MYu_ATF_CHECK_EQ(hi.loc.size, 32); 181 MYu_ATF_CHECK_EQ(hi.loc.count, 1); 182 MYu_ATF_CHECK_EQ(hi.loc.pos, 0); 183 MYx_ATF_CHECK_EQ(hi.flags, 0); 184 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_minimum_report, 185 &hi.loc), 0x0); 186 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_positive_one_report, 187 &hi.loc), 0x1); 188 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_negative_one_report, 189 &hi.loc), 0xfffffffe); 190 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_maximum_report, 191 &hi.loc), 0xffffffff); 192 193 ret = locate_item(unsigned_range_test_report_descriptor, 194 sizeof(unsigned_range_test_report_descriptor), 0xff000012, 0, 195 hid_input, &hi); 196 ATF_REQUIRE(ret > 0); 197 MYu_ATF_CHECK_EQ(hi.loc.size, 16); 198 MYu_ATF_CHECK_EQ(hi.loc.count, 1); 199 MYu_ATF_CHECK_EQ(hi.loc.pos, 32); 200 MYx_ATF_CHECK_EQ(hi.flags, 0); 201 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_minimum_report, 202 &hi.loc), 0x0); 203 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_positive_one_report, 204 &hi.loc), 0x1); 205 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_negative_one_report, 206 &hi.loc), 0xfffe); 207 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_maximum_report, 208 &hi.loc), 0xffff); 209 210 ret = locate_item(unsigned_range_test_report_descriptor, 211 sizeof(unsigned_range_test_report_descriptor), 0xff000011, 0, 212 hid_input, &hi); 213 ATF_REQUIRE(ret > 0); 214 MYu_ATF_CHECK_EQ(hi.loc.size, 8); 215 MYu_ATF_CHECK_EQ(hi.loc.count, 1); 216 MYu_ATF_CHECK_EQ(hi.loc.pos, 48); 217 MYx_ATF_CHECK_EQ(hi.flags, 0); 218 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_minimum_report, 219 &hi.loc), 0x0); 220 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_positive_one_report, 221 &hi.loc), 0x1); 222 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_negative_one_report, 223 &hi.loc), 0xfe); 224 MYlx_ATF_CHECK_EQ(hid_get_udata(unsigned_range_test_maximum_report, 225 &hi.loc), 0xff); 226 } 227 228 ATF_TC(khid_parse_just_pop); 229 230 ATF_TC_HEAD(khid_parse_just_pop, tc) 231 { 232 233 atf_tc_set_md_var(tc, "descr", "check kernel hid.c for " 234 "Pop on empty stack bug"); 235 } 236 237 ATF_TC_BODY(khid_parse_just_pop, tc) 238 { 239 struct hid_data *hdp; 240 struct hid_item hi; 241 242 rump_init(); 243 244 hdp = hid_start_parse(just_pop_report_descriptor, 245 sizeof just_pop_report_descriptor, hid_none); 246 while (hid_get_item(hdp, &hi) > 0) { 247 } 248 hid_end_parse(hdp); 249 } 250 251 ATF_TP_ADD_TCS(tp) 252 { 253 254 ATF_TP_ADD_TC(tp, khid); 255 ATF_TP_ADD_TC(tp, khid_parse_just_pop); 256 257 return atf_no_error(); 258 } 259 260
Indexes created Wed Sep 24 05:09:52 GMT 2025