Changes in / [2cb6571:54b141a] in mainline
- Files:
-
- 8 added
- 1 deleted
- 20 edited
Legend:
- Unmodified
- Added
- Removed
-
.bzrignore
r2cb6571 r54b141a 94 94 ./uspace/dist/drv/rootia32/ 95 95 ./uspace/dist/drv/uhci/ 96 ./uspace/dist/drv/usbhub/ 96 97 ./uspace/dist/drv/usbkbd/ 97 98 ./uspace/dist/drv/vhc/ … … 130 131 ./uspace/drv/rootia32/rootia32 131 132 ./uspace/drv/uhci/uhci 133 ./uspace/drv/usbhub/usbhub 132 134 ./uspace/drv/usbkbd/usbkbd 133 135 ./uspace/drv/vhc/vhc -
boot/arch/amd64/Makefile.inc
r2cb6571 r54b141a 42 42 ns8250 \ 43 43 uhci \ 44 usbhub \ 44 45 usbkbd 45 46 -
uspace/Makefile
r2cb6571 r54b141a 118 118 DIRS += drv/ns8250 119 119 DIRS += drv/uhci 120 DIRS += drv/usbhub 120 121 DIRS += drv/usbkbd 121 122 endif -
uspace/drv/uhci/Makefile
r2cb6571 r54b141a 33 33 34 34 SOURCES = \ 35 main.c 35 main.c \ 36 transfers.c 36 37 37 38 include $(USPACE_PREFIX)/Makefile.common -
uspace/drv/uhci/main.c
r2cb6571 r54b141a 28 28 #include <usb/hcdhubd.h> 29 29 #include <errno.h> 30 #include "uhci.h" 30 31 31 static int enqueue_transfer_out(usb_hc_device_t *hc, 32 usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, 33 void *buffer, size_t size, 34 usb_hcd_transfer_callback_out_t callback, void *arg) 35 { 36 printf("UHCI: transfer OUT [%d.%d (%s); %u]\n", 37 dev->address, endpoint->endpoint, 38 usb_str_transfer_type(endpoint->transfer_type), 39 size); 40 return ENOTSUP; 41 } 42 43 static int enqueue_transfer_setup(usb_hc_device_t *hc, 44 usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, 45 void *buffer, size_t size, 46 usb_hcd_transfer_callback_out_t callback, void *arg) 47 { 48 printf("UHCI: transfer SETUP [%d.%d (%s); %u]\n", 49 dev->address, endpoint->endpoint, 50 usb_str_transfer_type(endpoint->transfer_type), 51 size); 52 return ENOTSUP; 53 } 54 55 static int enqueue_transfer_in(usb_hc_device_t *hc, 56 usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint, 57 void *buffer, size_t size, 58 usb_hcd_transfer_callback_in_t callback, void *arg) 59 { 60 printf("UHCI: transfer IN [%d.%d (%s); %u]\n", 61 dev->address, endpoint->endpoint, 62 usb_str_transfer_type(endpoint->transfer_type), 63 size); 64 return ENOTSUP; 65 } 66 67 static usb_hcd_transfer_ops_t uhci_transfer_ops = { 68 .transfer_out = enqueue_transfer_out, 69 .transfer_in = enqueue_transfer_in, 70 .transfer_setup = enqueue_transfer_setup 32 static device_ops_t uhci_ops = { 33 .interfaces[USBHC_DEV_IFACE] = &uhci_iface, 71 34 }; 72 35 73 static int uhci_add_ hc(usb_hc_device_t *device)36 static int uhci_add_device(device_t *device) 74 37 { 75 device-> transfer_ops = &uhci_transfer_ops;38 device->ops = &uhci_ops; 76 39 77 40 /* … … 83 46 } 84 47 85 usb_hc_driver_t uhci_driver = { 86 .name = "uhci", 87 .add_hc = uhci_add_hc 48 static driver_ops_t uhci_driver_ops = { 49 .add_device = uhci_add_device, 50 }; 51 52 static driver_t uhci_driver = { 53 .name = NAME, 54 .driver_ops = &uhci_driver_ops 88 55 }; 89 56 … … 93 60 * Do some global initializations. 94 61 */ 62 sleep(5); 95 63 96 return usb_hcd_main(&uhci_driver);64 return driver_main(&uhci_driver); 97 65 } -
uspace/drv/uhci/uhci.ma
r2cb6571 r54b141a 1 1 10 pci/ven=8086&dev=7020 2 10 usb&hc=uhci 3 10 usb&hc=uhci&hub 2 -
uspace/drv/vhc/Makefile
r2cb6571 r54b141a 39 39 40 40 SOURCES = \ 41 addrmgm.c \ 41 42 conndev.c \ 42 43 connhost.c \ -
uspace/drv/vhc/conn.h
r2cb6571 r54b141a 38 38 #include <usb/usb.h> 39 39 #include <usb/hcdhubd.h> 40 #include <usbhc_iface.h> 40 41 #include "vhcd.h" 41 42 #include "devices.h" … … 44 45 45 46 usb_hcd_transfer_ops_t vhc_transfer_ops; 47 usbhc_iface_t vhc_iface; 48 49 void address_init(void); 50 int reserve_default_address(device_t *); 51 int release_default_address(device_t *); 52 int request_address(device_t *, usb_address_t *); 53 int release_address(device_t *, usb_address_t); 54 46 55 47 56 void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *); -
uspace/drv/vhc/connhost.c
r2cb6571 r54b141a 43 43 typedef struct { 44 44 usb_direction_t direction; 45 usb _hcd_transfer_callback_out_t out_callback;46 usb _hcd_transfer_callback_in_t in_callback;47 usb_hc_device_t *hc;45 usbhc_iface_transfer_out_callback_t out_callback; 46 usbhc_iface_transfer_in_callback_t in_callback; 47 device_t *dev; 48 48 void *arg; 49 49 } transfer_info_t; … … 56 56 switch (transfer->direction) { 57 57 case USB_DIRECTION_IN: 58 transfer->in_callback(transfer-> hc,58 transfer->in_callback(transfer->dev, 59 59 size, outcome, 60 60 transfer->arg); 61 61 break; 62 62 case USB_DIRECTION_OUT: 63 transfer->out_callback(transfer-> hc,63 transfer->out_callback(transfer->dev, 64 64 outcome, 65 65 transfer->arg); … … 73 73 } 74 74 75 static transfer_info_t *create_transfer_info( usb_hc_device_t *hc,75 static transfer_info_t *create_transfer_info(device_t *dev, 76 76 usb_direction_t direction, void *arg) 77 77 { … … 82 82 transfer->out_callback = NULL; 83 83 transfer->arg = arg; 84 transfer-> hc = hc;84 transfer->dev = dev; 85 85 86 86 return transfer; 87 87 } 88 88 89 static int enqueue_transfer_out( usb_hc_device_t *hc,90 usb_ hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,89 static int enqueue_transfer_out(device_t *dev, 90 usb_target_t target, usb_transfer_type_t transfer_type, 91 91 void *buffer, size_t size, 92 usb _hcd_transfer_callback_out_t callback, void *arg)92 usbhc_iface_transfer_out_callback_t callback, void *arg) 93 93 { 94 94 printf(NAME ": transfer OUT [%d.%d (%s); %u]\n", 95 dev->address, endpoint->endpoint,96 usb_str_transfer_type( endpoint->transfer_type),95 target.address, target.endpoint, 96 usb_str_transfer_type(transfer_type), 97 97 size); 98 98 99 99 transfer_info_t *transfer 100 = create_transfer_info( hc, USB_DIRECTION_OUT, arg);100 = create_transfer_info(dev, USB_DIRECTION_OUT, arg); 101 101 transfer->out_callback = callback; 102 103 usb_target_t target = {104 .address = dev->address,105 .endpoint = endpoint->endpoint106 };107 102 108 103 hc_add_transaction_to_device(false, target, buffer, size, … … 112 107 } 113 108 114 static int enqueue_transfer_setup( usb_hc_device_t *hc,115 usb_ hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,109 static int enqueue_transfer_setup(device_t *dev, 110 usb_target_t target, usb_transfer_type_t transfer_type, 116 111 void *buffer, size_t size, 117 usb _hcd_transfer_callback_out_t callback, void *arg)112 usbhc_iface_transfer_out_callback_t callback, void *arg) 118 113 { 119 114 printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n", 120 dev->address, endpoint->endpoint,121 usb_str_transfer_type( endpoint->transfer_type),115 target.address, target.endpoint, 116 usb_str_transfer_type(transfer_type), 122 117 size); 123 118 124 119 transfer_info_t *transfer 125 = create_transfer_info( hc, USB_DIRECTION_OUT, arg);120 = create_transfer_info(dev, USB_DIRECTION_OUT, arg); 126 121 transfer->out_callback = callback; 127 128 usb_target_t target = {129 .address = dev->address,130 .endpoint = endpoint->endpoint131 };132 122 133 123 hc_add_transaction_to_device(true, target, buffer, size, … … 137 127 } 138 128 139 static int enqueue_transfer_in( usb_hc_device_t *hc,140 usb_ hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,129 static int enqueue_transfer_in(device_t *dev, 130 usb_target_t target, usb_transfer_type_t transfer_type, 141 131 void *buffer, size_t size, 142 usb _hcd_transfer_callback_in_t callback, void *arg)132 usbhc_iface_transfer_in_callback_t callback, void *arg) 143 133 { 144 134 printf(NAME ": transfer IN [%d.%d (%s); %u]\n", 145 dev->address, endpoint->endpoint,146 usb_str_transfer_type( endpoint->transfer_type),135 target.address, target.endpoint, 136 usb_str_transfer_type(transfer_type), 147 137 size); 148 138 149 139 transfer_info_t *transfer 150 = create_transfer_info( hc, USB_DIRECTION_IN, arg);140 = create_transfer_info(dev, USB_DIRECTION_IN, arg); 151 141 transfer->in_callback = callback; 152 153 usb_target_t target = {154 .address = dev->address,155 .endpoint = endpoint->endpoint156 };157 142 158 143 hc_add_transaction_from_device(target, buffer, size, … … 163 148 164 149 165 usb_hcd_transfer_ops_t vhc_transfer_ops = { 166 .transfer_out = enqueue_transfer_out, 167 .transfer_in = enqueue_transfer_in, 168 .transfer_setup = enqueue_transfer_setup 150 static int get_address(device_t *dev, devman_handle_t handle, 151 usb_address_t *address) 152 { 153 return ENOTSUP; 154 } 155 156 static int interrupt_out(device_t *dev, usb_target_t target, 157 void *data, size_t size, 158 usbhc_iface_transfer_out_callback_t callback, void *arg) 159 { 160 return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT, 161 data, size, 162 callback, arg); 163 } 164 165 static int interrupt_in(device_t *dev, usb_target_t target, 166 void *data, size_t size, 167 usbhc_iface_transfer_in_callback_t callback, void *arg) 168 { 169 return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT, 170 data, size, 171 callback, arg); 172 } 173 174 static int control_write_setup(device_t *dev, usb_target_t target, 175 void *data, size_t size, 176 usbhc_iface_transfer_out_callback_t callback, void *arg) 177 { 178 return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL, 179 data, size, 180 callback, arg); 181 } 182 183 static int control_write_data(device_t *dev, usb_target_t target, 184 void *data, size_t size, 185 usbhc_iface_transfer_out_callback_t callback, void *arg) 186 { 187 return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL, 188 data, size, 189 callback, arg); 190 } 191 192 static int control_write_status(device_t *dev, usb_target_t target, 193 usbhc_iface_transfer_in_callback_t callback, void *arg) 194 { 195 return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL, 196 NULL, 0, 197 callback, arg); 198 } 199 200 static int control_read_setup(device_t *dev, usb_target_t target, 201 void *data, size_t size, 202 usbhc_iface_transfer_out_callback_t callback, void *arg) 203 { 204 return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL, 205 data, size, 206 callback, arg); 207 } 208 209 static int control_read_data(device_t *dev, usb_target_t target, 210 void *data, size_t size, 211 usbhc_iface_transfer_in_callback_t callback, void *arg) 212 { 213 return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL, 214 data, size, 215 callback, arg); 216 } 217 218 static int control_read_status(device_t *dev, usb_target_t target, 219 usbhc_iface_transfer_out_callback_t callback, void *arg) 220 { 221 return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL, 222 NULL, 0, 223 callback, arg); 224 } 225 226 227 usbhc_iface_t vhc_iface = { 228 .tell_address = get_address, 229 230 .reserve_default_address = reserve_default_address, 231 .release_default_address = release_default_address, 232 .request_address = request_address, 233 .release_address = release_address, 234 235 .interrupt_out = interrupt_out, 236 .interrupt_in = interrupt_in, 237 238 .control_write_setup = control_write_setup, 239 .control_write_data = control_write_data, 240 .control_write_status = control_write_status, 241 242 .control_read_setup = control_read_setup, 243 .control_read_data = control_read_data, 244 .control_read_status = control_read_status 169 245 }; 170 246 -
uspace/drv/vhc/hcd.c
r2cb6571 r54b141a 52 52 #include "conn.h" 53 53 54 static device_ops_t vhc_ops = { 55 .interfaces[USBHC_DEV_IFACE] = &vhc_iface, 56 .default_handler = default_connection_handler 57 }; 54 58 55 59 static int vhc_count = 0; 56 static int vhc_add_device( usb_hc_device_t *dev)60 static int vhc_add_device(device_t *dev) 57 61 { 58 62 /* … … 65 69 vhc_count++; 66 70 67 dev->transfer_ops = &vhc_transfer_ops; 68 dev->generic->ops->default_handler = default_connection_handler; 71 dev->ops = &vhc_ops; 72 73 /* 74 * Initialize address management. 75 */ 76 address_init(); 69 77 70 78 /* … … 79 87 } 80 88 81 static usb_hc_driver_t vhc_driver = { 89 static driver_ops_t vhc_driver_ops = { 90 .add_device = vhc_add_device, 91 }; 92 93 static driver_t vhc_driver = { 82 94 .name = NAME, 83 . add_hc = &vhc_add_device95 .driver_ops = &vhc_driver_ops 84 96 }; 85 97 … … 114 126 sleep(4); 115 127 116 return usb_hcd_main(&vhc_driver);128 return driver_main(&vhc_driver); 117 129 } 118 130 -
uspace/drv/vhc/vhc.ma
r2cb6571 r54b141a 1 1 10 usb&hc=vhc 2 10 usb&hc=vhc&hub 2 -
uspace/lib/drv/generic/remote_usbhc.c
r2cb6571 r54b141a 52 52 static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *); 53 53 static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *); 54 static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *); 55 static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *); 56 static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *); 57 static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *); 54 58 //static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *); 55 59 … … 57 61 static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = { 58 62 remote_usbhc_get_address, 63 59 64 remote_usbhc_get_buffer, 65 66 remote_usbhc_reserve_default_address, 67 remote_usbhc_release_default_address, 68 69 remote_usbhc_request_address, 70 remote_usbhc_release_address, 71 60 72 remote_usbhc_interrupt_out, 61 73 remote_usbhc_interrupt_in, 74 62 75 remote_usbhc_control_write_setup, 63 76 remote_usbhc_control_write_data, 64 77 remote_usbhc_control_write_status, 78 65 79 remote_usbhc_control_read_setup, 66 80 remote_usbhc_control_read_data, … … 134 148 free(trans->buffer); 135 149 free(trans); 150 } 151 152 void remote_usbhc_reserve_default_address(device_t *device, void *iface, 153 ipc_callid_t callid, ipc_call_t *call) 154 { 155 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; 156 157 if (!usb_iface->reserve_default_address) { 158 ipc_answer_0(callid, ENOTSUP); 159 return; 160 } 161 162 int rc = usb_iface->reserve_default_address(device); 163 164 ipc_answer_0(callid, rc); 165 } 166 167 void remote_usbhc_release_default_address(device_t *device, void *iface, 168 ipc_callid_t callid, ipc_call_t *call) 169 { 170 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; 171 172 if (!usb_iface->release_default_address) { 173 ipc_answer_0(callid, ENOTSUP); 174 return; 175 } 176 177 int rc = usb_iface->release_default_address(device); 178 179 ipc_answer_0(callid, rc); 180 } 181 182 void remote_usbhc_request_address(device_t *device, void *iface, 183 ipc_callid_t callid, ipc_call_t *call) 184 { 185 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; 186 187 if (!usb_iface->request_address) { 188 ipc_answer_0(callid, ENOTSUP); 189 return; 190 } 191 192 usb_address_t address; 193 int rc = usb_iface->request_address(device, &address); 194 if (rc != EOK) { 195 ipc_answer_0(callid, rc); 196 } else { 197 ipc_answer_1(callid, EOK, (ipcarg_t) address); 198 } 199 } 200 201 void remote_usbhc_release_address(device_t *device, void *iface, 202 ipc_callid_t callid, ipc_call_t *call) 203 { 204 usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface; 205 206 if (!usb_iface->release_address) { 207 ipc_answer_0(callid, ENOTSUP); 208 return; 209 } 210 211 usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call); 212 213 int rc = usb_iface->release_address(device, address); 214 215 ipc_answer_0(callid, rc); 136 216 } 137 217 -
uspace/lib/drv/include/usbhc_iface.h
r2cb6571 r54b141a 111 111 112 112 113 /** Reserve usage of default address. 114 * This call informs the host controller that the caller will be 115 * using default USB address. It is duty of the HC driver to ensure 116 * that only single entity will have it reserved. 117 * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS. 118 * The caller can start using the address after receiving EOK 119 * answer. 120 */ 121 IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS, 122 123 /** Release usage of default address. 124 * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS 125 */ 126 IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS, 127 128 /** Asks for address assignment by host controller. 129 * Answer: 130 * - ELIMIT - host controller run out of address 131 * - EOK - address assigned 132 * Answer arguments: 133 * - assigned address 134 * 135 * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS. 136 */ 137 IPC_M_USBHC_REQUEST_ADDRESS, 138 139 /** Release address in use. 140 * Arguments: 141 * - address to be released 142 * Answer: 143 * - ENOENT - address not in use 144 * - EPERM - trying to release default USB address 145 */ 146 IPC_M_USBHC_RELEASE_ADDRESS, 147 148 113 149 /** Send interrupt data to device. 114 150 * See explanation at usb_iface_funcs_t (OUT transaction). … … 183 219 typedef struct { 184 220 int (*tell_address)(device_t *, devman_handle_t, usb_address_t *); 221 222 int (*reserve_default_address)(device_t *); 223 int (*release_default_address)(device_t *); 224 int (*request_address)(device_t *, usb_address_t *); 225 int (*release_address)(device_t *, usb_address_t); 185 226 186 227 usbhc_iface_transfer_out_t interrupt_out; -
uspace/lib/usb/Makefile
r2cb6571 r54b141a 35 35 src/hcdhubd.c \ 36 36 src/hcdrv.c \ 37 src/hubdrv.c \38 37 src/localdrv.c \ 39 38 src/remotedrv.c \ -
uspace/lib/usb/include/usb/hcdhubd.h
r2cb6571 r54b141a 166 166 167 167 int usb_hcd_main(usb_hc_driver_t *); 168 int usb_hcd_add_root_hub( usb_hc_device_t *dev);168 int usb_hcd_add_root_hub(device_t *dev); 169 169 170 170 /** -
uspace/lib/usb/include/usb/usbdrv.h
r2cb6571 r54b141a 41 41 int usb_drv_hc_connect(device_t *, unsigned int); 42 42 43 int usb_drv_reserve_default_address(int); 44 int usb_drv_release_default_address(int); 45 usb_address_t usb_drv_request_address(int); 46 int usb_drv_release_address(int, usb_address_t); 47 43 48 usb_address_t usb_drv_get_my_address(int, device_t *); 44 49 -
uspace/lib/usb/src/hcdhubd.c
r2cb6571 r54b141a 51 51 */ 52 52 static int add_device(device_t *dev) { 53 bool is_hc = str_cmp(dev->name, USB_HUB_DEVICE_NAME) != 0; 54 printf("%s: add_device(name=\"%s\")\n", hc_driver->name, dev->name); 55 56 if (is_hc) { 57 /* 58 * We are the HC itself. 59 */ 60 return usb_add_hc_device(dev); 61 } else { 62 /* 63 * We are some (maybe deeply nested) hub. 64 * Thus, assign our own operations and explore already 65 * connected devices. 66 */ 67 return usb_add_hub_device(dev); 68 } 53 return ENOTSUP; 69 54 } 70 55 … … 105 90 * @return Error code. 106 91 */ 107 int usb_hcd_add_root_hub(usb_hc_device_t *dev) { 92 int usb_hcd_add_root_hub(device_t *dev) 93 { 108 94 char *id; 109 int rc = asprintf(&id, "usb&h c=%s&hub", hc_driver->name);95 int rc = asprintf(&id, "usb&hub"); 110 96 if (rc <= 0) { 111 97 return rc; 112 98 } 113 99 114 rc = usb_hc_add_child_device(dev ->generic, USB_HUB_DEVICE_NAME, id, true);100 rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true); 115 101 if (rc != EOK) { 116 102 free(id); -
uspace/lib/usb/src/hcdhubd_private.h
r2cb6571 r54b141a 46 46 usb_address_t usb_get_address_by_handle(devman_handle_t); 47 47 int usb_add_hc_device(device_t *); 48 int usb_add_hub_device(device_t *);49 48 50 49 /** lowest allowed usb address */ -
uspace/lib/usb/src/hcdrv.c
r2cb6571 r54b141a 47 47 LIST_INITIALIZE(hc_list); 48 48 49 /* Fake driver to have the name item initialized. */ 50 static usb_hc_driver_t hc_driver_fake = { 51 .name = "HCD", 52 }; 53 49 54 /** Our HC driver. */ 50 usb_hc_driver_t *hc_driver = NULL;55 usb_hc_driver_t *hc_driver = &hc_driver_fake; 51 56 52 57 int usb_lowest_address = 1; … … 86 91 int usb_add_hc_device(device_t *dev) 87 92 { 93 return ENOTSUP; 88 94 usb_hc_device_t *hc_dev = usb_hc_device_create(dev); 89 95 -
uspace/lib/usb/src/usbdrv.c
r2cb6571 r54b141a 100 100 } 101 101 102 /** Tell HC to reserve default address. 103 * 104 * @param phone Open phone to host controller driver. 105 * @return Error code. 106 */ 107 int usb_drv_reserve_default_address(int phone) 108 { 109 return async_req_0_0(phone, IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS); 110 } 111 112 /** Tell HC to release default address. 113 * 114 * @param phone Open phone to host controller driver. 115 * @return Error code. 116 */ 117 int usb_drv_release_default_address(int phone) 118 { 119 return async_req_0_0(phone, IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS); 120 } 121 122 /** Ask HC for free address assignment. 123 * 124 * @param phone Open phone to host controller driver. 125 * @return Assigned USB address or negative error code. 126 */ 127 usb_address_t usb_drv_request_address(int phone) 128 { 129 ipcarg_t address; 130 int rc = async_req_0_1(phone, IPC_M_USBHC_REQUEST_ADDRESS, &address); 131 if (rc != EOK) { 132 return rc; 133 } else { 134 return (usb_address_t) address; 135 } 136 } 137 138 /** Inform HC about address release. 139 * 140 * @param phone Open phone to host controller driver. 141 * @param address Address to be released. 142 * @return Error code. 143 */ 144 int usb_drv_release_address(int phone, usb_address_t address) 145 { 146 return async_req_1_0(phone, IPC_M_USBHC_RELEASE_ADDRESS, address); 147 } 148 102 149 /** Send data to HCD. 103 150 *
Note:
See TracChangeset
for help on using the changeset viewer.