Changeset 8d3f198 in mainline
- Timestamp:
- 2011-05-26T10:06:24Z (13 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- c0940a85
- Parents:
- fa8d346 (diff), 5f9b81af (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Files:
-
- 1 added
- 6 deleted
- 36 edited
- 2 moved
Legend:
- Unmodified
- Added
- Removed
-
.bzrignore
rfa8d346 r8d3f198 7 7 *.map 8 8 *.disasm 9 *.lo 10 *.la 11 *.so.* 12 *.so0 9 13 _link.ld 10 14 ./*.iso -
uspace/Makefile.common
rfa8d346 r8d3f198 131 131 endif 132 132 endif 133 # Build static whenever we use libusb because that library uses 134 # thread local variables 135 ifneq ($(findstring usb, $(LIBS)),) 136 STATIC_BUILD = y 137 endif 133 138 134 139 ifeq ($(STATIC_BUILD), y) -
uspace/app/lsusb/main.c
rfa8d346 r8d3f198 45 45 #include <devmap.h> 46 46 #include <usb/dev/hub.h> 47 #include <usb/h ost.h>47 #include <usb/hc.h> 48 48 49 49 #define NAME "lsusb" -
uspace/app/usbinfo/main.c
rfa8d346 r8d3f198 43 43 #include <devman.h> 44 44 #include <devmap.h> 45 #include <usb/ dev/hc.h>45 #include <usb/hc.h> 46 46 #include <usb/dev/pipes.h> 47 #include <usb/host.h>48 #include <usb/driver.h>49 47 #include "usbinfo.h" 50 51 static bool try_parse_class_and_address(const char *path,52 devman_handle_t *out_hc_handle, usb_address_t *out_device_address)53 {54 size_t class_index;55 size_t address;56 int rc;57 char *ptr;58 59 rc = str_size_t(path, &ptr, 10, false, &class_index);60 if (rc != EOK) {61 return false;62 }63 if ((*ptr == ':') || (*ptr == '.')) {64 ptr++;65 } else {66 return false;67 }68 rc = str_size_t(ptr, NULL, 10, true, &address);69 if (rc != EOK) {70 return false;71 }72 rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle);73 if (rc != EOK) {74 return false;75 }76 if (out_device_address != NULL) {77 *out_device_address = (usb_address_t) address;78 }79 return true;80 }81 82 static bool resolve_hc_handle_and_dev_addr(const char *devpath,83 devman_handle_t *out_hc_handle, usb_address_t *out_device_address)84 {85 int rc;86 87 /* Hack for QEMU to save-up on typing ;-). */88 if (str_cmp(devpath, "qemu") == 0) {89 devpath = "/hw/pci0/00:01.2/uhci-rh/usb00_a1";90 }91 92 /* Hack for virtual keyboard. */93 if (str_cmp(devpath, "virt") == 0) {94 devpath = "/virt/usbhc/usb00_a1/usb00_a2";95 }96 97 if (try_parse_class_and_address(devpath,98 out_hc_handle, out_device_address)) {99 return true;100 }101 102 char *path = str_dup(devpath);103 if (path == NULL) {104 return ENOMEM;105 }106 107 devman_handle_t hc = 0;108 bool hc_found = false;109 usb_address_t addr = 0;110 bool addr_found = false;111 112 /* Remove suffixes and hope that we will encounter device node. */113 while (str_length(path) > 0) {114 /* Get device handle first. */115 devman_handle_t dev_handle;116 rc = devman_device_get_handle(path, &dev_handle, 0);117 if (rc != EOK) {118 free(path);119 return false;120 }121 122 /* Try to find its host controller. */123 if (!hc_found) {124 rc = usb_hc_find(dev_handle, &hc);125 if (rc == EOK) {126 hc_found = true;127 }128 }129 /* Try to get its address. */130 if (!addr_found) {131 addr = usb_device_get_assigned_address(dev_handle);132 if (addr >= 0) {133 addr_found = true;134 }135 }136 137 /* Speed-up. */138 if (hc_found && addr_found) {139 break;140 }141 142 /* Remove the last suffix. */143 char *slash_pos = str_rchr(path, '/');144 if (slash_pos != NULL) {145 *slash_pos = 0;146 }147 }148 149 free(path);150 151 if (hc_found && addr_found) {152 if (out_hc_handle != NULL) {153 *out_hc_handle = hc;154 }155 if (out_device_address != NULL) {156 *out_device_address = addr;157 }158 return true;159 } else {160 return false;161 }162 }163 48 164 49 static void print_usage(char *app_name) … … 300 185 devman_handle_t hc_handle = 0; 301 186 usb_address_t dev_addr = 0; 302 bool found = resolve_hc_handle_and_dev_addr(devpath,303 &hc_handle, &dev_addr );304 if ( !found) {187 int rc = usb_resolve_device_handle(devpath, 188 &hc_handle, &dev_addr, NULL); 189 if (rc != EOK) { 305 190 fprintf(stderr, NAME ": device `%s' not found " 306 191 "or not of USB kind, skipping.\n", -
uspace/drv/ohci/hc.c
rfa8d346 r8d3f198 565 565 bzero(&instance->rh, sizeof(instance->rh)); 566 566 /* Init queues */ 567 hc_init_transfer_lists(instance); 567 const int ret = hc_init_transfer_lists(instance); 568 if (ret != EOK) { 569 return ret; 570 } 568 571 569 572 /*Init HCCA */ -
uspace/drv/uhci-hcd/Makefile
rfa8d346 r8d3f198 48 48 root_hub.c \ 49 49 hw_struct/transfer_descriptor.c \ 50 utils/slab.c \51 50 pci.c \ 52 51 batch.c -
uspace/drv/uhci-hcd/batch.h
rfa8d346 r8d3f198 35 35 #define DRV_UHCI_BATCH_H 36 36 37 #include <usbhc_iface.h>38 #include <usb/usb.h>39 #include <usb/host/device_keeper.h>40 #include <usb/host/endpoint.h>41 37 #include <usb/host/batch.h> 42 38 -
uspace/drv/uhci-hcd/hc.c
rfa8d346 r8d3f198 39 39 #include <usb/debug.h> 40 40 #include <usb/usb.h> 41 #include <usb/ddfiface.h>42 #include <usb_iface.h>43 41 44 42 #include "hc.h" … … 85 83 /* allow access to hc control registers */ 86 84 regs_t *io; 87 ret = pio_enable(regs, reg_size, (void **)&io);85 ret = pio_enable(regs, reg_size, (void **)&io); 88 86 CHECK_RET_RETURN(ret, 89 87 "Failed(%d) to gain access to registers at %p: %s.\n", … … 143 141 } 144 142 145 uint16_t status = pio_read_16(®isters->usbcmd);143 const uint16_t status = pio_read_16(®isters->usbcmd); 146 144 if (status != 0) 147 145 usb_log_warning("Previous command value: %x.\n", status); … … 212 210 /* Init USB frame list page*/ 213 211 instance->frame_list = get_page(); 214 ret = instance ? EOK : ENOMEM;212 ret = instance->frame_list ? EOK : ENOMEM; 215 213 CHECK_RET_RETURN(ret, "Failed to get frame list page.\n"); 216 214 usb_log_debug("Initialized frame list at %p.\n", instance->frame_list); … … 277 275 &instance->transfers_control_slow); 278 276 279 /*FSBR*/ 277 /*FSBR, This feature is not needed (adds no benefit) and is supposedly 278 * buggy on certain hw, enable at your own risk. */ 280 279 #ifdef FSBR 281 280 transfer_list_set_next(&instance->transfers_bulk_full, … … 428 427 } 429 428 430 uintptr_t frame_list =429 const uintptr_t frame_list = 431 430 pio_read_32(&instance->registers->flbaseadd) & ~0xfff; 432 431 if (frame_list != addr_to_phys(instance->frame_list)) { -
uspace/drv/uhci-hcd/hc.h
rfa8d346 r8d3f198 37 37 38 38 #include <fibril.h> 39 #include <fibril_synch.h>40 #include <adt/list.h>41 39 #include <ddi.h> 42 40 43 #include <usbhc_iface.h>44 41 #include <usb/host/device_keeper.h> 45 42 #include <usb/host/usb_endpoint_manager.h> 43 #include <usb/host/batch.h> 46 44 47 #include "batch.h"48 45 #include "transfer_list.h" 49 46 … … 154 151 */ 155 152 static inline hc_t * fun_to_hc(ddf_fun_t *fun) 156 { return (hc_t*)fun->driver_data; } 153 { 154 assert(fun); 155 return fun->driver_data; 156 } 157 157 #endif 158 158 /** -
uspace/drv/uhci-hcd/iface.c
rfa8d346 r8d3f198 39 39 40 40 #include "iface.h" 41 #include "batch.h" 41 42 #include "hc.h" 42 43 … … 122 123 return EOK; 123 124 } 124 125 /*----------------------------------------------------------------------------*/ 125 126 /** Find device handle by address interface function. 126 127 * … … 136 137 hc_t *hc = fun_to_hc(fun); 137 138 assert(hc); 138 bool found =139 const bool found = 139 140 usb_device_keeper_find_by_address(&hc->manager, address, handle); 140 141 return found ? EOK : ENOENT; 141 142 } 142 143 143 /*----------------------------------------------------------------------------*/ 144 144 /** Release address interface function … … 164 164 size_t max_packet_size, unsigned int interval) 165 165 { 166 assert(fun); 166 167 hc_t *hc = fun_to_hc(fun); 167 168 assert(hc); … … 183 184 usb_endpoint_t endpoint, usb_direction_t direction) 184 185 { 186 assert(fun); 185 187 hc_t *hc = fun_to_hc(fun); 186 188 assert(hc); … … 211 213 if (ret != EOK) 212 214 return ret; 215 assert(batch); 216 assert(hc); 213 217 batch_interrupt_out(batch); 214 218 ret = hc_schedule(hc, batch); … … 239 243 if (ret != EOK) 240 244 return ret; 245 assert(batch); 246 assert(hc); 241 247 batch_interrupt_in(batch); 242 248 ret = hc_schedule(hc, batch); … … 267 273 if (ret != EOK) 268 274 return ret; 275 assert(batch); 276 assert(hc); 269 277 batch_bulk_out(batch); 270 278 ret = hc_schedule(hc, batch); … … 295 303 if (ret != EOK) 296 304 return ret; 305 assert(batch); 306 assert(hc); 297 307 batch_bulk_in(batch); 298 308 ret = hc_schedule(hc, batch); … … 327 337 if (ret != EOK) 328 338 return ret; 339 assert(batch); 340 assert(hc); 329 341 usb_endpoint_manager_reset_if_need(&hc->ep_manager, target, setup_data); 330 342 batch_control_write(batch); … … 360 372 if (ret != EOK) 361 373 return ret; 374 assert(batch); 375 assert(hc); 362 376 batch_control_read(batch); 363 377 ret = hc_schedule(hc, batch); -
uspace/drv/uhci-hcd/pci.c
rfa8d346 r8d3f198 52 52 * @return Error code. 53 53 */ 54 int pci_get_my_registers( ddf_dev_t *dev,54 int pci_get_my_registers(const ddf_dev_t *dev, 55 55 uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no) 56 56 { 57 assert(dev != NULL); 57 assert(dev); 58 assert(io_reg_address); 59 assert(io_reg_size); 60 assert(irq_no); 58 61 59 62 int parent_phone = … … 66 69 int rc = hw_res_get_resource_list(parent_phone, &hw_resources); 67 70 if (rc != EOK) { 68 goto leave; 71 async_hangup(parent_phone); 72 return rc; 69 73 } 70 74 … … 78 82 size_t i; 79 83 for (i = 0; i < hw_resources.count; i++) { 80 hw_resource_t *res = &hw_resources.resources[i];84 const hw_resource_t *res = &hw_resources.resources[i]; 81 85 switch (res->type) 82 86 { … … 99 103 } 100 104 } 105 async_hangup(parent_phone); 101 106 102 if (!io_found || !irq_found) { 103 rc = ENOENT; 104 goto leave; 105 } 107 if (!io_found || !irq_found) 108 return ENOENT; 106 109 107 110 *io_reg_address = io_address; … … 109 112 *irq_no = irq; 110 113 111 rc = EOK; 112 leave: 113 async_hangup(parent_phone); 114 return rc; 114 return EOK; 115 115 } 116 116 /*----------------------------------------------------------------------------*/ … … 120 120 * @return Error code. 121 121 */ 122 int pci_enable_interrupts( ddf_dev_t *device)122 int pci_enable_interrupts(const ddf_dev_t *device) 123 123 { 124 int parent_phone = devman_parent_device_connect(device->handle, 125 IPC_FLAG_BLOCKING); 126 bool enabled = hw_res_enable_interrupt(parent_phone); 124 const int parent_phone = 125 devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING); 126 if (parent_phone < 0) { 127 return parent_phone; 128 } 129 const bool enabled = hw_res_enable_interrupt(parent_phone); 127 130 async_hangup(parent_phone); 128 131 return enabled ? EOK : EIO; … … 134 137 * @return Error code. 135 138 */ 136 int pci_disable_legacy( ddf_dev_t *device)139 int pci_disable_legacy(const ddf_dev_t *device) 137 140 { 138 141 assert(device); 139 int parent_phone =142 const int parent_phone = 140 143 devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING); 141 144 if (parent_phone < 0) { … … 145 148 /* See UHCI design guide for these values p.45, 146 149 * write all WC bits in USB legacy register */ 147 sysarg_t address = 0xc0;148 sysarg_t value = 0xaf00;150 const sysarg_t address = 0xc0; 151 const sysarg_t value = 0xaf00; 149 152 150 int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),153 const int rc = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE), 151 154 IPC_M_CONFIG_SPACE_WRITE_16, address, value); 152 155 async_hangup(parent_phone); -
uspace/drv/uhci-hcd/pci.h
rfa8d346 r8d3f198 38 38 #include <ddf/driver.h> 39 39 40 int pci_get_my_registers( ddf_dev_t *, uintptr_t *, size_t *, int *);41 int pci_enable_interrupts( ddf_dev_t *);42 int pci_disable_legacy( ddf_dev_t *);40 int pci_get_my_registers(const ddf_dev_t *, uintptr_t *, size_t *, int *); 41 int pci_enable_interrupts(const ddf_dev_t *); 42 int pci_disable_legacy(const ddf_dev_t *); 43 43 44 44 #endif -
uspace/drv/uhci-hcd/root_hub.c
rfa8d346 r8d3f198 60 60 return ret; 61 61 } 62 assert(match_str); 62 63 63 64 ret = ddf_fun_add_match_id(fun, match_str, 100); -
uspace/drv/uhci-hcd/root_hub.h
rfa8d346 r8d3f198 43 43 /** List of resources available to the root hub. */ 44 44 hw_resource_list_t resource_list; 45 /** The only resource in the above list */45 /** The only resource in the RH resource list */ 46 46 hw_resource_t io_regs; 47 47 } rh_t; -
uspace/drv/uhci-hcd/transfer_list.c
rfa8d346 r8d3f198 36 36 #include <arch/barrier.h> 37 37 38 38 39 #include "transfer_list.h" 40 #include "batch.h" 39 41 40 42 static void transfer_list_remove_batch( … … 58 60 return ENOMEM; 59 61 } 60 uint32_t queue_head_pa = addr_to_phys(instance->queue_head);62 const uint32_t queue_head_pa = addr_to_phys(instance->queue_head); 61 63 usb_log_debug2("Transfer list %s setup with QH: %p (%#" PRIx32" ).\n", 62 64 name, instance->queue_head, queue_head_pa); … … 90 92 { 91 93 assert(instance); 94 assert(instance->queue_head); 92 95 assert(next); 93 if (!instance->queue_head)94 return;95 96 /* Set queue_head.next to point to the follower */ 96 97 qh_set_next_qh(instance->queue_head, next->queue_head); … … 137 138 write_barrier(); 138 139 139 /* Add to the driver list */140 /* Add to the driver's list */ 140 141 list_append(&batch->link, &instance->batch_list); 141 142 … … 160 161 link_t *current = instance->batch_list.next; 161 162 while (current != &instance->batch_list) { 162 link_t * next = current->next;163 link_t * const next = current->next; 163 164 usb_transfer_batch_t *batch = 164 165 usb_transfer_batch_from_link(current); … … 182 183 fibril_mutex_lock(&instance->guard); 183 184 while (!list_empty(&instance->batch_list)) { 184 link_t * current = instance->batch_list.next;185 link_t * const current = instance->batch_list.next; 185 186 usb_transfer_batch_t *batch = 186 187 usb_transfer_batch_from_link(current); -
uspace/drv/uhci-hcd/transfer_list.h
rfa8d346 r8d3f198 36 36 37 37 #include <fibril_synch.h> 38 #include <usb/host/batch.h> 38 39 39 #include "batch.h"40 40 #include "hw_struct/queue_head.h" 41 41 -
uspace/drv/uhci-hcd/uhci.c
rfa8d346 r8d3f198 77 77 { 78 78 assert(dev); 79 hc_t *hc = &((uhci_t*)dev->driver_data)->hc; 79 uhci_t *uhci = dev->driver_data; 80 assert(uhci); 81 hc_t *hc = &uhci->hc; 80 82 uint16_t status = IPC_GET_ARG1(*call); 81 83 assert(hc); … … 144 146 { 145 147 assert(fun); 146 return &((rh_t*)fun->driver_data)->resource_list; 148 rh_t *rh = fun->driver_data; 149 assert(rh); 150 return &rh->resource_list; 147 151 } 148 152 /*----------------------------------------------------------------------------*/ -
uspace/drv/uhci-hcd/uhci.h
rfa8d346 r8d3f198 35 35 #ifndef DRV_UHCI_UHCI_H 36 36 #define DRV_UHCI_UHCI_H 37 #include <ddi.h>38 37 #include <ddf/driver.h> 39 38 -
uspace/drv/uhci-hcd/utils/malloc32.h
rfa8d346 r8d3f198 41 41 #include <as.h> 42 42 43 #include "slab.h"44 45 43 #define UHCI_STRCUTURES_ALIGNMENT 16 46 44 #define UHCI_REQUIRED_PAGE_SIZE 4096 … … 59 57 uintptr_t result; 60 58 const int ret = as_get_physical_mapping(addr, &result); 61 assert(ret == EOK);62 63 59 if (ret != EOK) 64 60 return 0; … … 72 68 */ 73 69 static inline void * malloc32(size_t size) { 74 if (size <= SLAB_ELEMENT_SIZE) 75 return slab_malloc_g(); 76 usb_log_warning("Requested %zu bytes, current allocator can't handle " 77 "that amount, pray that the standard malloc will suffice.", size); 78 return memalign(UHCI_STRCUTURES_ALIGNMENT, size); 70 /* This works only when the host has less than 4GB of memory as 71 * physical address needs to fit into 32 bits */ 72 73 /* If we need more than one page there is no guarantee that the 74 * memory will be continuous */ 75 if (size > PAGE_SIZE) 76 return NULL; 77 /* Calculate alignment to make sure the block won't cross page 78 * boundary */ 79 size_t alignment = UHCI_STRCUTURES_ALIGNMENT; 80 while (alignment < size) 81 alignment *= 2; 82 return memalign(alignment, size); 79 83 } 80 84 /*----------------------------------------------------------------------------*/ … … 86 90 if (!addr) 87 91 return; 88 if (slab_in_range_g(addr))89 return slab_free_g(addr);90 92 free(addr); 91 93 } … … 98 100 { 99 101 void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE); 100 assert(free_address); /* TODO: remove this assert */101 102 if (free_address == 0) 102 103 return NULL; -
uspace/drv/uhci-rhd/main.c
rfa8d346 r8d3f198 37 37 #include <errno.h> 38 38 #include <str_error.h> 39 39 40 #include <usb_iface.h> 40 41 #include <usb/ddfiface.h> … … 45 46 #define NAME "uhci-rhd" 46 47 47 static int hc_get_my_registers( ddf_dev_t *dev,48 static int hc_get_my_registers(const ddf_dev_t *dev, 48 49 uintptr_t *io_reg_address, size_t *io_reg_size); 49 50 /*----------------------------------------------------------------------------*/ … … 130 131 */ 131 132 int hc_get_my_registers( 132 ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)133 const ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size) 133 134 { 134 assert(dev != NULL);135 assert(dev); 135 136 136 int parent_phone = devman_parent_device_connect(dev->handle,137 const int parent_phone = devman_parent_device_connect(dev->handle, 137 138 IPC_FLAG_BLOCKING); 138 139 if (parent_phone < 0) { … … 141 142 142 143 hw_resource_list_t hw_resources; 143 int ret = hw_res_get_resource_list(parent_phone, &hw_resources);144 const int ret = hw_res_get_resource_list(parent_phone, &hw_resources); 144 145 if (ret != EOK) { 145 146 async_hangup(parent_phone); -
uspace/drv/uhci-rhd/port.c
rfa8d346 r8d3f198 36 36 #include <errno.h> 37 37 #include <str_error.h> 38 #include <time.h>39 38 #include <async.h> 40 39 … … 82 81 * @param[in] number Port number. 83 82 * @param[in] usec Polling interval. 84 * @param[in] rh Pointer to ddf instance fothe root hub driver.83 * @param[in] rh Pointer to ddf instance of the root hub driver. 85 84 * @return Error code. 86 85 * … … 91 90 { 92 91 assert(port); 93 asprintf(&port->id_string, "Port (%p - %u)", port, number); 94 if (port->id_string == NULL) { 92 char *id_string; 93 asprintf(&id_string, "Port (%p - %u)", port, number); 94 if (id_string == NULL) { 95 95 return ENOMEM; 96 96 } 97 97 98 port->id_string = id_string; 98 99 port->address = address; 99 100 port->number = number; … … 105 106 usb_hc_connection_initialize_from_device(&port->hc_connection, rh); 106 107 if (ret != EOK) { 107 usb_log_error("Failed to initialize connection to HC."); 108 usb_log_error("%s: failed to initialize connection to HC.", 109 port->id_string); 110 free(id_string); 108 111 return ret; 109 112 } … … 113 116 usb_log_error("%s: failed to create polling fibril.", 114 117 port->id_string); 118 free(id_string); 115 119 return ENOMEM; 116 120 } … … 132 136 assert(port); 133 137 free(port->id_string); 134 / * TODO: Kill fibril here */138 // TODO: Kill fibril here 135 139 return; 136 140 } … … 150 154 151 155 /* Read register value */ 152 port_status_t port_status = uhci_port_read_status(instance); 156 const port_status_t port_status = 157 uhci_port_read_status(instance); 153 158 154 159 /* Print the value if it's interesting */ … … 161 166 usb_log_debug("%s: Connected change detected: %x.\n", 162 167 instance->id_string, port_status); 163 164 int rc =165 usb_hc_connection_open(&instance->hc_connection);166 if (rc != EOK) {167 usb_log_error("%s: Failed to connect to HC.",168 instance->id_string);169 continue;170 }171 168 172 169 /* Remove any old device */ … … 175 172 instance->id_string); 176 173 uhci_port_remove_device(instance); 174 } 175 176 int ret = 177 usb_hc_connection_open(&instance->hc_connection); 178 if (ret != EOK) { 179 usb_log_error("%s: Failed to connect to HC.", 180 instance->id_string); 181 continue; 177 182 } 178 183 … … 190 195 } 191 196 192 r c= usb_hc_connection_close(&instance->hc_connection);193 if (r c!= EOK) {197 ret = usb_hc_connection_close(&instance->hc_connection); 198 if (ret != EOK) { 194 199 usb_log_error("%s: Failed to disconnect.", 195 200 instance->id_string); … … 209 214 int uhci_port_reset_enable(int portno, void *arg) 210 215 { 211 uhci_port_t *port = (uhci_port_t *) arg; 216 uhci_port_t *port = arg; 217 assert(port); 212 218 213 219 usb_log_debug2("%s: new_device_enable_port.\n", port->id_string); … … 283 289 usb_log_error("%s: Don't know how to remove device %" PRIun ".\n", 284 290 port->id_string, port->attached_device); 291 port->attached_device = 0; 285 292 return ENOTSUP; 286 293 } -
uspace/drv/uhci-rhd/port.h
rfa8d346 r8d3f198 38 38 #include <fibril.h> 39 39 #include <ddf/driver.h> 40 #include <usb/ dev/hc.h> /* usb_hc_connection_t */40 #include <usb/hc.h> /* usb_hc_connection_t */ 41 41 42 42 typedef uint16_t port_status_t; … … 57 57 typedef struct uhci_port 58 58 { 59 c har *id_string;59 const char *id_string; 60 60 port_status_t *address; 61 61 unsigned number; -
uspace/lib/usb/Makefile
rfa8d346 r8d3f198 37 37 src/ddfiface.c \ 38 38 src/debug.c \ 39 src/driver.c \40 39 src/dump.c \ 41 src/host.c \ 40 src/hc.c \ 41 src/resolve.c \ 42 42 src/usb.c 43 43 -
uspace/lib/usb/include/usb/hc.h
rfa8d346 r8d3f198 27 27 */ 28 28 29 /** @addtogroup libusb dev29 /** @addtogroup libusb 30 30 * @{ 31 31 */ 32 32 /** @file 33 * General communication between device drivers andhost controller driver.33 * General communication with host controller driver. 34 34 */ 35 #ifndef LIBUSB DEV_HC_H_36 #define LIBUSB DEV_HC_H_35 #ifndef LIBUSB_HC_H_ 36 #define LIBUSB_HC_H_ 37 37 38 38 #include <sys/types.h> … … 57 57 bool usb_hc_connection_is_opened(const usb_hc_connection_t *); 58 58 int usb_hc_connection_close(usb_hc_connection_t *); 59 int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t, 60 devman_handle_t *); 59 61 62 int usb_hc_get_address_by_handle(devman_handle_t); 63 64 int usb_hc_find(devman_handle_t, devman_handle_t *); 65 66 int usb_resolve_device_handle(const char *, devman_handle_t *, usb_address_t *, 67 devman_handle_t *); 68 69 int usb_ddf_get_hc_handle_by_class(size_t, devman_handle_t *); 60 70 61 71 -
uspace/lib/usb/src/ddfiface.c
rfa8d346 r8d3f198 37 37 #include <async.h> 38 38 #include <usb/ddfiface.h> 39 #include <usb/ driver.h>39 #include <usb/hc.h> 40 40 #include <usb/debug.h> 41 41 #include <errno.h> -
uspace/lib/usb/src/hc.c
rfa8d346 r8d3f198 27 27 */ 28 28 29 /** @addtogroup libusb dev29 /** @addtogroup libusb 30 30 * @{ 31 31 */ 32 32 /** @file 33 * General communication between device drivers and host controller driver.33 * General communication with host controller driver (implementation). 34 34 */ 35 35 #include <devman.h> 36 36 #include <async.h> 37 #include <dev_iface.h> 37 38 #include <usb_iface.h> 38 #include <usb /dev/hc.h>39 #include <usb/ driver.h>39 #include <usbhc_iface.h> 40 #include <usb/hc.h> 40 41 #include <usb/debug.h> 41 42 #include <errno.h> … … 143 144 } 144 145 146 /** Get handle of USB device with given address. 147 * 148 * @param[in] connection Opened connection to host controller. 149 * @param[in] address Address of device in question. 150 * @param[out] handle Where to write the device handle. 151 * @return Error code. 152 */ 153 int usb_hc_get_handle_by_address(usb_hc_connection_t *connection, 154 usb_address_t address, devman_handle_t *handle) 155 { 156 if (!usb_hc_connection_is_opened(connection)) { 157 return ENOENT; 158 } 159 160 sysarg_t tmp; 161 int rc = async_req_2_1(connection->hc_phone, 162 DEV_IFACE_ID(USBHC_DEV_IFACE), 163 IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, 164 address, &tmp); 165 if ((rc == EOK) && (handle != NULL)) { 166 *handle = tmp; 167 } 168 169 return rc; 170 } 171 172 /** Tell USB address assigned to device with given handle. 173 * 174 * @param dev_handle Devman handle of the USB device in question. 175 * @return USB address or negative error code. 176 */ 177 usb_address_t usb_hc_get_address_by_handle(devman_handle_t dev_handle) 178 { 179 int parent_phone = devman_parent_device_connect(dev_handle, 180 IPC_FLAG_BLOCKING); 181 if (parent_phone < 0) { 182 return parent_phone; 183 } 184 185 sysarg_t address; 186 187 int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), 188 IPC_M_USB_GET_ADDRESS, 189 dev_handle, &address); 190 191 if (rc != EOK) { 192 return rc; 193 } 194 195 async_hangup(parent_phone); 196 197 return (usb_address_t) address; 198 } 199 200 201 /** Get host controller handle by its class index. 202 * 203 * @param class_index Class index for the host controller. 204 * @param hc_handle Where to store the HC handle 205 * (can be NULL for existence test only). 206 * @return Error code. 207 */ 208 int usb_ddf_get_hc_handle_by_class(size_t class_index, 209 devman_handle_t *hc_handle) 210 { 211 char *class_index_str; 212 devman_handle_t hc_handle_tmp; 213 int rc; 214 215 rc = asprintf(&class_index_str, "%zu", class_index); 216 if (rc < 0) { 217 return ENOMEM; 218 } 219 rc = devman_device_get_handle_by_class("usbhc", class_index_str, 220 &hc_handle_tmp, 0); 221 free(class_index_str); 222 if (rc != EOK) { 223 return rc; 224 } 225 226 if (hc_handle != NULL) { 227 *hc_handle = hc_handle_tmp; 228 } 229 230 return EOK; 231 } 232 233 /** Find host controller handle that is ancestor of given device. 234 * 235 * @param[in] device_handle Device devman handle. 236 * @param[out] hc_handle Where to store handle of host controller 237 * controlling device with @p device_handle handle. 238 * @return Error code. 239 */ 240 int usb_hc_find(devman_handle_t device_handle, devman_handle_t *hc_handle) 241 { 242 int parent_phone = devman_parent_device_connect(device_handle, 243 IPC_FLAG_BLOCKING); 244 if (parent_phone < 0) { 245 return parent_phone; 246 } 247 248 devman_handle_t h; 249 int rc = async_req_1_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE), 250 IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h); 251 252 async_hangup(parent_phone); 253 254 if (rc != EOK) { 255 return rc; 256 } 257 258 if (hc_handle != NULL) { 259 *hc_handle = h; 260 } 261 262 return EOK; 263 } 264 145 265 /** 146 266 * @} -
uspace/lib/usbdev/Makefile
rfa8d346 r8d3f198 46 46 src/pipesio.c \ 47 47 src/recognise.c \ 48 src/request.c \ 49 src/usbdevice.c 48 src/request.c 50 49 51 50 include $(USPACE_PREFIX)/Makefile.common -
uspace/lib/usbdev/include/usb/dev/hub.h
rfa8d346 r8d3f198 39 39 40 40 #include <sys/types.h> 41 #include <usb/ dev/hc.h>41 #include <usb/hc.h> 42 42 43 43 int usb_hc_new_device_wrapper(ddf_dev_t *, usb_hc_connection_t *, usb_speed_t, … … 63 63 const usb_hc_attached_device_t *); 64 64 int usb_hc_unregister_device(usb_hc_connection_t *, usb_address_t); 65 int usb_hc_get_handle_by_address(usb_hc_connection_t *, usb_address_t,66 devman_handle_t *);67 65 68 66 #endif -
uspace/lib/usbdev/include/usb/dev/pipes.h
rfa8d346 r8d3f198 38 38 #include <sys/types.h> 39 39 #include <usb/usb.h> 40 #include <usb/ dev/hc.h>40 #include <usb/hc.h> 41 41 #include <usb/descriptor.h> 42 42 #include <ipc/devman.h> … … 163 163 164 164 int usb_device_get_assigned_interface(ddf_dev_t *); 165 usb_address_t usb_device_get_assigned_address(devman_handle_t);166 165 167 166 int usb_pipe_initialize(usb_pipe_t *, usb_device_connection_t *, -
uspace/lib/usbdev/src/hub.c
rfa8d346 r8d3f198 120 120 } 121 121 122 /** Get handle of USB device with given address.123 *124 * @param[in] connection Opened connection to host controller.125 * @param[in] address Address of device in question.126 * @param[out] handle Where to write the device handle.127 * @return Error code.128 */129 int usb_hc_get_handle_by_address(usb_hc_connection_t *connection,130 usb_address_t address, devman_handle_t *handle)131 {132 CHECK_CONNECTION(connection);133 134 sysarg_t tmp;135 int rc = async_req_2_1(connection->hc_phone,136 DEV_IFACE_ID(USBHC_DEV_IFACE),137 IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,138 address, &tmp);139 if ((rc == EOK) && (handle != NULL)) {140 *handle = tmp;141 }142 143 return rc;144 }145 122 146 123 static void unregister_control_endpoint_on_default_address( -
uspace/lib/usbdev/src/pipes.c
rfa8d346 r8d3f198 36 36 #include <usb/dev/pipes.h> 37 37 #include <usb/debug.h> 38 #include <usb/ driver.h>38 #include <usb/hc.h> 39 39 #include <usbhc_iface.h> 40 40 #include <usb_iface.h> … … 97 97 98 98 return (int) iface_no; 99 }100 101 /** Tell USB address assigned to given device.102 *103 * @param dev_handle Devman handle of the USB device in question.104 * @return USB address or negative error code.105 */106 usb_address_t usb_device_get_assigned_address(devman_handle_t dev_handle)107 {108 int parent_phone = devman_parent_device_connect(dev_handle,109 IPC_FLAG_BLOCKING);110 if (parent_phone < 0) {111 return parent_phone;112 }113 114 sysarg_t address;115 116 int rc = async_req_2_1(parent_phone, DEV_IFACE_ID(USB_DEV_IFACE),117 IPC_M_USB_GET_ADDRESS,118 dev_handle, &address);119 120 if (rc != EOK) {121 return rc;122 }123 124 async_hangup(parent_phone);125 126 return (usb_address_t) address;127 99 } 128 100 -
uspace/lib/usbhid/include/usb/hid/hid_report_items.h
rfa8d346 r8d3f198 27 27 */ 28 28 29 /** @addtogroup libusb hid29 /** @addtogroup libusb 30 30 * @{ 31 31 */ 32 32 /** @file 33 * @brief USB HID parser.34 */ 35 #ifndef LIBUSB HID_HID_REPORT_ITEMS_H_36 #define LIBUSB HID_HID_REPORT_ITEMS_H_33 * @brief USB HID Report descriptor item tags. 34 */ 35 #ifndef LIBUSB_HID_REPORT_ITEMS_H_ 36 #define LIBUSB_HID_REPORT_ITEMS_H_ 37 37 38 38 #include <stdint.h> 39 39 40 /** 40 /*---------------------------------------------------------------------------*/ 41 /* 41 42 * Item prefix 42 43 */ 44 45 /** Returns size of item data in bytes */ 43 46 #define USB_HID_ITEM_SIZE(data) ((uint8_t)(data & 0x3)) 47 48 /** Returns item tag */ 44 49 #define USB_HID_ITEM_TAG(data) ((uint8_t)((data & 0xF0) >> 4)) 50 51 /** Returns class of item tag */ 45 52 #define USB_HID_ITEM_TAG_CLASS(data) ((uint8_t)((data & 0xC) >> 2)) 53 54 /** Returns if the item is the short item or long item. Long items are not 55 * supported. */ 46 56 #define USB_HID_ITEM_IS_LONG(data) (data == 0xFE) 47 57 48 49 /* *58 /*---------------------------------------------------------------------------*/ 59 /* 50 60 * Extended usage macros 51 61 */ 62 63 /** Recognizes if the given usage is extended (contains also usage page). */ 52 64 #define USB_HID_IS_EXTENDED_USAGE(usage) ((usage & 0xFFFF0000) != 0) 65 66 /** Cuts usage page of the extended usage. */ 53 67 #define USB_HID_EXTENDED_USAGE_PAGE(usage) ((usage & 0xFFFF0000) >> 16) 68 69 /** Cuts usage of the extended usage */ 54 70 #define USB_HID_EXTENDED_USAGE(usage) (usage & 0xFFFF) 55 71 56 /** 72 /*---------------------------------------------------------------------------*/ 73 /* 57 74 * Input/Output/Feature Item flags 58 75 */ 59 /** Constant (1) / Variable (0) */ 76 /** 77 * Indicates whether the item is data (0) or a constant (1) value. Data 78 * indicates the item is defining report fields that contain modifiable device 79 * data. Constant indicates the item is a static read-only field in a report 80 * and cannot be modified (written) by the host. 81 */ 60 82 #define USB_HID_ITEM_FLAG_CONSTANT(flags) ((flags & 0x1) == 0x1) 61 /** Variable (1) / Array (0) */ 83 84 /** 85 * Indicates whether the item creates variable (1) or array (0) data fields in 86 * reports. 87 */ 62 88 #define USB_HID_ITEM_FLAG_VARIABLE(flags) ((flags & 0x2) == 0x2) 63 /** Absolute / Relative*/ 89 90 /** 91 * Indicates whether the data is absolute (0) (based on a fixed origin) or 92 * relative (1) (indicating the change in value from the last report). Mouse 93 * devices usually provide relative data, while tablets usually provide 94 * absolute data. 95 */ 64 96 #define USB_HID_ITEM_FLAG_RELATIVE(flags) ((flags & 0x4) == 0x4) 65 /** Wrap / No Wrap */ 97 98 /** 99 * Indicates whether the data “rolls over” when reaching either the extreme 100 * high or low value. For example, a dial that can spin freely 360 degrees 101 * might output values from 0 to 10. If Wrap is indicated, the next value 102 * reported after passing the 10 position in the increasing direction would be 103 * 0. 104 */ 66 105 #define USB_HID_ITEM_FLAG_WRAP(flags) ((flags & 0x8) == 0x8) 106 107 /** 108 * Indicates whether the raw data from the device has been processed in some 109 * way, and no longer represents a linear relationship between what is 110 * measured and the data that is reported. 111 */ 67 112 #define USB_HID_ITEM_FLAG_LINEAR(flags) ((flags & 0x10) == 0x10) 113 114 /** 115 * Indicates whether the control has a preferred state to which it will return 116 * when the user is not physically interacting with the control. Push buttons 117 * (as opposed to toggle buttons) and self- centering joysticks are examples. 118 */ 68 119 #define USB_HID_ITEM_FLAG_PREFERRED(flags) ((flags & 0x20) == 0x20) 120 121 /** 122 * Indicates whether the control has a state in which it is not sending 123 * meaningful data. One possible use of the null state is for controls that 124 * require the user to physically interact with the control in order for it to 125 * report useful data. 126 */ 69 127 #define USB_HID_ITEM_FLAG_POSITION(flags) ((flags & 0x40) == 0x40) 128 129 /** 130 * Indicates whether the Feature or Output control's value should be changed 131 * by the host or not. Volatile output can change with or without host 132 * interaction. To avoid synchronization problems, volatile controls should be 133 * relative whenever possible. 134 */ 70 135 #define USB_HID_ITEM_FLAG_VOLATILE(flags) ((flags & 0x80) == 0x80) 136 137 /** 138 * Indicates that the control emits a fixed-size stream of bytes. The contents 139 * of the data field are determined by the application. The contents of the 140 * buffer are not interpreted as a single numeric quantity. Report data 141 * defined by a Buffered Bytes item must be aligned on an 8-bit boundary. 142 */ 71 143 #define USB_HID_ITEM_FLAG_BUFFERED(flags) ((flags & 0x100) == 0x100) 72 144 145 /*---------------------------------------------------------------------------*/ 146 73 147 /* MAIN ITEMS */ 74 #define USB_HID_TAG_CLASS_MAIN 0x0 75 #define USB_HID_REPORT_TAG_INPUT 0x8 76 #define USB_HID_REPORT_TAG_OUTPUT 0x9 77 #define USB_HID_REPORT_TAG_FEATURE 0xB 148 149 /** 150 * Main items are used to either define or group certain types of data fields 151 * within a Report descriptor. 152 */ 153 #define USB_HID_TAG_CLASS_MAIN 0x0 154 155 /** 156 * An Input item describes information about the data provided by one or more 157 * physical controls. An application can use this information to interpret the 158 * data provided by the device. All data fields defined in a single item share 159 * an identical data format. 160 */ 161 #define USB_HID_REPORT_TAG_INPUT 0x8 162 163 /** 164 * The Output item is used to define an output data field in a report. This 165 * item is similar to an Input item except it describes data sent to the 166 * device—for example, LED states. 167 */ 168 #define USB_HID_REPORT_TAG_OUTPUT 0x9 169 170 /** 171 * Feature items describe device configuration information that can be sent to 172 * the device. 173 */ 174 #define USB_HID_REPORT_TAG_FEATURE 0xB 175 176 /** 177 * A Collection item identifies a relationship between two or more data 178 * (Input, Output, or Feature.) 179 */ 78 180 #define USB_HID_REPORT_TAG_COLLECTION 0xA 181 182 /** 183 * While the Collection item opens a collection of data, the End Collection 184 * item closes a collection. 185 */ 79 186 #define USB_HID_REPORT_TAG_END_COLLECTION 0xC 80 187 188 /*---------------------------------------------------------------------------*/ 189 81 190 /* GLOBAL ITEMS */ 82 #define USB_HID_TAG_CLASS_GLOBAL 0x1 191 192 /** 193 * Global items describe rather than define data from a control. 194 */ 195 #define USB_HID_TAG_CLASS_GLOBAL 0x1 196 197 /** 198 * Unsigned integer specifying the current Usage Page. Since a usage are 32 199 * bit values, Usage Page items can be used to conserve space in a report 200 * descriptor by setting the high order 16 bits of a subsequent usages. Any 201 * usage that follows which is defines 16 bits or less is interpreted as a 202 * Usage ID and concatenated with the Usage Page to form a 32 bit Usage. 203 */ 83 204 #define USB_HID_REPORT_TAG_USAGE_PAGE 0x0 205 206 /** 207 * Extent value in logical units. This is the minimum value that a variable 208 * or array item will report. For example, a mouse reporting x position values 209 * from 0 to 128 would have a Logical Minimum of 0 and a Logical Maximum of 210 * 128. 211 */ 84 212 #define USB_HID_REPORT_TAG_LOGICAL_MINIMUM 0x1 213 214 /** 215 * Extent value in logical units. This is the maximum value that a variable 216 * or array item will report. 217 */ 85 218 #define USB_HID_REPORT_TAG_LOGICAL_MAXIMUM 0x2 86 #define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3 87 #define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4 219 220 /** 221 * Minimum value for the physical extent of a variable item. This represents 222 * the Logical Minimum with units applied to it. 223 */ 224 #define USB_HID_REPORT_TAG_PHYSICAL_MINIMUM 0x3 225 226 /** 227 * Maximum value for the physical extent of a variable item. 228 */ 229 #define USB_HID_REPORT_TAG_PHYSICAL_MAXIMUM 0x4 230 231 /** 232 * Value of the unit exponent in base 10. See the table later in this section 233 * for more information. 234 */ 88 235 #define USB_HID_REPORT_TAG_UNIT_EXPONENT 0x5 89 #define USB_HID_REPORT_TAG_UNIT 0x6 236 237 /** 238 * Unit values. 239 */ 240 #define USB_HID_REPORT_TAG_UNIT 0x6 241 242 /** 243 * Unsigned integer specifying the size of the report fields in bits. This 244 * allows the parser to build an item map for the report handler to use. 245 */ 90 246 #define USB_HID_REPORT_TAG_REPORT_SIZE 0x7 247 248 /** 249 * Unsigned value that specifies the Report ID. If a Report ID tag is used 250 * anywhere in Report descriptor, all data reports for the device are preceded 251 * by a single byte ID field. All items succeeding the first Report ID tag but 252 * preceding a second Report ID tag are included in a report prefixed by a 253 * 1-byte ID. All items succeeding the second but preceding a third Report ID 254 * tag are included in a second report prefixed by a second ID, and so on. 255 */ 91 256 #define USB_HID_REPORT_TAG_REPORT_ID 0x8 257 258 /** 259 * Unsigned integer specifying the number of data fields for the item; 260 * determines how many fields are included in the report for this particular 261 * item (and consequently how many bits are added to the report). 262 */ 92 263 #define USB_HID_REPORT_TAG_REPORT_COUNT 0x9 93 #define USB_HID_REPORT_TAG_PUSH 0xA 94 #define USB_HID_REPORT_TAG_POP 0xB 95 264 265 /** 266 * Places a copy of the global item state table on the stack. 267 */ 268 #define USB_HID_REPORT_TAG_PUSH 0xA 269 270 /** 271 * Replaces the item state table with the top structure from the stack. 272 */ 273 #define USB_HID_REPORT_TAG_POP 0xB 274 275 /*---------------------------------------------------------------------------*/ 96 276 97 277 /* LOCAL ITEMS */ 98 #define USB_HID_TAG_CLASS_LOCAL 0x2 99 #define USB_HID_REPORT_TAG_USAGE 0x0 100 #define USB_HID_REPORT_TAG_USAGE_MINIMUM 0x1 101 #define USB_HID_REPORT_TAG_USAGE_MAXIMUM 0x2 102 #define USB_HID_REPORT_TAG_DESIGNATOR_INDEX 0x3 278 279 /** 280 * Local item tags define characteristics of controls. These items do not 281 * carry over to the next Main item. If a Main item defines more than one 282 * control, it may be preceded by several similar Local item tags. For 283 * example, an Input item may have several Usage tags associated with it, one 284 * for each control. 285 */ 286 #define USB_HID_TAG_CLASS_LOCAL 0x2 287 288 /** 289 * Usage index for an item usage; represents a suggested usage for the item or 290 * collection. In the case where an item represents multiple controls, a Usage 291 * tag may suggest a usage for every variable or element in an array. 292 */ 293 #define USB_HID_REPORT_TAG_USAGE 0x0 294 295 /** 296 * Defines the starting usage associated with an array or bitmap. 297 */ 298 #define USB_HID_REPORT_TAG_USAGE_MINIMUM 0x1 299 300 /** 301 * Defines the ending usage associated with an array or bitmap. 302 */ 303 #define USB_HID_REPORT_TAG_USAGE_MAXIMUM 0x2 304 305 /** 306 * Determines the body part used for a control. Index points to a designator 307 * in the Physical descriptor. 308 */ 309 #define USB_HID_REPORT_TAG_DESIGNATOR_INDEX 0x3 310 311 /** 312 * Defines the index of the starting designator associated with an array or 313 * bitmap. 314 */ 103 315 #define USB_HID_REPORT_TAG_DESIGNATOR_MINIMUM 0x4 316 317 /** 318 * Defines the index of the ending designator associated with an array or 319 * bitmap. 320 */ 104 321 #define USB_HID_REPORT_TAG_DESIGNATOR_MAXIMUM 0x5 105 #define USB_HID_REPORT_TAG_STRING_INDEX 0x7 106 #define USB_HID_REPORT_TAG_STRING_MINIMUM 0x8 107 #define USB_HID_REPORT_TAG_STRING_MAXIMUM 0x9 108 #define USB_HID_REPORT_TAG_DELIMITER 0xA 322 323 /** 324 * String index for a String descriptor; allows a string to be associated with 325 * a particular item or control. 326 */ 327 #define USB_HID_REPORT_TAG_STRING_INDEX 0x7 328 329 /** 330 * Specifies the first string index when assigning a group of sequential 331 * strings to controls in an array or bitmap. 332 */ 333 #define USB_HID_REPORT_TAG_STRING_MINIMUM 0x8 334 335 /** 336 * Specifies the last string index when assigning a group of sequential 337 * strings to controls in an array or bitmap. 338 */ 339 #define USB_HID_REPORT_TAG_STRING_MAXIMUM 0x9 340 341 /** 342 * Defines the beginning or end of a set of local items (1 = open set, 0 = 343 * close set). 344 * 345 * Usages other than the first (most preferred) usage defined are not 346 * accessible by system software. 347 */ 348 #define USB_HID_REPORT_TAG_DELIMITER 0xA 349 350 /*---------------------------------------------------------------------------*/ 109 351 110 352 #endif -
uspace/lib/usbhid/include/usb/hid/hiddescriptor.h
rfa8d346 r8d3f198 27 27 */ 28 28 29 /** @addtogroup libusb hid29 /** @addtogroup libusb 30 30 * @{ 31 31 */ … … 33 33 * USB HID report descriptor and report data parser 34 34 */ 35 #ifndef LIBUSB HID_HIDDESCRIPTOR_H_36 #define LIBUSB HID_HIDDESCRIPTOR_H_35 #ifndef LIBUSB_HIDDESCRIPTOR_H_ 36 #define LIBUSB_HIDDESCRIPTOR_H_ 37 37 38 38 #include <stdint.h> … … 42 42 #include <usb/hid/hidtypes.h> 43 43 44 45 /*46 * Descriptor parser functions47 */48 49 /** */50 44 int usb_hid_parse_report_descriptor(usb_hid_report_t *report, 51 45 const uint8_t *data, size_t size); 52 46 53 /** */54 47 void usb_hid_free_report(usb_hid_report_t *report); 55 48 56 /** */57 49 void usb_hid_descriptor_print(usb_hid_report_t *report); 58 50 51 int usb_hid_report_init(usb_hid_report_t *report); 59 52 60 int usb_hid_report_init(usb_hid_report_t *report);61 53 int usb_hid_report_append_fields(usb_hid_report_t *report, 62 54 usb_hid_report_item_t *report_item); 63 55 64 56 usb_hid_report_description_t * usb_hid_report_find_description(const usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type); 57 65 58 int usb_hid_report_parse_tag(uint8_t tag, uint8_t class, const uint8_t *data, size_t item_size, 66 59 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 60 67 61 int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size, 68 62 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 63 69 64 int usb_hid_report_parse_global_tag(uint8_t tag, const uint8_t *data, size_t item_size, 70 65 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 66 71 67 int usb_hid_report_parse_local_tag(uint8_t tag, const uint8_t *data, size_t item_size, 72 68 usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path); 73 69 74 70 void usb_hid_descriptor_print_list(link_t *head); 71 75 72 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item); 73 76 74 void usb_hid_free_report_list(link_t *head); 75 77 76 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item); 77 78 78 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size); 79 79 80 80 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path); 81 82 81 83 #endif 82 84 /** -
uspace/lib/usbhid/include/usb/hid/hidparser.h
rfa8d346 r8d3f198 65 65 usb_hid_report_type_t type); 66 66 67 size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, 68 usb_hid_report_type_t type); 69 70 67 71 /** Makes the output report buffer by translated given data */ 68 72 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id, 69 73 uint8_t *buffer, size_t size); 74 70 75 71 76 /** */ … … 77 82 78 83 /** */ 79 uint8_t usb_hid_ report_get_report_id(usb_hid_report_t *report,84 uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, 80 85 uint8_t report_id, 81 86 usb_hid_report_type_t type); -
uspace/lib/usbhid/include/usb/hid/hidpath.h
rfa8d346 r8d3f198 27 27 */ 28 28 29 /** @addtogroup libusb hid29 /** @addtogroup libusb 30 30 * @{ 31 31 */ … … 33 33 * USB HID report descriptor and report data parser 34 34 */ 35 #ifndef LIBUSB HID_HIDPATH_H_36 #define LIBUSB HID_HIDPATH_H_35 #ifndef LIBUSB_HIDPATH_H_ 36 #define LIBUSB_HIDPATH_H_ 37 37 38 38 #include <usb/hid/hidparser.h> … … 40 40 #include <adt/list.h> 41 41 42 43 /*---------------------------------------------------------------------------*/ 42 44 /** 43 * Description of path of usage pages and usages in report descriptor 45 * Flags of usage paths comparison modes. 46 * 44 47 */ 45 /** Wanted usage path must be exactly the same as the searched one */ 48 /** Wanted usage path must be exactly the same as the searched one. 49 * This option cannot be combined with the others. 50 */ 46 51 #define USB_HID_PATH_COMPARE_STRICT 0 47 /** Wanted usage path must be the suffix in the searched one */ 52 53 /** 54 * Wanted usage path must be the suffix in the searched one. 55 */ 48 56 #define USB_HID_PATH_COMPARE_END 1 49 /** */ 57 58 /** 59 * Only usage page are compared along the usage path. 60 * This option can be combined with others. 61 */ 50 62 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY 2 51 /** Searched usage page must be prefix of the other one */ 63 64 /** 65 * Searched usage page must be prefix of the other one. 66 */ 52 67 #define USB_HID_PATH_COMPARE_BEGIN 4 53 /** Searched couple of usage page and usage can be anywhere in usage path */ 68 69 /** 70 * Searched couple of usage page and usage can be anywhere in usage path. 71 * This option is deprecated. 72 */ 54 73 #define USB_HID_PATH_COMPARE_ANYWHERE 8 55 74 56 57 /** Collection usage path structure */ 75 /*----------------------------------------------------------------------------*/ 76 /** 77 * Item of usage path structure. Last item of linked list describes one item 78 * in report, the others describe superior Collection tags. Usage and Usage 79 * page of report item can be changed due to data in report. 80 */ 58 81 typedef struct { 59 /** */82 /** Usage page of report item. Zero when usage page can be changed. */ 60 83 uint32_t usage_page; 61 /** */84 /** Usage of report item. Zero when usage can be changed. */ 62 85 uint32_t usage; 63 86 87 /** Attribute of Collection tag in report descriptor*/ 64 88 uint8_t flags; 65 /** */ 89 90 /** Linked list structure*/ 66 91 link_t link; 67 92 } usb_hid_report_usage_path_t; 68 93 69 /** */ 94 95 /*---------------------------------------------------------------------------*/ 96 /** 97 * USB HID usage path structure. 98 * */ 70 99 typedef struct { 71 /** */100 /** Length of usage path */ 72 101 int depth; 102 103 /** Report id. Zero is reserved and means that report id is not used. */ 73 104 uint8_t report_id; 74 105 75 /** */106 /** Linked list structure. */ 76 107 link_t link; /* list */ 77 108 78 link_t head; /* head of list of usage paths */ 109 /** Head of the list of usage path items. */ 110 link_t head; 79 111 80 112 } usb_hid_report_path_t; 81 113 82 /* **/114 /*---------------------------------------------------------------------------*/ 83 115 usb_hid_report_path_t *usb_hid_report_path(void); 84 116 85 /** */86 117 void usb_hid_report_path_free(usb_hid_report_path_t *path); 87 118 88 /** */89 119 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *usage_path, 90 120 uint8_t report_id); 91 121 92 /** */93 122 int usb_hid_report_path_append_item(usb_hid_report_path_t *usage_path, 94 123 int32_t usage_page, int32_t usage); 95 124 96 /** */97 125 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path); 98 126 99 /** */100 127 void usb_hid_report_null_last_item(usb_hid_report_path_t *usage_path); 101 128 102 /** */103 129 void usb_hid_report_set_last_item(usb_hid_report_path_t *usage_path, 104 130 int32_t tag, int32_t data); 105 131 106 /** */107 132 int usb_hid_report_compare_usage_path(usb_hid_report_path_t *report_path, 108 133 usb_hid_report_path_t *path, int flags); 109 134 110 /** */111 135 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path); 112 136 -
uspace/lib/usbhid/include/usb/hid/hidtypes.h
rfa8d346 r8d3f198 27 27 */ 28 28 29 /** @addtogroup libusb hid29 /** @addtogroup libusb 30 30 * @{ 31 31 */ 32 32 /** @file 33 * USB HID report descriptor and report data parser34 */ 35 #ifndef LIBUSB HID_HIDTYPES_H_36 #define LIBUSB HID_HIDTYPES_H_33 * Basic data structures for USB HID Report descriptor and report parser. 34 */ 35 #ifndef LIBUSB_HIDTYPES_H_ 36 #define LIBUSB_HIDTYPES_H_ 37 37 38 38 #include <stdint.h> 39 39 #include <adt/list.h> 40 40 41 /*---------------------------------------------------------------------------*/ 42 43 /** 44 * Maximum amount of specified usages for one report item 45 */ 41 46 #define USB_HID_MAX_USAGES 0xffff 42 47 43 #define USB_HID_UINT32_TO_INT32(x, size) ((((x) & (1 << ((size) - 1))) != 0) ? -(~(x - 1) & ((1 << size) - 1)) : (x)) //(-(~((x) - 1))) 44 #define USB_HID_INT32_TO_UINT32(x, size) (((x) < 0 ) ? ((1 << (size)) + (x)) : (x)) 45 46 48 /** 49 * Converts integer from unsigned two's complement format format to signed 50 * one. 51 * 52 * @param x Number to convert 53 * @param size Length of the unsigned number in bites 54 * @return signed int 55 */ 56 #define USB_HID_UINT32_TO_INT32(x, size) \ 57 ((((x) & (1 << ((size) - 1))) != 0) ? \ 58 -(~((x) - 1) & ((1 << size) - 1)) : (x)) 59 60 /** 61 * Convert integer from signed format to unsigned. If number is negative the 62 * two's complement format is used. 63 * 64 * @param x Number to convert 65 * @param size Length of result number in bites 66 * @return unsigned int 67 */ 68 #define USB_HID_INT32_TO_UINT32(x, size) \ 69 (((x) < 0 ) ? ((1 << (size)) + (x)) : (x)) 70 71 /*---------------------------------------------------------------------------*/ 72 73 /** 74 * Report type 75 */ 47 76 typedef enum { 48 77 USB_HID_REPORT_TYPE_INPUT = 1, … … 51 80 } usb_hid_report_type_t; 52 81 53 82 /*---------------------------------------------------------------------------*/ 83 84 /** 85 * Description of all reports described in one report descriptor. 86 */ 54 87 typedef struct { 55 /** */88 /** Count of available reports. */ 56 89 int report_count; 57 link_t reports; /** list of usb_hid_report_description_t */ 58 90 91 /** Head of linked list of description of reports. */ 92 link_t reports; 93 94 /** Head of linked list of all used usage/collection paths. */ 59 95 link_t collection_paths; 96 97 /** Length of list of usage paths. */ 60 98 int collection_paths_count; 61 99 100 /** Flag whether report ids are used. */ 62 101 int use_report_ids; 102 103 /** Report id of last parsed report. */ 63 104 uint8_t last_report_id; 64 105 65 106 } usb_hid_report_t; 66 107 /*---------------------------------------------------------------------------*/ 108 109 /** 110 * Description of one concrete report 111 */ 67 112 typedef struct { 113 /** Report id. Zero when no report id is used. */ 68 114 uint8_t report_id; 115 116 /** Type of report */ 69 117 usb_hid_report_type_t type; 70 118 119 /** Bit length of the report */ 71 120 size_t bit_length; 121 122 /** Number of items in report */ 72 123 size_t item_length; 73 124 74 link_t report_items; /** list of report items (fields) */ 75 125 /** Linked list of report items in report */ 126 link_t report_items; 127 128 /** Linked list of descriptions. */ 76 129 link_t link; 77 130 } usb_hid_report_description_t; 78 131 /*---------------------------------------------------------------------------*/ 132 133 /** 134 * Description of one field/item in report 135 */ 79 136 typedef struct { 80 137 /** Bit offset of the field */ 81 138 int offset; 139 140 /** Bit size of the field */ 82 141 size_t size; 83 142 143 /** Usage page. Zero when usage page can be changed. */ 84 144 uint16_t usage_page; 145 146 /** Usage. Zero when usage can be changed. */ 85 147 uint16_t usage; 86 148 149 /** Item's attributes */ 87 150 uint8_t item_flags; 151 152 /** Usage/Collection path of the field. */ 88 153 usb_hid_report_path_t *collection_path; 89 154 155 /** 156 * The lowest valid logical value (value with the device operates) 157 */ 90 158 int32_t logical_minimum; 159 160 /** 161 * The greatest valid logical value 162 */ 91 163 int32_t logical_maximum; 164 165 /** 166 * The lowest valid physical value (value with the system operates) 167 */ 92 168 int32_t physical_minimum; 169 170 /** The greatest valid physical value */ 93 171 int32_t physical_maximum; 172 173 /** The lowest valid usage index */ 94 174 int32_t usage_minimum; 175 176 /** The greatest valid usage index */ 95 177 int32_t usage_maximum; 178 179 /** Unit of the value */ 96 180 uint32_t unit; 181 182 /** Unit exponent */ 97 183 uint32_t unit_exponent; 98 184 185 /** Array of possible usages */ 99 186 uint32_t *usages; 187 188 /** Size of the array of usages */ 100 189 size_t usages_count; 101 190 191 /** Parsed value */ 102 192 int32_t value; 103 193 194 /** List to another report items */ 104 195 link_t link; 105 196 } usb_hid_report_field_t; 106 197 107 108 109 /** 110 * state table198 /*---------------------------------------------------------------------------*/ 199 200 /** 201 * State table for report descriptor parsing 111 202 */ 112 203 typedef struct { … … 114 205 int32_t id; 115 206 116 /** */207 /** Extended usage page */ 117 208 uint16_t extended_usage_page; 209 210 /** Array of usages specified for this item */ 118 211 uint32_t usages[USB_HID_MAX_USAGES]; 212 213 /** Length of usages array */ 119 214 int usages_count; 120 215 121 /** */216 /** Usage page*/ 122 217 uint32_t usage_page; 123 218 124 /** */219 /** Minimum valid usage index */ 125 220 int32_t usage_minimum; 126 /** */ 221 222 /** Maximum valid usage index */ 127 223 int32_t usage_maximum; 128 /** */ 224 225 /** Minimum valid logical value */ 129 226 int32_t logical_minimum; 130 /** */ 227 228 /** Maximum valid logical value */ 131 229 int32_t logical_maximum; 132 /** */ 230 231 /** Length of the items in bits*/ 133 232 int32_t size; 134 /** */ 233 234 /** COunt of items*/ 135 235 int32_t count; 136 /** */ 236 237 /** Bit offset of the item in report */ 137 238 size_t offset; 138 /** */ 239 240 /** Unit exponent */ 139 241 int32_t unit_exponent; 140 /** */242 /** Unit of the value */ 141 243 int32_t unit; 142 244 143 /** */245 /** String index */ 144 246 uint32_t string_index; 145 /** */ 247 248 /** Minimum valid string index */ 146 249 uint32_t string_minimum; 147 /** */ 250 251 /** Maximum valid string index */ 148 252 uint32_t string_maximum; 149 /** */ 253 254 /** The designator index */ 150 255 uint32_t designator_index; 151 /** */ 256 257 /** Minimum valid designator value*/ 152 258 uint32_t designator_minimum; 153 /** */ 259 260 /** Maximum valid designator value*/ 154 261 uint32_t designator_maximum; 155 /** */ 262 263 /** Minimal valid physical value*/ 156 264 int32_t physical_minimum; 157 /** */ 265 266 /** Maximal valid physical value */ 158 267 int32_t physical_maximum; 159 268 160 /** */269 /** Items attributes*/ 161 270 uint8_t item_flags; 162 271 272 /** Report type */ 163 273 usb_hid_report_type_t type; 164 274 165 275 /** current collection path*/ 166 276 usb_hid_report_path_t *usage_path; 167 /** */ 277 278 /** Unused*/ 168 279 link_t link; 169 280 170 281 int in_delimiter; 171 282 } usb_hid_report_item_t; 172 173 /** HID parser callbacks for IN items. */ 174 typedef struct { 175 /** Callback for keyboard. 176 * 177 * @param key_codes Array of pressed key (including modifiers). 178 * @param count Length of @p key_codes. 179 * @param arg Custom argument. 180 */ 181 void (*keyboard)(const uint8_t *key_codes, size_t count, const uint8_t report_id, void *arg); 182 } usb_hid_report_in_callbacks_t; 183 184 283 /*---------------------------------------------------------------------------*/ 284 /** 285 * Enum of the keyboard modifiers 286 */ 185 287 typedef enum { 186 288 USB_HID_MOD_LCTRL = 0x01, … … 206 308 USB_HID_MOD_RGUI 207 309 }; 310 /*---------------------------------------------------------------------------*/ 311 208 312 209 313 #endif -
uspace/lib/usbhid/src/hidparser.c
rfa8d346 r8d3f198 31 31 */ 32 32 /** @file 33 * HID report descriptor andreport data parser implementation.33 * USB HID report data parser implementation. 34 34 */ 35 35 #include <usb/hid/hidparser.h> … … 41 41 #include <assert.h> 42 42 43 43 /*---------------------------------------------------------------------------*/ 44 44 /* 45 45 * Data translation private functions 46 46 */ 47 47 uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size); 48 //inline size_t usb_hid_count_item_offset(usb_hid_report_item_t * report_item, size_t offset); 48 49 49 int usb_hid_translate_data(usb_hid_report_field_t *item, const uint8_t *data); 50 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int32_t value); 50 51 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 52 int32_t value); 53 51 54 int usb_pow(int a, int b); 52 55 56 /*---------------------------------------------------------------------------*/ 53 57 54 58 // TODO: tohle ma bejt asi jinde … … 56 60 { 57 61 switch(b) { 58 59 60 61 62 63 64 65 66 67 } 68 } 69 62 case 0: 63 return 1; 64 break; 65 case 1: 66 return a; 67 break; 68 default: 69 return a * usb_pow(a, b-1); 70 break; 71 } 72 } 73 /*---------------------------------------------------------------------------*/ 70 74 71 75 /** Returns size of report of specified report id and type in items … … 94 98 } 95 99 100 /** Returns size of report of specified report id and type in bytes 101 * 102 * @param parser Opaque report parser structure 103 * @param report_id 104 * @param type 105 * @return Number of items in specified report 106 */ 107 size_t usb_hid_report_byte_size(usb_hid_report_t *report, uint8_t report_id, 108 usb_hid_report_type_t type) 109 { 110 usb_hid_report_description_t *report_des; 111 112 if(report == NULL) { 113 return 0; 114 } 115 116 report_des = usb_hid_report_find_description (report, report_id, type); 117 if(report_des == NULL){ 118 return 0; 119 } 120 else { 121 return (report_des->bit_length + 7) / 8; 122 } 123 } 124 /*---------------------------------------------------------------------------*/ 96 125 97 126 /** Parse and act upon a HID report. … … 103 132 * @return Error code. 104 133 */ 105 int usb_hid_parse_report(const usb_hid_report_t *report, 106 const uint8_t *data,size_t size, uint8_t *report_id)134 int usb_hid_parse_report(const usb_hid_report_t *report, const uint8_t *data, 135 size_t size, uint8_t *report_id) 107 136 { 108 137 link_t *list_item; … … 139 168 item->value = usb_hid_translate_data(item, data); 140 169 141 item->usage = USB_HID_EXTENDED_USAGE(item->usages[item->value - item->physical_minimum]); 142 item->usage_page = USB_HID_EXTENDED_USAGE_PAGE(item->usages[item->value - item->physical_minimum]); 170 item->usage = USB_HID_EXTENDED_USAGE( 171 item->usages[item->value - item->physical_minimum]); 172 item->usage_page = USB_HID_EXTENDED_USAGE_PAGE( 173 item->usages[item->value - item->physical_minimum]); 143 174 144 175 usb_hid_report_set_last_item (item->collection_path, 145 USB_HID_TAG_CLASS_GLOBAL, 146 item->usage_page); 176 USB_HID_TAG_CLASS_GLOBAL, item->usage_page); 147 177 usb_hid_report_set_last_item (item->collection_path, 148 USB_HID_TAG_CLASS_LOCAL, 149 item->usage); 178 USB_HID_TAG_CLASS_LOCAL, item->usage); 150 179 151 180 } … … 162 191 } 163 192 193 /*---------------------------------------------------------------------------*/ 164 194 /** 165 195 * Translate data from the report as specified in report descriptor item … … 167 197 * @param item Report descriptor item with definition of translation 168 198 * @param data Data to translate 169 * @param j Index of processed field in report descriptor item170 199 * @return Translated data 171 200 */ … … 240 269 } 241 270 242 /*** OUTPUT API **/ 271 /*---------------------------------------------------------------------------*/ 272 /* OUTPUT API */ 243 273 244 274 /** … … 250 280 * @return Returns allocated output buffer for specified output 251 281 */ 252 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, uint8_t report_id) 282 uint8_t *usb_hid_report_output(usb_hid_report_t *report, size_t *size, 283 uint8_t report_id) 253 284 { 254 285 if(report == NULL) { … … 260 291 usb_hid_report_description_t *report_des = NULL; 261 292 while(report_it != &report->reports) { 262 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 263 if((report_des->report_id == report_id) && (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ 293 report_des = list_get_instance(report_it, 294 usb_hid_report_description_t, link); 295 296 if((report_des->report_id == report_id) && 297 (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ 264 298 break; 265 299 } … … 303 337 * @return Error code 304 338 */ 305 int usb_hid_report_output_translate(usb_hid_report_t *report, uint8_t report_id,306 339 int usb_hid_report_output_translate(usb_hid_report_t *report, 340 uint8_t report_id, uint8_t *buffer, size_t size) 307 341 { 308 342 link_t *item; … … 320 354 } 321 355 322 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));323 324 356 usb_hid_report_description_t *report_des; 325 report_des = usb_hid_report_find_description (report, report_id, USB_HID_REPORT_TYPE_OUTPUT); 357 report_des = usb_hid_report_find_description (report, report_id, 358 USB_HID_REPORT_TYPE_OUTPUT); 359 326 360 if(report_des == NULL){ 327 361 return EINVAL; … … 333 367 report_item = list_get_instance(item, usb_hid_report_field_t, link); 334 368 335 usb_log_debug("OUTPUT ITEM usage(%x), value(%x)\n", report_item->usage, report_item->value);336 337 369 if(USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) == 0) { 338 370 339 371 // array 340 value = usb_hid_translate_data_reverse(report_item, report_item->value); 372 value = usb_hid_translate_data_reverse(report_item, 373 report_item->value); 374 341 375 offset = report_item->offset; 342 376 length = report_item->size; … … 344 378 else { 345 379 // variable item 346 value = usb_hid_translate_data_reverse(report_item, report_item->value); 380 value = usb_hid_translate_data_reverse(report_item, 381 report_item->value); 382 347 383 offset = report_item->offset; 348 384 length = report_item->size; … … 353 389 if((offset/8) == ((offset+length-1)/8)) { 354 390 // je to v jednom bytu 355 if(((size_t)(offset/8) >= size) || ((size_t)(offset+length-1)/8) >= size) { 391 if(((size_t)(offset/8) >= size) || 392 ((size_t)(offset+length-1)/8) >= size) { 356 393 break; // TODO ErrorCode 357 394 } … … 379 416 380 417 value = value >> (length - ((offset + length) % 8)); 381 value = value & ((1 << (length - ((offset + length) % 8))) - 1); 418 value = value & 419 ((1 << (length - ((offset + length) % 8))) - 1); 382 420 383 421 mask = (1 << (length - ((offset + length) % 8))) - 1; … … 396 434 } 397 435 398 usb_log_debug("OUTPUT BUFFER: %s\n", usb_debug_str_buffer(buffer,size, 0));399 400 436 return EOK; 401 437 } 402 438 439 /*---------------------------------------------------------------------------*/ 403 440 /** 404 441 * Translate given data for putting them into the outoput report … … 407 444 * @return ranslated value 408 445 */ 409 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, int value) 446 uint32_t usb_hid_translate_data_reverse(usb_hid_report_field_t *item, 447 int value) 410 448 { 411 449 int ret=0; … … 431 469 } 432 470 433 ret = ((value - item->physical_minimum) * resolution) + item->logical_minimum; 434 usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), ret(%x)\n", value, resolution, item->physical_minimum, item->logical_minimum, ret); 471 ret = ((value - item->physical_minimum) * resolution) + 472 item->logical_minimum; 473 474 usb_log_debug("\tvalue(%x), resolution(%x), phymin(%x) logmin(%x), \ 475 ret(%x)\n", value, resolution, item->physical_minimum, 476 item->logical_minimum, ret); 435 477 436 478 if((item->logical_minimum < 0) || (item->logical_maximum < 0)){ … … 440 482 } 441 483 442 usb_hid_report_item_t *usb_hid_report_item_clone(const usb_hid_report_item_t *item) 484 /*---------------------------------------------------------------------------*/ 485 /** 486 * Clones given state table 487 * 488 * @param item State table to clone 489 * @return Pointer to the cloned item 490 */ 491 usb_hid_report_item_t *usb_hid_report_item_clone( 492 const usb_hid_report_item_t *item) 443 493 { 444 494 usb_hid_report_item_t *new_report_item; … … 453 503 } 454 504 455 505 /*---------------------------------------------------------------------------*/ 506 /** 507 * Function for sequence walking through the report. Returns next field in the 508 * report or the first one when no field is given. 509 * 510 * @param report Searched report structure 511 * @param field Current field. If NULL is given, the first one in the report 512 * is returned. Otherwise the next one i nthe list is returned. 513 * @param path Usage path specifying which fields wa are interested in. 514 * @param flags Flags defining mode of usage paths comparison 515 * @param type Type of report we search. 516 * @retval NULL if no field is founded 517 * @retval Pointer to the founded report structure when founded 518 */ 456 519 usb_hid_report_field_t *usb_hid_report_get_sibling(usb_hid_report_t *report, 457 usb_hid_report_field_t *field, 458 usb_hid_report_path_t *path, int flags, 459 usb_hid_report_type_t type) 460 { 461 usb_hid_report_description_t *report_des = usb_hid_report_find_description (report, path->report_id, type); 520 usb_hid_report_field_t *field, usb_hid_report_path_t *path, int flags, 521 usb_hid_report_type_t type) 522 { 523 usb_hid_report_description_t *report_des = usb_hid_report_find_description( 524 report, path->report_id, type); 525 462 526 link_t *field_it; 463 527 … … 467 531 468 532 if(field == NULL){ 469 // vezmu prvni co mathuje podle path!!470 533 field_it = report_des->report_items.next; 471 534 } … … 478 541 479 542 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { 480 usb_hid_report_path_append_item (field->collection_path, field->usage_page, field->usage); 481 if(usb_hid_report_compare_usage_path (field->collection_path, path, flags) == EOK){ 482 usb_hid_report_remove_last_item (field->collection_path); 543 usb_hid_report_path_append_item (field->collection_path, 544 field->usage_page, field->usage); 545 546 if(usb_hid_report_compare_usage_path(field->collection_path, path, 547 flags) == EOK){ 548 549 usb_hid_report_remove_last_item(field->collection_path); 483 550 return field; 484 551 } … … 491 558 } 492 559 493 uint8_t usb_hid_report_get_report_id(usb_hid_report_t *report, uint8_t report_id, usb_hid_report_type_t type) 560 /*---------------------------------------------------------------------------*/ 561 /** 562 * Returns next report_id of report of specified type. If zero is given than 563 * first report_id of specified type is returned (0 is not legal value for 564 * repotr_id) 565 * 566 * @param report_id Current report_id, 0 if there is no current report_id 567 * @param type Type of searched report 568 * @param report Report structure inwhich we search 569 * @retval 0 if report structure is null or there is no specified report 570 * @retval report_id otherwise 571 */ 572 uint8_t usb_hid_get_next_report_id(usb_hid_report_t *report, 573 uint8_t report_id, usb_hid_report_type_t type) 494 574 { 495 575 if(report == NULL){ … … 500 580 link_t *report_it; 501 581 502 if(report_id == 0) { 503 report_it = usb_hid_report_find_description (report, report_id, type)->link.next; 582 if(report_id > 0) { 583 report_it = usb_hid_report_find_description(report, report_id, 584 type)->link.next; 504 585 } 505 586 else { … … 508 589 509 590 while(report_it != &report->reports) { 510 report_des = list_get_instance(report_it, usb_hid_report_description_t, link); 591 report_des = list_get_instance(report_it, 592 usb_hid_report_description_t, link); 593 511 594 if(report_des->type == type){ 512 595 return report_des->report_id; … … 517 600 } 518 601 602 /*---------------------------------------------------------------------------*/ 603 /** 604 * Reset all local items in given state table 605 * 606 * @param report_item State table containing current state of report 607 * descriptor parsing 608 * 609 * @return void 610 */ 519 611 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item) 520 612 { -
uspace/lib/usbhid/src/hidpath.c
rfa8d346 r8d3f198 41 41 #include <assert.h> 42 42 43 44 #define USB_HID_SAME_USAGE(usage1, usage2) ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0)) 45 #define USB_HID_SAME_USAGE_PAGE(page1, page2) ((page1 == page2) || (page1 == 0) || (page2 == 0)) 46 43 /*---------------------------------------------------------------------------*/ 44 /** 45 * Compares two usages if they are same or not or one of the usages is not 46 * set. 47 * 48 * @param usage1 49 * @param usage2 50 * @return boolean 51 */ 52 #define USB_HID_SAME_USAGE(usage1, usage2) \ 53 ((usage1 == usage2) || (usage1 == 0) || (usage2 == 0)) 54 55 /** 56 * Compares two usage pages if they are same or not or one of them is not set. 57 * 58 * @param page1 59 * @param page2 60 * @return boolean 61 */ 62 #define USB_HID_SAME_USAGE_PAGE(page1, page2) \ 63 ((page1 == page2) || (page1 == 0) || (page2 == 0)) 64 65 /*---------------------------------------------------------------------------*/ 47 66 /** 48 67 * Appends one item (couple of usage_path and usage) into the usage path … … 73 92 } 74 93 94 /*---------------------------------------------------------------------------*/ 75 95 /** 76 96 * Removes last item from the usage path structure … … 91 111 } 92 112 113 /*---------------------------------------------------------------------------*/ 93 114 /** 94 115 * Nulls last item of the usage path structure. … … 102 123 103 124 if(!list_empty(&usage_path->head)){ 104 item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link); 125 item = list_get_instance(usage_path->head.prev, 126 usb_hid_report_usage_path_t, link); 127 105 128 memset(item, 0, sizeof(usb_hid_report_usage_path_t)); 106 129 } 107 130 } 108 131 132 /*---------------------------------------------------------------------------*/ 109 133 /** 110 134 * Modifies last item of usage path structure by given usage page or usage … … 137 161 } 138 162 139 163 /*---------------------------------------------------------------------------*/ 164 /** 165 * 166 * 167 * 168 * 169 */ 140 170 void usb_hid_print_usage_path(usb_hid_report_path_t *path) 141 171 { … … 147 177 while(item != &path->head) { 148 178 149 path_item = list_get_instance(item, usb_hid_report_usage_path_t, link); 179 path_item = list_get_instance(item, usb_hid_report_usage_path_t, 180 link); 181 150 182 usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page); 151 183 usb_log_debug("\tUSAGE: %X\n", path_item->usage); 152 184 usb_log_debug("\tFLAGS: %d\n", path_item->flags); 153 185 154 item = item->next; 155 } 156 } 157 186 item = item->next; 187 } 188 } 189 190 /*---------------------------------------------------------------------------*/ 158 191 /** 159 192 * Compares two usage paths structures … … 198 231 } 199 232 200 // projit skrz cestu a kdyz nekde sedi tak vratim EOK201 // dojduli az za konec tak nnesedi202 233 report_link = report_path->head.next; 203 234 path_link = path->head.next; 204 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link); 235 path_item = list_get_instance(path_link, 236 usb_hid_report_usage_path_t, link); 205 237 206 238 while(report_link != &report_path->head) { 207 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link); 208 if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page)){ 239 report_item = list_get_instance(report_link, 240 usb_hid_report_usage_path_t, link); 241 242 if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 243 path_item->usage_page)){ 244 209 245 if(only_page == 0){ 210 if(USB_HID_SAME_USAGE(report_item->usage, path_item->usage)) { 246 if(USB_HID_SAME_USAGE(report_item->usage, 247 path_item->usage)) { 248 211 249 return EOK; 212 250 } … … 238 276 239 277 report_item = list_get_instance(report_link, 240 usb_hid_report_usage_path_t, 241 link); 278 usb_hid_report_usage_path_t, link); 242 279 243 280 path_item = list_get_instance(path_link, 244 usb_hid_report_usage_path_t, 245 link); 246 247 if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page) ||248 ((only_page == 0) &&249 !USB_HID_SAME_USAGE(report_item->usage,path_item->usage))) {281 usb_hid_report_usage_path_t, link); 282 283 if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 284 path_item->usage_page) || ((only_page == 0) && 285 !USB_HID_SAME_USAGE(report_item->usage, 286 path_item->usage))) { 250 287 251 288 return 1; … … 257 294 } 258 295 259 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) || 260 ((report_link == &report_path->head) && (path_link == &path->head))) { 296 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && 297 (path_link == &path->head)) || 298 ((report_link == &report_path->head) && 299 (path_link == &path->head))) { 300 261 301 return EOK; 262 302 } … … 280 320 281 321 report_item = list_get_instance(report_link, 282 usb_hid_report_usage_path_t,283 link); 322 usb_hid_report_usage_path_t, link); 323 284 324 path_item = list_get_instance(path_link, 285 usb_hid_report_usage_path_t, 286 link); 325 usb_hid_report_usage_path_t, link); 287 326 288 if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, path_item->usage_page) || 289 ((only_page == 0) && 290 !USB_HID_SAME_USAGE(report_item->usage, path_item->usage))) { 327 if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 328 path_item->usage_page) || ((only_page == 0) && 329 !USB_HID_SAME_USAGE(report_item->usage, 330 path_item->usage))) { 331 291 332 return 1; 292 333 } else { … … 311 352 } 312 353 354 /*---------------------------------------------------------------------------*/ 313 355 /** 314 356 * Allocates and initializes new usage path structure. … … 332 374 } 333 375 376 /*---------------------------------------------------------------------------*/ 334 377 /** 335 378 * Releases given usage path structure. … … 348 391 } 349 392 350 393 /*---------------------------------------------------------------------------*/ 351 394 /** 352 395 * Clone content of given usage path to the new one … … 355 398 * @return New copy of given usage path structure 356 399 */ 357 usb_hid_report_path_t *usb_hid_report_path_clone(usb_hid_report_path_t *usage_path) 400 usb_hid_report_path_t *usb_hid_report_path_clone( 401 usb_hid_report_path_t *usage_path) 358 402 { 359 403 link_t *path_link; … … 374 418 path_link = usage_path->head.next; 375 419 while(path_link != &usage_path->head) { 376 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, 420 path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, 377 421 link); 378 422 new_path_item = malloc(sizeof(usb_hid_report_usage_path_t)); … … 395 439 } 396 440 397 441 /*---------------------------------------------------------------------------*/ 398 442 /** 399 443 * Sets report id in usage path structure … … 403 447 * @return Error code 404 448 */ 405 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, uint8_t report_id) 449 int usb_hid_report_path_set_report_id(usb_hid_report_path_t *path, 450 uint8_t report_id) 406 451 { 407 452 if(path == NULL){
Note:
See TracChangeset
for help on using the changeset viewer.