source: mainline/uspace/lib/usbhost/src/usb_device_manager.c@ c59dbdd5

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since c59dbdd5 was bbd09694, checked in by Jan Vesely <jano.vesely@…>, 14 years ago

libusbhost: Make sure USB_DEFAULT_ADDRESS won't get assigned if not in strict mode
  • Property mode set to 100644
File size: 7.6 KB
Line 
1/*
2 * Copyright (c) 2011 Jan Vesely
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libusbhost
30 * @{
31 */
32/** @file
33 * Device manager structure and functions (implementation).
34 */
35#include <assert.h>
36#include <errno.h>
37#include <usb/debug.h>
38#include <usb/host/usb_device_manager.h>
39
40/** Get a free USB address
41 *
42 * @param[in] instance Device manager structure to use.
43 * @param[in] speed Speed of the device requiring address.
44 * @return Free address, or error code.
45 */
46static usb_address_t usb_device_manager_get_free_address(
47 usb_device_manager_t *instance)
48{
49
50 usb_address_t new_address = instance->last_address;
51 do {
52 new_address = (new_address + 1) % USB_ADDRESS_COUNT;
53 if (new_address == USB_ADDRESS_DEFAULT)
54 new_address = 1;
55 if (new_address == instance->last_address) {
56 return ENOSPC;
57 }
58 } while (instance->devices[new_address].occupied);
59
60 assert(new_address != USB_ADDRESS_DEFAULT);
61 instance->last_address = new_address;
62
63 return new_address;
64}
65/*----------------------------------------------------------------------------*/
66/** Initialize device manager structure.
67 *
68 * @param[in] instance Memory place to initialize.
69 * @param[in] max_speed Maximum allowed USB speed of devices (inclusive).
70 *
71 * Set all values to false/0.
72 */
73void usb_device_manager_init(
74 usb_device_manager_t *instance, usb_speed_t max_speed)
75{
76 assert(instance);
77 for (unsigned i = 0; i < USB_ADDRESS_COUNT; ++i) {
78 instance->devices[i].occupied = false;
79 instance->devices[i].handle = 0;
80 instance->devices[i].speed = USB_SPEED_MAX;
81 }
82 instance->last_address = 1;
83 instance->max_speed = max_speed;
84 fibril_mutex_initialize(&instance->guard);
85}
86/*----------------------------------------------------------------------------*/
87/** Request USB address.
88 * @param instance usb_device_manager
89 * @param address Pointer to requested address value, place to store new address
90 * @parma strict Fail if the requested address is not available.
91 * @return Error code.
92 * @note Default address is only available in strict mode.
93 */
94int usb_device_manager_request_address(usb_device_manager_t *instance,
95 usb_address_t *address, bool strict, usb_speed_t speed)
96{
97 assert(instance);
98 assert(address);
99 if (speed > instance->max_speed)
100 return ENOTSUP;
101
102 if ((*address) < 0 || (*address) >= USB_ADDRESS_COUNT)
103 return EINVAL;
104
105 fibril_mutex_lock(&instance->guard);
106 /* Only grant default address to strict requests */
107 if (( (*address) == USB_ADDRESS_DEFAULT) && !strict) {
108 *address = instance->last_address;
109 }
110
111 if (instance->devices[*address].occupied) {
112 if (strict) {
113 fibril_mutex_unlock(&instance->guard);
114 return ENOENT;
115 }
116 *address = usb_device_manager_get_free_address(instance);
117 }
118 assert(instance->devices[*address].occupied == false);
119 assert(instance->devices[*address].handle == 0);
120 assert(*address != USB_ADDRESS_DEFAULT || strict);
121
122 instance->devices[*address].occupied = true;
123 instance->devices[*address].speed = speed;
124
125 fibril_mutex_unlock(&instance->guard);
126 return EOK;
127}
128/*----------------------------------------------------------------------------*/
129/** Bind USB address to devman handle.
130 *
131 * @param[in] instance Device manager structure to use.
132 * @param[in] address Device address
133 * @param[in] handle Devman handle of the device.
134 * @return Error code.
135 */
136int usb_device_manager_bind_address(usb_device_manager_t *instance,
137 usb_address_t address, devman_handle_t handle)
138{
139 if ((address <= 0) || (address >= USB_ADDRESS_COUNT)) {
140 return EINVAL;
141 }
142 assert(instance);
143
144 fibril_mutex_lock(&instance->guard);
145 /* Not reserved */
146 if (!instance->devices[address].occupied) {
147 fibril_mutex_unlock(&instance->guard);
148 return ENOENT;
149 }
150 /* Already bound */
151 if (instance->devices[address].handle != 0) {
152 fibril_mutex_unlock(&instance->guard);
153 return EEXISTS;
154 }
155 instance->devices[address].handle = handle;
156 fibril_mutex_unlock(&instance->guard);
157 return EOK;
158}
159/*----------------------------------------------------------------------------*/
160/** Release used USB address.
161 *
162 * @param[in] instance Device manager structure to use.
163 * @param[in] address Device address
164 * @return Error code.
165 */
166int usb_device_manager_release_address(
167 usb_device_manager_t *instance, usb_address_t address)
168{
169 if ((address < 0) || (address >= USB_ADDRESS_COUNT)) {
170 return EINVAL;
171 }
172 assert(instance);
173
174 fibril_mutex_lock(&instance->guard);
175 if (!instance->devices[address].occupied) {
176 fibril_mutex_unlock(&instance->guard);
177 return ENOENT;
178 }
179
180 instance->devices[address].occupied = false;
181 instance->devices[address].handle = 0;
182 fibril_mutex_unlock(&instance->guard);
183 return EOK;
184}
185/*----------------------------------------------------------------------------*/
186/** Find USB address associated with the device
187 *
188 * @param[in] instance Device manager structure to use.
189 * @param[in] handle Devman handle of the device seeking its address.
190 * @return USB Address, or error code.
191 */
192usb_address_t usb_device_manager_find_address(
193 usb_device_manager_t *instance, devman_handle_t handle)
194{
195 assert(instance);
196 fibril_mutex_lock(&instance->guard);
197 for (usb_address_t address = 1; address <= USB11_ADDRESS_MAX; ++address)
198 {
199 if (instance->devices[address].handle == handle) {
200 assert(instance->devices[address].occupied);
201 fibril_mutex_unlock(&instance->guard);
202 return address;
203 }
204 }
205 fibril_mutex_unlock(&instance->guard);
206 return ENOENT;
207}
208/*----------------------------------------------------------------------------*/
209/** Find devman handle and speed assigned to USB address.
210 * Intentionally refuse to work on default address.
211 *
212 * @param[in] instance Device manager structure to use.
213 * @param[in] address Address the caller wants to find.
214 * @param[out] handle Where to store found handle.
215 * @param[out] speed Assigned speed.
216 * @return Error code.
217 */
218int usb_device_manager_get_info_by_address(usb_device_manager_t *instance,
219 usb_address_t address, devman_handle_t *handle, usb_speed_t *speed)
220{
221 assert(instance);
222 if ((address < 0) || (address >= USB_ADDRESS_COUNT)) {
223 return EINVAL;
224 }
225
226 fibril_mutex_lock(&instance->guard);
227 if (!instance->devices[address].occupied) {
228 fibril_mutex_unlock(&instance->guard);
229 return ENOENT;
230 }
231
232 if (handle != NULL) {
233 *handle = instance->devices[address].handle;
234 }
235 if (speed != NULL) {
236 *speed = instance->devices[address].speed;
237 }
238
239 fibril_mutex_unlock(&instance->guard);
240 return EOK;
241}
242/**
243 * @}
244 */
Note: See TracBrowser for help on using the repository browser.