00001
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050 #include <stddef.h>
00051 #include "compiler.h"
00052 #include "conf_usb.h"
00053 #include "usb_task.h"
00054 #include "usb_host_task.h"
00055 #include "usb_host_enum.h"
00056 #include "hid.h"
00057 #include "host_hid.h"
00058
00059
00060
00061
00062
00063
00064
00066 static struct
00067 {
00068 size_t length;
00069 const hid_item_t *item;
00070 } host_hid_report_descriptor_parser =
00071 {
00072 0,
00073 NULL
00074 };
00075
00076
00077
00078
00081
00082
00083
00084 Status_t host_hid_get_descriptor(U8 descriptor_type, U8 descriptor_index, U8 s_interface)
00085 {
00086 Status_t status;
00087 const hid_descriptor_t *hid_descriptor = (hid_descriptor_t *)&data_stage;
00088 U8 i;
00089
00090 usb_request.bmRequestType = 0x81;
00091 usb_request.bRequest = GET_DESCRIPTOR;
00092 usb_request.wValue = descriptor_type << 8 | descriptor_index;
00093 usb_request.wIndex = Get_interface_number(s_interface);
00094 usb_request.wLength = SIZEOF_DATA_STAGE;
00095 usb_request.incomplete_read = FALSE;
00096
00097 status = host_transfer_control(data_stage);
00098
00099 switch (descriptor_type)
00100 {
00101 case HID_DESCRIPTOR:
00102 for (i = 0; i < hid_descriptor->bNumDescriptors; i++)
00103 {
00104 if (hid_descriptor->Descriptor[i].bType == HID_REPORT_DESCRIPTOR)
00105 {
00106 host_hid_report_descriptor_parser.length =
00107 usb_format_usb_to_mcu_data(16, hid_descriptor->Descriptor[i].wLength);
00108 break;
00109 }
00110 }
00111 break;
00112
00113 case HID_REPORT_DESCRIPTOR:
00114 host_hid_report_descriptor_parser.item = (hid_item_t *)&data_stage;
00115 break;
00116 }
00117
00118 return status;
00119 }
00120
00121
00122 Status_t host_hid_set_descriptor(U8 descriptor_type, U8 descriptor_index, U8 s_interface, U16 length)
00123 {
00124 usb_request.bmRequestType = 0x01;
00125 usb_request.bRequest = SET_DESCRIPTOR;
00126 usb_request.wValue = descriptor_type << 8 | descriptor_index;
00127 usb_request.wIndex = Get_interface_number(s_interface);
00128 usb_request.wLength = length;
00129 usb_request.incomplete_read = FALSE;
00130
00131 return host_transfer_control(data_stage);
00132 }
00133
00134
00136
00137
00140
00141
00142
00143 Status_t host_hid_get_report(U8 report_type, U8 report_id, U8 s_interface)
00144 {
00145 usb_request.bmRequestType = 0xA1;
00146 usb_request.bRequest = HID_GET_REPORT;
00147 usb_request.wValue = report_type << 8 | report_id;
00148 usb_request.wIndex = Get_interface_number(s_interface);
00149 usb_request.wLength = SIZEOF_DATA_STAGE;
00150 usb_request.incomplete_read = FALSE;
00151
00152 return host_transfer_control(data_stage);
00153 }
00154
00155
00156 Status_t host_hid_set_report(U8 report_type, U8 report_id, U8 s_interface, U16 length)
00157 {
00158 usb_request.bmRequestType = 0x21;
00159 usb_request.bRequest = HID_SET_REPORT;
00160 usb_request.wValue = report_type << 8 | report_id;
00161 usb_request.wIndex = Get_interface_number(s_interface);
00162 usb_request.wLength = length;
00163 usb_request.incomplete_read = FALSE;
00164
00165 return host_transfer_control(data_stage);
00166 }
00167
00168
00169 U8 host_hid_get_idle(U8 report_id, U8 s_interface)
00170 {
00171 usb_request.bmRequestType = 0xA1;
00172 usb_request.bRequest = HID_GET_IDLE;
00173 usb_request.wValue = 0x00 << 8 | report_id;
00174 usb_request.wIndex = Get_interface_number(s_interface);
00175 usb_request.wLength = 0x0001;
00176 usb_request.incomplete_read = FALSE;
00177
00178 host_transfer_control(data_stage);
00179
00180 return data_stage[0x00];
00181 }
00182
00183
00184 Status_t host_hid_set_idle(U8 duration_4_ms, U8 report_id, U8 s_interface)
00185 {
00186 usb_request.bmRequestType = 0x21;
00187 usb_request.bRequest = HID_SET_IDLE;
00188 usb_request.wValue = duration_4_ms << 8 | report_id;
00189 usb_request.wIndex = Get_interface_number(s_interface);
00190 usb_request.wLength = 0x0000;
00191 usb_request.incomplete_read = FALSE;
00192
00193 return host_transfer_control(data_stage);
00194 }
00195
00196
00197 U8 host_hid_get_protocol(U8 s_interface)
00198 {
00199 usb_request.bmRequestType = 0xA1;
00200 usb_request.bRequest = HID_GET_PROTOCOL;
00201 usb_request.wValue = 0x0000;
00202 usb_request.wIndex = Get_interface_number(s_interface);
00203 usb_request.wLength = 0x0001;
00204 usb_request.incomplete_read = FALSE;
00205
00206 host_transfer_control(data_stage);
00207
00208 return data_stage[0x00];
00209 }
00210
00211
00212 Status_t host_hid_set_protocol(U8 protocol, U8 s_interface)
00213 {
00214 usb_request.bmRequestType = 0x21;
00215 usb_request.bRequest = HID_SET_PROTOCOL;
00216 usb_request.wValue = protocol;
00217 usb_request.wIndex = Get_interface_number(s_interface);
00218 usb_request.wLength = 0x0000;
00219 usb_request.incomplete_read = FALSE;
00220
00221 return host_transfer_control(data_stage);
00222 }
00223
00224
00226
00227
00230
00231
00232
00233 Status_bool_t host_hid_get_item(host_hid_item_t *item)
00234 {
00235 const hid_item_t *hid_item = host_hid_report_descriptor_parser.item;
00236 U8 size;
00237
00238 if (host_hid_report_descriptor_parser.length <
00239 (U8 *)&hid_item->header - (U8 *)hid_item +
00240 sizeof(hid_item->header))
00241 return FALSE;
00242
00243 item->type = hid_item->header.bType;
00244
00245 if (hid_item->header.bTag == HID_ITEM_TAG_LONG_ITEM)
00246 {
00247 if (host_hid_report_descriptor_parser.length <
00248 (U8 *)&hid_item->long_format.bDataSize - (U8 *)hid_item +
00249 sizeof(hid_item->long_format.bDataSize))
00250 return FALSE;
00251
00252 size = hid_item->long_format.bDataSize;
00253
00254 if (host_hid_report_descriptor_parser.length <
00255 (U8 *)&hid_item->long_format.data - (U8 *)hid_item +
00256 size)
00257 return FALSE;
00258
00259 item->tag = hid_item->long_format.bLongItemTag;
00260
00261 item->long_format = TRUE;
00262
00263 item->long_data.size = size;
00264 item->long_data.data = &hid_item->long_format.data;
00265
00266 host_hid_report_descriptor_parser.length -=
00267 (U8 *)&hid_item->long_format.data - (U8 *)hid_item +
00268 size;
00269
00270 host_hid_report_descriptor_parser.item =
00271 (hid_item_t *)&hid_item->long_format.data[size];
00272 }
00273 else
00274 {
00275 U8 i;
00276
00277 size = (hid_item->short_format.bSize) ?
00278 1 << (hid_item->short_format.bSize - 1) :
00279 0;
00280
00281 if (host_hid_report_descriptor_parser.length <
00282 (U8 *)&hid_item->short_format.data - (U8 *)hid_item +
00283 size)
00284 return FALSE;
00285
00286 item->tag = hid_item->short_format.bTag;
00287
00288 item->long_format = FALSE;
00289
00290 item->short_data.value = 0x00000000;
00291 for (i = 0; i < size; i++)
00292 {
00293 item->short_data.value = item->short_data.value << 8 |
00294 hid_item->short_format.data[i];
00295 }
00296 item->short_data.value =
00297 usb_format_usb_to_mcu_data(32, item->short_data.value <<
00298 ((sizeof(U32) - size) << 3));
00299
00300 host_hid_report_descriptor_parser.length -=
00301 (U8 *)&hid_item->short_format.data - (U8 *)hid_item +
00302 size;
00303
00304 host_hid_report_descriptor_parser.item =
00305 (hid_item_t *)&hid_item->short_format.data[size];
00306 }
00307
00308 return TRUE;
00309 }
00310
00311