Error Trace
[Home]
Bug # 48
Show/hide error trace| Error trace
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--68_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8072/dscv_tempdir/dscv/rcv/68_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/net/wireless/rsi/rsi_91x_usb.o.i() { 535 -rsi_dev_table[ 0 ].match_flags = 3; rsi_dev_table[ 0 ].idVendor = 771; rsi_dev_table[ 0 ].idProduct = 256; rsi_dev_table[ 0 ].bcdDevice_lo = 0; rsi_dev_table[ 0 ].bcdDevice_hi = 0; rsi_dev_table[ 0 ].bDeviceClass = 0; rsi_dev_table[ 0 ].bDeviceSubClass = 0; rsi_dev_table[ 0 ].bDeviceProtocol = 0; rsi_dev_table[ 0 ].bInterfaceClass = 0; rsi_dev_table[ 0 ].bInterfaceSubClass = 0; rsi_dev_table[ 0 ].bInterfaceProtocol = 0; rsi_dev_table[ 0 ].bInterfaceNumber = 0; rsi_dev_table[ 0 ].driver_info = 0; rsi_dev_table[ 1 ].match_flags = 3; rsi_dev_table[ 1 ].idVendor = 1051; rsi_dev_table[ 1 ].idProduct = 769; rsi_dev_table[ 1 ].bcdDevice_lo = 0; rsi_dev_table[ 1 ].bcdDevice_hi = 0; rsi_dev_table[ 1 ].bDeviceClass = 0; rsi_dev_table[ 1 ].bDeviceSubClass = 0; rsi_dev_table[ 1 ].bDeviceProtocol = 0; rsi_dev_table[ 1 ].bInterfaceClass = 0; rsi_dev_table[ 1 ].bInterfaceSubClass = 0; rsi_dev_table[ 1 ].bInterfaceProtocol = 0; rsi_dev_table[ 1 ].bInterfaceNumber = 0; rsi_dev_table[ 1 ].driver_info = 0; rsi_dev_table[ 2 ].match_flags = 3; rsi_dev_table[ 2 ].idVendor = 1051; rsi_dev_table[ 2 ].idProduct = 513; rsi_dev_table[ 2 ].bcdDevice_lo = 0; rsi_dev_table[ 2 ].bcdDevice_hi = 0; rsi_dev_table[ 2 ].bDeviceClass = 0; rsi_dev_table[ 2 ].bDeviceSubClass = 0; rsi_dev_table[ 2 ].bDeviceProtocol = 0; rsi_dev_table[ 2 ].bInterfaceClass = 0; rsi_dev_table[ 2 ].bInterfaceSubClass = 0; rsi_dev_table[ 2 ].bInterfaceProtocol = 0; rsi_dev_table[ 2 ].bInterfaceNumber = 0; rsi_dev_table[ 2 ].driver_info = 0; rsi_dev_table[ 3 ].match_flags = 3; rsi_dev_table[ 3 ].idVendor = 1051; rsi_dev_table[ 3 ].idProduct = 37680; rsi_dev_table[ 3 ].bcdDevice_lo = 0; rsi_dev_table[ 3 ].bcdDevice_hi = 0; rsi_dev_table[ 3 ].bDeviceClass = 0; rsi_dev_table[ 3 ].bDeviceSubClass = 0; rsi_dev_table[ 3 ].bDeviceProtocol = 0; rsi_dev_table[ 3 ].bInterfaceClass = 0; rsi_dev_table[ 3 ].bInterfaceSubClass = 0; rsi_dev_table[ 3 ].bInterfaceProtocol = 0; rsi_dev_table[ 3 ].bInterfaceNumber = 0; rsi_dev_table[ 3 ].driver_info = 0; rsi_dev_table[ 4 ].match_flags = 0; rsi_dev_table[ 4 ].idVendor = 0; rsi_dev_table[ 4 ].idProduct = 0; rsi_dev_table[ 4 ].bcdDevice_lo = 0; rsi_dev_table[ 4 ].bcdDevice_hi = 0; rsi_dev_table[ 4 ].bDeviceClass = 0; rsi_dev_table[ 4 ].bDeviceSubClass = 0; rsi_dev_table[ 4 ].bDeviceProtocol = 0; rsi_dev_table[ 4 ].bInterfaceClass = 0; rsi_dev_table[ 4 ].bInterfaceSubClass = 0; rsi_dev_table[ 4 ].bInterfaceProtocol = 0; rsi_dev_table[ 4 ].bInterfaceNumber = 0; rsi_dev_table[ 4 ].driver_info = 0; rsi_driver.name = "RSI-USB WLAN"; rsi_driver.probe = &(rsi_probe); rsi_driver.disconnect = &(rsi_disconnect); rsi_driver.unlocked_ioctl = 0; rsi_driver.suspend = &(rsi_suspend); rsi_driver.resume = &(rsi_resume); rsi_driver.reset_resume = 0; rsi_driver.pre_reset = 0; rsi_driver.post_reset = 0; rsi_driver.id_table = &(rsi_dev_table); rsi_driver.dynids.lock.__annonCompField19.rlock.raw_lock.__annonCompField7.head_tail = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.magic = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.owner_cpu = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.owner = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.dep_map.key = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.dep_map.class_cache[ 0 ] = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.dep_map.class_cache[ 1 ] = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.dep_map.name = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.dep_map.cpu = 0; rsi_driver.dynids.lock.__annonCompField19.rlock.dep_map.ip = 0; rsi_driver.dynids.list.next = 0; rsi_driver.dynids.list.prev = 0; rsi_driver.drvwrap.driver.name = 0; rsi_driver.drvwrap.driver.bus = 0; rsi_driver.drvwrap.driver.owner = 0; rsi_driver.drvwrap.driver.mod_name = 0; rsi_driver.drvwrap.driver.suppress_bind_attrs = 0; rsi_driver.drvwrap.driver.of_match_table = 0; rsi_driver.drvwrap.driver.acpi_match_table = 0; rsi_driver.drvwrap.driver.probe = 0; rsi_driver.drvwrap.driver.remove = 0; rsi_driver.drvwrap.driver.shutdown = 0; rsi_driver.drvwrap.driver.suspend = 0; rsi_driver.drvwrap.driver.resume = 0; rsi_driver.drvwrap.driver.groups = 0; rsi_driver.drvwrap.driver.pm = 0; rsi_driver.drvwrap.driver.p = 0; rsi_driver.drvwrap.for_devices = 0; rsi_driver.no_dynamic_id = 0; rsi_driver.supports_autosuspend = 0; rsi_driver.disable_hub_initiated_lpm = 0; rsi_driver.soft_unbind = 0; return ; } -__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--68_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8072/dscv_tempdir/dscv/rcv/68_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/net/wireless/rsi/rsi_91x_usb_ops.o.i() { return ; } -__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--68_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8072/dscv_tempdir/dscv/rcv/68_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp//home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--68_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8072/dscv_tempdir/rule-instrumentor/68_1a/common-model/ldv_common_model.o.i() { 702 ldv_initialize() { /* Function call is skipped due to function is undefined */} 715 ldv_handler_precall() { /* Function call is skipped due to function is undefined */} { 562 usb_register_driver(&(rsi_driver), &(__this_module), "rsi_usb") { /* Function call is skipped due to function is undefined */} 563 rsi_dbg(4, "%s: Registering driver\n", "rsi_module_init") { /* Function call is skipped due to function is undefined */} 564 __retres1 = 0; } 721 tmp___1 = nondet_int() { /* Function call is skipped due to function is undefined */} 725 tmp___0 = nondet_int() { /* Function call is skipped due to function is undefined */} { 450 rsi_dbg(4, "%s: Init function called\n", "rsi_probe") { /* Function call is skipped due to function is undefined */} 452 adapter = rsi_91x_init() { /* Function call is skipped due to function is undefined */} { 378 common = *(adapter).priv; { { } 462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */} } 381 rsi_dev = tmp; 385 *(adapter).rsi_dev = rsi_dev; 391 *(adapter).device = &(pfunction)->dev; { 462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */} } 394 *(common).rx_data_pkt = tmp___1; { 462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */} } 401 *(rsi_dev).tx_buffer = tmp___2; { { } 43 tmp = ldv_undef_ptr() { /* Function call is skipped due to function is undefined */} 43 arbitrary_memory = tmp; 50 ldv_urb_state = ldv_urb_state + 1; 52 __retres3 = arbitrary_memory; } 403 -cil_11 = *(adapter).priv; *(*(rsi_dev).rx_usb_urb[ 0 ]).transfer_buffer = *(cil_11).rx_data_pkt; *(rsi_dev).tx_blk_size = 252; *(adapter).rx_urb_submit = &(rsi_rx_urb_submit); *(adapter).host_intf_write_pkt = &(rsi_usb_host_intf_write_pkt); *(adapter).check_hw_queue_status = &(rsi_usb_check_queue_status); *(adapter).determine_event_timeout = &(rsi_usb_event_timeout); { { 39 *(v).counter = i; 37 return ; } 31 __init_waitqueue_head(&(pevent)->event_queue, "&pevent->event_queue", &(__key)) { /* Function call is skipped due to function is undefined */} 32 __retres3 = 0; 28 return __retres3; } 413 -status = rsi_create_kthread(common /* common */, &(rsi_dev)->rx_thread /* thread */, &(rsi_usb_rx_thread) /* func_ptr */, "RX-Thread" /* name */) { { 75 *(x).done = 0; 76 __init_waitqueue_head(&(x)->wait, "&x->wait", &(__key)) { /* Function call is skipped due to function is undefined */} 73 return ; } 66 tmp = kthread_create_on_node(func_ptr, common, -1, "%s", name) { /* Function call is skipped due to function is undefined */} 66 __k = tmp; 66 assume(tmp___0 != 0); 66 tmp___1 = 0; 66 assume(tmp___1 == 0); 66 *(thread).task = __k; 67 assume(tmp___3 != 0); 68 __retres11 = tmp___2; 60 return __retres11; } 416 rsi_dbg(1, "%s: Unable to init rx thrd\n", "rsi_init_usb_interface") { /* Function call is skipped due to function is undefined */} 429 kfree(*(rsi_dev).tx_buffer) { /* Function call is skipped due to function is undefined */} 430 kfree(*(common).rx_data_pkt) { /* Function call is skipped due to function is undefined */} 431 __retres12 = status; } 460 rsi_dbg(1, "%s: Failed to init usb interface\n", "rsi_probe") { /* Function call is skipped due to function is undefined */} 495 rsi_91x_deinit(adapter) { /* Function call is skipped due to function is undefined */} 496 rsi_dbg(1, "%s: Failed in probe...Exiting\n", "rsi_probe") { /* Function call is skipped due to function is undefined */} 497 __retres11 = 1; } 739 ldv_check_return_value(res_rsi_probe_11) { /* Function call is skipped due to function is undefined */} 740 ldv_check_return_value_probe(res_rsi_probe_11) { /* Function call is skipped due to function is undefined */} 853 ldv_handler_precall() { /* Function call is skipped due to function is undefined */} { } 575 usb_deregister(&(rsi_driver)) { /* Function call is skipped due to function is undefined */} 576 rsi_dbg(2, "%s: Unregistering driver\n", "rsi_module_exit") { /* Function call is skipped due to function is undefined */} 573 return ; } | Source code
1 #ifndef _ASM_X86_ATOMIC_H
2 #define _ASM_X86_ATOMIC_H
3
4 #include <linux/compiler.h>
5 #include <linux/types.h>
6 #include <asm/processor.h>
7 #include <asm/alternative.h>
8 #include <asm/cmpxchg.h>
9 #include <asm/rmwcc.h>
10 #include <asm/barrier.h>
11
12 /*
13 * Atomic operations that C can't guarantee us. Useful for
14 * resource counting etc..
15 */
16
17 #define ATOMIC_INIT(i) { (i) }
18
19 /**
20 * atomic_read - read atomic variable
21 * @v: pointer of type atomic_t
22 *
23 * Atomically reads the value of @v.
24 */
25 static inline int atomic_read(const atomic_t *v)
26 {
27 return (*(volatile int *)&(v)->counter);
28 }
29
30 /**
31 * atomic_set - set atomic variable
32 * @v: pointer of type atomic_t
33 * @i: required value
34 *
35 * Atomically sets the value of @v to @i.
36 */
37 static inline void atomic_set(atomic_t *v, int i)
38 {
39 v->counter = i;
40 }
41
42 /**
43 * atomic_add - add integer to atomic variable
44 * @i: integer value to add
45 * @v: pointer of type atomic_t
46 *
47 * Atomically adds @i to @v.
48 */
49 static inline void atomic_add(int i, atomic_t *v)
50 {
51 asm volatile(LOCK_PREFIX "addl %1,%0"
52 : "+m" (v->counter)
53 : "ir" (i));
54 }
55
56 /**
57 * atomic_sub - subtract integer from atomic variable
58 * @i: integer value to subtract
59 * @v: pointer of type atomic_t
60 *
61 * Atomically subtracts @i from @v.
62 */
63 static inline void atomic_sub(int i, atomic_t *v)
64 {
65 asm volatile(LOCK_PREFIX "subl %1,%0"
66 : "+m" (v->counter)
67 : "ir" (i));
68 }
69
70 /**
71 * atomic_sub_and_test - subtract value from variable and test result
72 * @i: integer value to subtract
73 * @v: pointer of type atomic_t
74 *
75 * Atomically subtracts @i from @v and returns
76 * true if the result is zero, or false for all
77 * other cases.
78 */
79 static inline int atomic_sub_and_test(int i, atomic_t *v)
80 {
81 GEN_BINARY_RMWcc(LOCK_PREFIX "subl", v->counter, "er", i, "%0", "e");
82 }
83
84 /**
85 * atomic_inc - increment atomic variable
86 * @v: pointer of type atomic_t
87 *
88 * Atomically increments @v by 1.
89 */
90 static inline void atomic_inc(atomic_t *v)
91 {
92 asm volatile(LOCK_PREFIX "incl %0"
93 : "+m" (v->counter));
94 }
95
96 /**
97 * atomic_dec - decrement atomic variable
98 * @v: pointer of type atomic_t
99 *
100 * Atomically decrements @v by 1.
101 */
102 static inline void atomic_dec(atomic_t *v)
103 {
104 asm volatile(LOCK_PREFIX "decl %0"
105 : "+m" (v->counter));
106 }
107
108 /**
109 * atomic_dec_and_test - decrement and test
110 * @v: pointer of type atomic_t
111 *
112 * Atomically decrements @v by 1 and
113 * returns true if the result is 0, or false for all other
114 * cases.
115 */
116 static inline int atomic_dec_and_test(atomic_t *v)
117 {
118 GEN_UNARY_RMWcc(LOCK_PREFIX "decl", v->counter, "%0", "e");
119 }
120
121 /**
122 * atomic_inc_and_test - increment and test
123 * @v: pointer of type atomic_t
124 *
125 * Atomically increments @v by 1
126 * and returns true if the result is zero, or false for all
127 * other cases.
128 */
129 static inline int atomic_inc_and_test(atomic_t *v)
130 {
131 GEN_UNARY_RMWcc(LOCK_PREFIX "incl", v->counter, "%0", "e");
132 }
133
134 /**
135 * atomic_add_negative - add and test if negative
136 * @i: integer value to add
137 * @v: pointer of type atomic_t
138 *
139 * Atomically adds @i to @v and returns true
140 * if the result is negative, or false when
141 * result is greater than or equal to zero.
142 */
143 static inline int atomic_add_negative(int i, atomic_t *v)
144 {
145 GEN_BINARY_RMWcc(LOCK_PREFIX "addl", v->counter, "er", i, "%0", "s");
146 }
147
148 /**
149 * atomic_add_return - add integer and return
150 * @i: integer value to add
151 * @v: pointer of type atomic_t
152 *
153 * Atomically adds @i to @v and returns @i + @v
154 */
155 static inline int atomic_add_return(int i, atomic_t *v)
156 {
157 return i + xadd(&v->counter, i);
158 }
159
160 /**
161 * atomic_sub_return - subtract integer and return
162 * @v: pointer of type atomic_t
163 * @i: integer value to subtract
164 *
165 * Atomically subtracts @i from @v and returns @v - @i
166 */
167 static inline int atomic_sub_return(int i, atomic_t *v)
168 {
169 return atomic_add_return(-i, v);
170 }
171
172 #define atomic_inc_return(v) (atomic_add_return(1, v))
173 #define atomic_dec_return(v) (atomic_sub_return(1, v))
174
175 static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
176 {
177 return cmpxchg(&v->counter, old, new);
178 }
179
180 static inline int atomic_xchg(atomic_t *v, int new)
181 {
182 return xchg(&v->counter, new);
183 }
184
185 /**
186 * __atomic_add_unless - add unless the number is already a given value
187 * @v: pointer of type atomic_t
188 * @a: the amount to add to v...
189 * @u: ...unless v is equal to u.
190 *
191 * Atomically adds @a to @v, so long as @v was not already @u.
192 * Returns the old value of @v.
193 */
194 static inline int __atomic_add_unless(atomic_t *v, int a, int u)
195 {
196 int c, old;
197 c = atomic_read(v);
198 for (;;) {
199 if (unlikely(c == (u)))
200 break;
201 old = atomic_cmpxchg((v), c, c + (a));
202 if (likely(old == c))
203 break;
204 c = old;
205 }
206 return c;
207 }
208
209 /**
210 * atomic_inc_short - increment of a short integer
211 * @v: pointer to type int
212 *
213 * Atomically adds 1 to @v
214 * Returns the new value of @u
215 */
216 static inline short int atomic_inc_short(short int *v)
217 {
218 asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v));
219 return *v;
220 }
221
222 #ifdef CONFIG_X86_64
223 /**
224 * atomic_or_long - OR of two long integers
225 * @v1: pointer to type unsigned long
226 * @v2: pointer to type unsigned long
227 *
228 * Atomically ORs @v1 and @v2
229 * Returns the result of the OR
230 */
231 static inline void atomic_or_long(unsigned long *v1, unsigned long v2)
232 {
233 asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2));
234 }
235 #endif
236
237 /* These are x86-specific, used by some header files */
238 #define atomic_clear_mask(mask, addr) \
239 asm volatile(LOCK_PREFIX "andl %0,%1" \
240 : : "r" (~(mask)), "m" (*(addr)) : "memory")
241
242 #define atomic_set_mask(mask, addr) \
243 asm volatile(LOCK_PREFIX "orl %0,%1" \
244 : : "r" ((unsigned)(mask)), "m" (*(addr)) \
245 : "memory")
246
247 #ifdef CONFIG_X86_32
248 # include <asm/atomic64_32.h>
249 #else
250 # include <asm/atomic64_64.h>
251 #endif
252
253 #endif /* _ASM_X86_ATOMIC_H */ 1
2 /**
3 * Copyright (c) 2014 Redpine Signals Inc.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 *
17 */
18
19 #include <linux/module.h>
20 #include "rsi_usb.h"
21
22 /**
23 * rsi_usb_card_write() - This function writes to the USB Card.
24 * @adapter: Pointer to the adapter structure.
25 * @buf: Pointer to the buffer from where the data has to be taken.
26 * @len: Length to be written.
27 * @endpoint: Type of endpoint.
28 *
29 * Return: status: 0 on success, -1 on failure.
30 */
31 static int rsi_usb_card_write(struct rsi_hw *adapter,
32 void *buf,
33 u16 len,
34 u8 endpoint)
35 {
36 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
37 int status;
38 s32 transfer;
39
40 status = usb_bulk_msg(dev->usbdev,
41 usb_sndbulkpipe(dev->usbdev,
42 dev->bulkout_endpoint_addr[endpoint - 1]),
43 buf,
44 len,
45 &transfer,
46 HZ * 5);
47
48 if (status < 0) {
49 rsi_dbg(ERR_ZONE,
50 "Card write failed with error code :%10d\n", status);
51 dev->write_fail = 1;
52 }
53 return status;
54 }
55
56 /**
57 * rsi_write_multiple() - This function writes multiple bytes of information
58 * to the USB card.
59 * @adapter: Pointer to the adapter structure.
60 * @addr: Address of the register.
61 * @data: Pointer to the data that has to be written.
62 * @count: Number of multiple bytes to be written.
63 *
64 * Return: 0 on success, -1 on failure.
65 */
66 static int rsi_write_multiple(struct rsi_hw *adapter,
67 u8 endpoint,
68 u8 *data,
69 u32 count)
70 {
71 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
72 u8 *seg = dev->tx_buffer;
73
74 if (dev->write_fail)
75 return 0;
76
77 if (endpoint == MGMT_EP) {
78 memset(seg, 0, RSI_USB_TX_HEAD_ROOM);
79 memcpy(seg + RSI_USB_TX_HEAD_ROOM, data, count);
80 } else {
81 seg = ((u8 *)data - RSI_USB_TX_HEAD_ROOM);
82 }
83
84 return rsi_usb_card_write(adapter,
85 seg,
86 count + RSI_USB_TX_HEAD_ROOM,
87 endpoint);
88 }
89
90 /**
91 * rsi_find_bulk_in_and_out_endpoints() - This function initializes the bulk
92 * endpoints to the device.
93 * @interface: Pointer to the USB interface structure.
94 * @adapter: Pointer to the adapter structure.
95 *
96 * Return: ret_val: 0 on success, -ENOMEM on failure.
97 */
98 static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface,
99 struct rsi_hw *adapter)
100 {
101 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
102 struct usb_host_interface *iface_desc;
103 struct usb_endpoint_descriptor *endpoint;
104 __le16 buffer_size;
105 int ii, bep_found = 0;
106
107 iface_desc = &(interface->altsetting[0]);
108
109 for (ii = 0; ii < iface_desc->desc.bNumEndpoints; ++ii) {
110 endpoint = &(iface_desc->endpoint[ii].desc);
111
112 if ((!(dev->bulkin_endpoint_addr)) &&
113 (endpoint->bEndpointAddress & USB_DIR_IN) &&
114 ((endpoint->bmAttributes &
115 USB_ENDPOINT_XFERTYPE_MASK) ==
116 USB_ENDPOINT_XFER_BULK)) {
117 buffer_size = endpoint->wMaxPacketSize;
118 dev->bulkin_size = buffer_size;
119 dev->bulkin_endpoint_addr =
120 endpoint->bEndpointAddress;
121 }
122
123 if (!dev->bulkout_endpoint_addr[bep_found] &&
124 !(endpoint->bEndpointAddress & USB_DIR_IN) &&
125 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
126 USB_ENDPOINT_XFER_BULK)) {
127 dev->bulkout_endpoint_addr[bep_found] =
128 endpoint->bEndpointAddress;
129 buffer_size = endpoint->wMaxPacketSize;
130 dev->bulkout_size[bep_found] = buffer_size;
131 bep_found++;
132 }
133
134 if (bep_found >= MAX_BULK_EP)
135 break;
136 }
137
138 if (!(dev->bulkin_endpoint_addr) &&
139 (dev->bulkout_endpoint_addr[0]))
140 return -EINVAL;
141
142 return 0;
143 }
144
145 /* rsi_usb_reg_read() - This function reads data from given register address.
146 * @usbdev: Pointer to the usb_device structure.
147 * @reg: Address of the register to be read.
148 * @value: Value to be read.
149 * @len: length of data to be read.
150 *
151 * Return: status: 0 on success, -1 on failure.
152 */
153 static int rsi_usb_reg_read(struct usb_device *usbdev,
154 u32 reg,
155 u16 *value,
156 u16 len)
157 {
158 u8 *buf;
159 int status = -ENOMEM;
160
161 buf = kmalloc(0x04, GFP_KERNEL);
162 if (!buf)
163 return status;
164
165 status = usb_control_msg(usbdev,
166 usb_rcvctrlpipe(usbdev, 0),
167 USB_VENDOR_REGISTER_READ,
168 USB_TYPE_VENDOR,
169 ((reg & 0xffff0000) >> 16), (reg & 0xffff),
170 (void *)buf,
171 len,
172 HZ * 5);
173
174 *value = (buf[0] | (buf[1] << 8));
175 if (status < 0) {
176 rsi_dbg(ERR_ZONE,
177 "%s: Reg read failed with error code :%d\n",
178 __func__, status);
179 }
180 kfree(buf);
181
182 return status;
183 }
184
185 /**
186 * rsi_usb_reg_write() - This function writes the given data into the given
187 * register address.
188 * @usbdev: Pointer to the usb_device structure.
189 * @reg: Address of the register.
190 * @value: Value to write.
191 * @len: Length of data to be written.
192 *
193 * Return: status: 0 on success, -1 on failure.
194 */
195 static int rsi_usb_reg_write(struct usb_device *usbdev,
196 u32 reg,
197 u16 value,
198 u16 len)
199 {
200 u8 *usb_reg_buf;
201 int status = -ENOMEM;
202
203 usb_reg_buf = kmalloc(0x04, GFP_KERNEL);
204 if (!usb_reg_buf)
205 return status;
206
207 usb_reg_buf[0] = (value & 0x00ff);
208 usb_reg_buf[1] = (value & 0xff00) >> 8;
209 usb_reg_buf[2] = 0x0;
210 usb_reg_buf[3] = 0x0;
211
212 status = usb_control_msg(usbdev,
213 usb_sndctrlpipe(usbdev, 0),
214 USB_VENDOR_REGISTER_WRITE,
215 USB_TYPE_VENDOR,
216 ((reg & 0xffff0000) >> 16),
217 (reg & 0xffff),
218 (void *)usb_reg_buf,
219 len,
220 HZ * 5);
221 if (status < 0) {
222 rsi_dbg(ERR_ZONE,
223 "%s: Reg write failed with error code :%d\n",
224 __func__, status);
225 }
226 kfree(usb_reg_buf);
227
228 return status;
229 }
230
231 /**
232 * rsi_rx_done_handler() - This function is called when a packet is received
233 * from USB stack. This is callback to recieve done.
234 * @urb: Received URB.
235 *
236 * Return: None.
237 */
238 static void rsi_rx_done_handler(struct urb *urb)
239 {
240 struct rsi_hw *adapter = urb->context;
241 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
242
243 if (urb->status)
244 return;
245
246 rsi_set_event(&dev->rx_thread.event);
247 }
248
249 /**
250 * rsi_rx_urb_submit() - This function submits the given URB to the USB stack.
251 * @adapter: Pointer to the adapter structure.
252 *
253 * Return: 0 on success, -1 on failure.
254 */
255 static int rsi_rx_urb_submit(struct rsi_hw *adapter)
256 {
257 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
258 struct urb *urb = dev->rx_usb_urb[0];
259 int status;
260
261 usb_fill_bulk_urb(urb,
262 dev->usbdev,
263 usb_rcvbulkpipe(dev->usbdev,
264 dev->bulkin_endpoint_addr),
265 urb->transfer_buffer,
266 3000,
267 rsi_rx_done_handler,
268 adapter);
269
270 status = usb_submit_urb(urb, GFP_KERNEL);
271 if (status)
272 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__);
273
274 return status;
275 }
276
277 /**
278 * rsi_usb_write_register_multiple() - This function writes multiple bytes of
279 * information to multiple registers.
280 * @adapter: Pointer to the adapter structure.
281 * @addr: Address of the register.
282 * @data: Pointer to the data that has to be written.
283 * @count: Number of multiple bytes to be written on to the registers.
284 *
285 * Return: status: 0 on success, -1 on failure.
286 */
287 int rsi_usb_write_register_multiple(struct rsi_hw *adapter,
288 u32 addr,
289 u8 *data,
290 u32 count)
291 {
292 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
293 u8 *buf;
294 u8 transfer;
295 int status = 0;
296
297 buf = kzalloc(4096, GFP_KERNEL);
298 if (!buf)
299 return -ENOMEM;
300
301 while (count) {
302 transfer = (u8)(min_t(u32, count, 4096));
303 memcpy(buf, data, transfer);
304 status = usb_control_msg(dev->usbdev,
305 usb_sndctrlpipe(dev->usbdev, 0),
306 USB_VENDOR_REGISTER_WRITE,
307 USB_TYPE_VENDOR,
308 ((addr & 0xffff0000) >> 16),
309 (addr & 0xffff),
310 (void *)buf,
311 transfer,
312 HZ * 5);
313 if (status < 0) {
314 rsi_dbg(ERR_ZONE,
315 "Reg write failed with error code :%d\n",
316 status);
317 } else {
318 count -= transfer;
319 data += transfer;
320 addr += transfer;
321 }
322 }
323
324 kfree(buf);
325 return 0;
326 }
327
328 /**
329 *rsi_usb_host_intf_write_pkt() - This function writes the packet to the
330 * USB card.
331 * @adapter: Pointer to the adapter structure.
332 * @pkt: Pointer to the data to be written on to the card.
333 * @len: Length of the data to be written on to the card.
334 *
335 * Return: 0 on success, -1 on failure.
336 */
337 static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter,
338 u8 *pkt,
339 u32 len)
340 {
341 u32 queueno = ((pkt[1] >> 4) & 0xf);
342 u8 endpoint;
343
344 endpoint = ((queueno == RSI_WIFI_MGMT_Q) ? MGMT_EP : DATA_EP);
345
346 return rsi_write_multiple(adapter,
347 endpoint,
348 (u8 *)pkt,
349 len);
350 }
351
352 /**
353 * rsi_deinit_usb_interface() - This function deinitializes the usb interface.
354 * @adapter: Pointer to the adapter structure.
355 *
356 * Return: None.
357 */
358 static void rsi_deinit_usb_interface(struct rsi_hw *adapter)
359 {
360 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
361
362 rsi_kill_thread(&dev->rx_thread);
363 kfree(adapter->priv->rx_data_pkt);
364 kfree(dev->tx_buffer);
365 }
366
367 /**
368 * rsi_init_usb_interface() - This function initializes the usb interface.
369 * @adapter: Pointer to the adapter structure.
370 * @pfunction: Pointer to USB interface structure.
371 *
372 * Return: 0 on success, -1 on failure.
373 */
374 static int rsi_init_usb_interface(struct rsi_hw *adapter,
375 struct usb_interface *pfunction)
376 {
377 struct rsi_91x_usbdev *rsi_dev;
378 struct rsi_common *common = adapter->priv;
379 int status;
380
381 rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL);
382 if (!rsi_dev)
383 return -ENOMEM;
384
385 adapter->rsi_dev = rsi_dev;
386 rsi_dev->usbdev = interface_to_usbdev(pfunction);
387
388 if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter))
389 return -EINVAL;
390
391 adapter->device = &pfunction->dev;
392 usb_set_intfdata(pfunction, adapter);
393
394 common->rx_data_pkt = kmalloc(2048, GFP_KERNEL);
395 if (!common->rx_data_pkt) {
396 rsi_dbg(ERR_ZONE, "%s: Failed to allocate memory\n",
397 __func__);
398 return -ENOMEM;
399 }
400
401 rsi_dev->tx_buffer = kmalloc(2048, GFP_ATOMIC);
402 rsi_dev->rx_usb_urb[0] = usb_alloc_urb(0, GFP_KERNEL);
403 rsi_dev->rx_usb_urb[0]->transfer_buffer = adapter->priv->rx_data_pkt;
404 rsi_dev->tx_blk_size = 252;
405
406 /* Initializing function callbacks */
407 adapter->rx_urb_submit = rsi_rx_urb_submit;
408 adapter->host_intf_write_pkt = rsi_usb_host_intf_write_pkt;
409 adapter->check_hw_queue_status = rsi_usb_check_queue_status;
410 adapter->determine_event_timeout = rsi_usb_event_timeout;
411
412 rsi_init_event(&rsi_dev->rx_thread.event);
413 status = rsi_create_kthread(common, &rsi_dev->rx_thread,
414 rsi_usb_rx_thread, "RX-Thread");
415 if (status) {
416 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
417 goto fail;
418 }
419
420 #ifdef CONFIG_RSI_DEBUGFS
421 /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */
422 adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1);
423 #endif
424
425 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
426 return 0;
427
428 fail:
429 kfree(rsi_dev->tx_buffer);
430 kfree(common->rx_data_pkt);
431 return status;
432 }
433
434 /**
435 * rsi_probe() - This function is called by kernel when the driver provided
436 * Vendor and device IDs are matched. All the initialization
437 * work is done here.
438 * @pfunction: Pointer to the USB interface structure.
439 * @id: Pointer to the usb_device_id structure.
440 *
441 * Return: 0 on success, -1 on failure.
442 */
443 static int rsi_probe(struct usb_interface *pfunction,
444 const struct usb_device_id *id)
445 {
446 struct rsi_hw *adapter;
447 struct rsi_91x_usbdev *dev;
448 u16 fw_status;
449
450 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
451
452 adapter = rsi_91x_init();
453 if (!adapter) {
454 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
455 __func__);
456 return 1;
457 }
458
459 if (rsi_init_usb_interface(adapter, pfunction)) {
460 rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n",
461 __func__);
462 goto err;
463 }
464
465 rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__);
466
467 dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
468
469 if (rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2) < 0)
470 goto err1;
471 else
472 fw_status &= 1;
473
474 if (!fw_status) {
475 if (rsi_usb_device_init(adapter->priv)) {
476 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n",
477 __func__);
478 goto err1;
479 }
480
481 if (rsi_usb_reg_write(dev->usbdev,
482 USB_INTERNAL_REG_1,
483 RSI_USB_READY_MAGIC_NUM, 1) < 0)
484 goto err1;
485 rsi_dbg(INIT_ZONE, "%s: Performed device init\n", __func__);
486 }
487
488 if (rsi_rx_urb_submit(adapter))
489 goto err1;
490
491 return 0;
492 err1:
493 rsi_deinit_usb_interface(adapter);
494 err:
495 rsi_91x_deinit(adapter);
496 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
497 return 1;
498 }
499
500 /**
501 * rsi_disconnect() - This function performs the reverse of the probe function,
502 * it deintialize the driver structure.
503 * @pfunction: Pointer to the USB interface structure.
504 *
505 * Return: None.
506 */
507 static void rsi_disconnect(struct usb_interface *pfunction)
508 {
509 struct rsi_hw *adapter = usb_get_intfdata(pfunction);
510
511 if (!adapter)
512 return;
513
514 rsi_mac80211_detach(adapter);
515 rsi_deinit_usb_interface(adapter);
516 rsi_91x_deinit(adapter);
517
518 rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__);
519 }
520
521 #ifdef CONFIG_PM
522 static int rsi_suspend(struct usb_interface *intf, pm_message_t message)
523 {
524 /* Not yet implemented */
525 return -ENOSYS;
526 }
527
528 static int rsi_resume(struct usb_interface *intf)
529 {
530 /* Not yet implemented */
531 return -ENOSYS;
532 }
533 #endif
534
535 static const struct usb_device_id rsi_dev_table[] = {
536 { USB_DEVICE(0x0303, 0x0100) },
537 { USB_DEVICE(0x041B, 0x0301) },
538 { USB_DEVICE(0x041B, 0x0201) },
539 { USB_DEVICE(0x041B, 0x9330) },
540 { /* Blank */},
541 };
542
543 static struct usb_driver rsi_driver = {
544 .name = "RSI-USB WLAN",
545 .probe = rsi_probe,
546 .disconnect = rsi_disconnect,
547 .id_table = rsi_dev_table,
548 #ifdef CONFIG_PM
549 .suspend = rsi_suspend,
550 .resume = rsi_resume,
551 #endif
552 };
553
554 /**
555 * rsi_module_init() - This function registers the client driver.
556 * @void: Void.
557 *
558 * Return: 0 on success.
559 */
560 static int rsi_module_init(void)
561 {
562 usb_register(&rsi_driver);
563 rsi_dbg(INIT_ZONE, "%s: Registering driver\n", __func__);
564 return 0;
565 }
566
567 /**
568 * rsi_module_exit() - This function unregisters the client driver.
569 * @void: Void.
570 *
571 * Return: None.
572 */
573 static void rsi_module_exit(void)
574 {
575 usb_deregister(&rsi_driver);
576 rsi_dbg(INFO_ZONE, "%s: Unregistering driver\n", __func__);
577 }
578
579 module_init(rsi_module_init);
580 module_exit(rsi_module_exit);
581
582 MODULE_AUTHOR("Redpine Signals Inc");
583 MODULE_DESCRIPTION("Common USB layer for RSI drivers");
584 MODULE_SUPPORTED_DEVICE("RSI-91x");
585 MODULE_DEVICE_TABLE(usb, rsi_dev_table);
586 MODULE_FIRMWARE(FIRMWARE_RSI9113);
587 MODULE_VERSION("0.1");
588 MODULE_LICENSE("Dual BSD/GPL");
589
590
591
592
593
594 /* LDV_COMMENT_BEGIN_MAIN */
595 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful
596
597 /*###########################################################################*/
598
599 /*############## Driver Environment Generator 0.2 output ####################*/
600
601 /*###########################################################################*/
602
603
604
605 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */
606 void ldv_check_final_state(void);
607
608 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */
609 void ldv_check_return_value(int res);
610
611 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */
612 void ldv_check_return_value_probe(int res);
613
614 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */
615 void ldv_initialize(void);
616
617 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */
618 void ldv_handler_precall(void);
619
620 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */
621 int nondet_int(void);
622
623 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */
624 int LDV_IN_INTERRUPT;
625
626 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */
627 void ldv_main0_sequence_infinite_withcheck_stateful(void) {
628
629
630
631 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */
632 /*============================= VARIABLE DECLARATION PART =============================*/
633 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
634 /* content: static int rsi_probe(struct usb_interface *pfunction, const struct usb_device_id *id)*/
635 /* LDV_COMMENT_BEGIN_PREP */
636 #ifdef CONFIG_RSI_DEBUGFS
637 #endif
638 /* LDV_COMMENT_END_PREP */
639 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_probe" */
640 struct usb_interface * var_group1;
641 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_probe" */
642 const struct usb_device_id * var_rsi_probe_11_p1;
643 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "rsi_probe" */
644 static int res_rsi_probe_11;
645 /* LDV_COMMENT_BEGIN_PREP */
646 #ifdef CONFIG_PM
647 #endif
648 #ifdef CONFIG_PM
649 #endif
650 /* LDV_COMMENT_END_PREP */
651 /* content: static void rsi_disconnect(struct usb_interface *pfunction)*/
652 /* LDV_COMMENT_BEGIN_PREP */
653 #ifdef CONFIG_RSI_DEBUGFS
654 #endif
655 /* LDV_COMMENT_END_PREP */
656 /* LDV_COMMENT_BEGIN_PREP */
657 #ifdef CONFIG_PM
658 #endif
659 #ifdef CONFIG_PM
660 #endif
661 /* LDV_COMMENT_END_PREP */
662 /* content: static int rsi_suspend(struct usb_interface *intf, pm_message_t message)*/
663 /* LDV_COMMENT_BEGIN_PREP */
664 #ifdef CONFIG_RSI_DEBUGFS
665 #endif
666 #ifdef CONFIG_PM
667 /* LDV_COMMENT_END_PREP */
668 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_suspend" */
669 pm_message_t var_rsi_suspend_13_p1;
670 /* LDV_COMMENT_BEGIN_PREP */
671 #endif
672 #ifdef CONFIG_PM
673 #endif
674 /* LDV_COMMENT_END_PREP */
675 /* content: static int rsi_resume(struct usb_interface *intf)*/
676 /* LDV_COMMENT_BEGIN_PREP */
677 #ifdef CONFIG_RSI_DEBUGFS
678 #endif
679 #ifdef CONFIG_PM
680 /* LDV_COMMENT_END_PREP */
681 /* LDV_COMMENT_BEGIN_PREP */
682 #endif
683 #ifdef CONFIG_PM
684 #endif
685 /* LDV_COMMENT_END_PREP */
686
687
688
689
690 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */
691 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */
692 /*============================= VARIABLE INITIALIZING PART =============================*/
693 LDV_IN_INTERRUPT=1;
694
695
696
697
698 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */
699 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */
700 /*============================= FUNCTION CALL SECTION =============================*/
701 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */
702 ldv_initialize();
703
704 /** INIT: init_type: ST_MODULE_INIT **/
705 /* content: static int rsi_module_init(void)*/
706 /* LDV_COMMENT_BEGIN_PREP */
707 #ifdef CONFIG_RSI_DEBUGFS
708 #endif
709 #ifdef CONFIG_PM
710 #endif
711 #ifdef CONFIG_PM
712 #endif
713 /* LDV_COMMENT_END_PREP */
714 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver init function after driver loading to kernel. This function declared as "MODULE_INIT(function name)". */
715 ldv_handler_precall();
716 if(rsi_module_init())
717 goto ldv_final;
718 int ldv_s_rsi_driver_usb_driver = 0;
719
720
721 while( nondet_int()
722 || !(ldv_s_rsi_driver_usb_driver == 0)
723 ) {
724
725 switch(nondet_int()) {
726
727 case 0: {
728
729 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
730 if(ldv_s_rsi_driver_usb_driver==0) {
731
732 /* content: static int rsi_probe(struct usb_interface *pfunction, const struct usb_device_id *id)*/
733 /* LDV_COMMENT_BEGIN_PREP */
734 #ifdef CONFIG_RSI_DEBUGFS
735 #endif
736 /* LDV_COMMENT_END_PREP */
737 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "rsi_driver". Standart function test for correct return result. */
738 res_rsi_probe_11 = rsi_probe( var_group1, var_rsi_probe_11_p1);
739 ldv_check_return_value(res_rsi_probe_11);
740 ldv_check_return_value_probe(res_rsi_probe_11);
741 if(res_rsi_probe_11)
742 goto ldv_module_exit;
743 /* LDV_COMMENT_BEGIN_PREP */
744 #ifdef CONFIG_PM
745 #endif
746 #ifdef CONFIG_PM
747 #endif
748 /* LDV_COMMENT_END_PREP */
749 ldv_s_rsi_driver_usb_driver++;
750
751 }
752
753 }
754
755 break;
756 case 1: {
757
758 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
759 if(ldv_s_rsi_driver_usb_driver==1) {
760
761 /* content: static int rsi_suspend(struct usb_interface *intf, pm_message_t message)*/
762 /* LDV_COMMENT_BEGIN_PREP */
763 #ifdef CONFIG_RSI_DEBUGFS
764 #endif
765 #ifdef CONFIG_PM
766 /* LDV_COMMENT_END_PREP */
767 /* LDV_COMMENT_FUNCTION_CALL Function from field "suspend" from driver structure with callbacks "rsi_driver" */
768 ldv_handler_precall();
769 rsi_suspend( var_group1, var_rsi_suspend_13_p1);
770 /* LDV_COMMENT_BEGIN_PREP */
771 #endif
772 #ifdef CONFIG_PM
773 #endif
774 /* LDV_COMMENT_END_PREP */
775 ldv_s_rsi_driver_usb_driver++;
776
777 }
778
779 }
780
781 break;
782 case 2: {
783
784 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
785 if(ldv_s_rsi_driver_usb_driver==2) {
786
787 /* content: static int rsi_resume(struct usb_interface *intf)*/
788 /* LDV_COMMENT_BEGIN_PREP */
789 #ifdef CONFIG_RSI_DEBUGFS
790 #endif
791 #ifdef CONFIG_PM
792 /* LDV_COMMENT_END_PREP */
793 /* LDV_COMMENT_FUNCTION_CALL Function from field "resume" from driver structure with callbacks "rsi_driver" */
794 ldv_handler_precall();
795 rsi_resume( var_group1);
796 /* LDV_COMMENT_BEGIN_PREP */
797 #endif
798 #ifdef CONFIG_PM
799 #endif
800 /* LDV_COMMENT_END_PREP */
801 ldv_s_rsi_driver_usb_driver++;
802
803 }
804
805 }
806
807 break;
808 case 3: {
809
810 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
811 if(ldv_s_rsi_driver_usb_driver==3) {
812
813 /* content: static void rsi_disconnect(struct usb_interface *pfunction)*/
814 /* LDV_COMMENT_BEGIN_PREP */
815 #ifdef CONFIG_RSI_DEBUGFS
816 #endif
817 /* LDV_COMMENT_END_PREP */
818 /* LDV_COMMENT_FUNCTION_CALL Function from field "disconnect" from driver structure with callbacks "rsi_driver" */
819 ldv_handler_precall();
820 rsi_disconnect( var_group1);
821 /* LDV_COMMENT_BEGIN_PREP */
822 #ifdef CONFIG_PM
823 #endif
824 #ifdef CONFIG_PM
825 #endif
826 /* LDV_COMMENT_END_PREP */
827 ldv_s_rsi_driver_usb_driver=0;
828
829 }
830
831 }
832
833 break;
834 default: break;
835
836 }
837
838 }
839
840 ldv_module_exit:
841
842 /** INIT: init_type: ST_MODULE_EXIT **/
843 /* content: static void rsi_module_exit(void)*/
844 /* LDV_COMMENT_BEGIN_PREP */
845 #ifdef CONFIG_RSI_DEBUGFS
846 #endif
847 #ifdef CONFIG_PM
848 #endif
849 #ifdef CONFIG_PM
850 #endif
851 /* LDV_COMMENT_END_PREP */
852 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver release function before driver will be uploaded from kernel. This function declared as "MODULE_EXIT(function name)". */
853 ldv_handler_precall();
854 rsi_module_exit();
855
856 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */
857 ldv_final: ldv_check_final_state();
858
859 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */
860 return;
861
862 }
863 #endif
864
865 /* LDV_COMMENT_END_MAIN */ 1
2 #include <linux/kernel.h>
3 #include <linux/module.h>
4 struct urb;
5 extern void *ldv_usb_alloc_coherent(void);
6 extern struct urb *ldv_usb_alloc_urb(void);
7 extern void ldv_usb_free_coherent(void *addr);
8 extern void ldv_usb_free_urb(struct urb *urb);
9 #line 1 "/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--68_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8072/dscv_tempdir/dscv/ri/68_1a/drivers/net/wireless/rsi/rsi_91x_usb.c"
10
11 /**
12 * Copyright (c) 2014 Redpine Signals Inc.
13 *
14 * Permission to use, copy, modify, and/or distribute this software for any
15 * purpose with or without fee is hereby granted, provided that the above
16 * copyright notice and this permission notice appear in all copies.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
19 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
21 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
22 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
23 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
24 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 *
26 */
27
28 #include <linux/module.h>
29 #include "rsi_usb.h"
30
31 /**
32 * rsi_usb_card_write() - This function writes to the USB Card.
33 * @adapter: Pointer to the adapter structure.
34 * @buf: Pointer to the buffer from where the data has to be taken.
35 * @len: Length to be written.
36 * @endpoint: Type of endpoint.
37 *
38 * Return: status: 0 on success, -1 on failure.
39 */
40 static int rsi_usb_card_write(struct rsi_hw *adapter,
41 void *buf,
42 u16 len,
43 u8 endpoint)
44 {
45 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
46 int status;
47 s32 transfer;
48
49 status = usb_bulk_msg(dev->usbdev,
50 usb_sndbulkpipe(dev->usbdev,
51 dev->bulkout_endpoint_addr[endpoint - 1]),
52 buf,
53 len,
54 &transfer,
55 HZ * 5);
56
57 if (status < 0) {
58 rsi_dbg(ERR_ZONE,
59 "Card write failed with error code :%10d\n", status);
60 dev->write_fail = 1;
61 }
62 return status;
63 }
64
65 /**
66 * rsi_write_multiple() - This function writes multiple bytes of information
67 * to the USB card.
68 * @adapter: Pointer to the adapter structure.
69 * @addr: Address of the register.
70 * @data: Pointer to the data that has to be written.
71 * @count: Number of multiple bytes to be written.
72 *
73 * Return: 0 on success, -1 on failure.
74 */
75 static int rsi_write_multiple(struct rsi_hw *adapter,
76 u8 endpoint,
77 u8 *data,
78 u32 count)
79 {
80 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
81 u8 *seg = dev->tx_buffer;
82
83 if (dev->write_fail)
84 return 0;
85
86 if (endpoint == MGMT_EP) {
87 memset(seg, 0, RSI_USB_TX_HEAD_ROOM);
88 memcpy(seg + RSI_USB_TX_HEAD_ROOM, data, count);
89 } else {
90 seg = ((u8 *)data - RSI_USB_TX_HEAD_ROOM);
91 }
92
93 return rsi_usb_card_write(adapter,
94 seg,
95 count + RSI_USB_TX_HEAD_ROOM,
96 endpoint);
97 }
98
99 /**
100 * rsi_find_bulk_in_and_out_endpoints() - This function initializes the bulk
101 * endpoints to the device.
102 * @interface: Pointer to the USB interface structure.
103 * @adapter: Pointer to the adapter structure.
104 *
105 * Return: ret_val: 0 on success, -ENOMEM on failure.
106 */
107 static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface,
108 struct rsi_hw *adapter)
109 {
110 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
111 struct usb_host_interface *iface_desc;
112 struct usb_endpoint_descriptor *endpoint;
113 __le16 buffer_size;
114 int ii, bep_found = 0;
115
116 iface_desc = &(interface->altsetting[0]);
117
118 for (ii = 0; ii < iface_desc->desc.bNumEndpoints; ++ii) {
119 endpoint = &(iface_desc->endpoint[ii].desc);
120
121 if ((!(dev->bulkin_endpoint_addr)) &&
122 (endpoint->bEndpointAddress & USB_DIR_IN) &&
123 ((endpoint->bmAttributes &
124 USB_ENDPOINT_XFERTYPE_MASK) ==
125 USB_ENDPOINT_XFER_BULK)) {
126 buffer_size = endpoint->wMaxPacketSize;
127 dev->bulkin_size = buffer_size;
128 dev->bulkin_endpoint_addr =
129 endpoint->bEndpointAddress;
130 }
131
132 if (!dev->bulkout_endpoint_addr[bep_found] &&
133 !(endpoint->bEndpointAddress & USB_DIR_IN) &&
134 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
135 USB_ENDPOINT_XFER_BULK)) {
136 dev->bulkout_endpoint_addr[bep_found] =
137 endpoint->bEndpointAddress;
138 buffer_size = endpoint->wMaxPacketSize;
139 dev->bulkout_size[bep_found] = buffer_size;
140 bep_found++;
141 }
142
143 if (bep_found >= MAX_BULK_EP)
144 break;
145 }
146
147 if (!(dev->bulkin_endpoint_addr) &&
148 (dev->bulkout_endpoint_addr[0]))
149 return -EINVAL;
150
151 return 0;
152 }
153
154 /* rsi_usb_reg_read() - This function reads data from given register address.
155 * @usbdev: Pointer to the usb_device structure.
156 * @reg: Address of the register to be read.
157 * @value: Value to be read.
158 * @len: length of data to be read.
159 *
160 * Return: status: 0 on success, -1 on failure.
161 */
162 static int rsi_usb_reg_read(struct usb_device *usbdev,
163 u32 reg,
164 u16 *value,
165 u16 len)
166 {
167 u8 *buf;
168 int status = -ENOMEM;
169
170 buf = kmalloc(0x04, GFP_KERNEL);
171 if (!buf)
172 return status;
173
174 status = usb_control_msg(usbdev,
175 usb_rcvctrlpipe(usbdev, 0),
176 USB_VENDOR_REGISTER_READ,
177 USB_TYPE_VENDOR,
178 ((reg & 0xffff0000) >> 16), (reg & 0xffff),
179 (void *)buf,
180 len,
181 HZ * 5);
182
183 *value = (buf[0] | (buf[1] << 8));
184 if (status < 0) {
185 rsi_dbg(ERR_ZONE,
186 "%s: Reg read failed with error code :%d\n",
187 __func__, status);
188 }
189 kfree(buf);
190
191 return status;
192 }
193
194 /**
195 * rsi_usb_reg_write() - This function writes the given data into the given
196 * register address.
197 * @usbdev: Pointer to the usb_device structure.
198 * @reg: Address of the register.
199 * @value: Value to write.
200 * @len: Length of data to be written.
201 *
202 * Return: status: 0 on success, -1 on failure.
203 */
204 static int rsi_usb_reg_write(struct usb_device *usbdev,
205 u32 reg,
206 u16 value,
207 u16 len)
208 {
209 u8 *usb_reg_buf;
210 int status = -ENOMEM;
211
212 usb_reg_buf = kmalloc(0x04, GFP_KERNEL);
213 if (!usb_reg_buf)
214 return status;
215
216 usb_reg_buf[0] = (value & 0x00ff);
217 usb_reg_buf[1] = (value & 0xff00) >> 8;
218 usb_reg_buf[2] = 0x0;
219 usb_reg_buf[3] = 0x0;
220
221 status = usb_control_msg(usbdev,
222 usb_sndctrlpipe(usbdev, 0),
223 USB_VENDOR_REGISTER_WRITE,
224 USB_TYPE_VENDOR,
225 ((reg & 0xffff0000) >> 16),
226 (reg & 0xffff),
227 (void *)usb_reg_buf,
228 len,
229 HZ * 5);
230 if (status < 0) {
231 rsi_dbg(ERR_ZONE,
232 "%s: Reg write failed with error code :%d\n",
233 __func__, status);
234 }
235 kfree(usb_reg_buf);
236
237 return status;
238 }
239
240 /**
241 * rsi_rx_done_handler() - This function is called when a packet is received
242 * from USB stack. This is callback to recieve done.
243 * @urb: Received URB.
244 *
245 * Return: None.
246 */
247 static void rsi_rx_done_handler(struct urb *urb)
248 {
249 struct rsi_hw *adapter = urb->context;
250 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
251
252 if (urb->status)
253 return;
254
255 rsi_set_event(&dev->rx_thread.event);
256 }
257
258 /**
259 * rsi_rx_urb_submit() - This function submits the given URB to the USB stack.
260 * @adapter: Pointer to the adapter structure.
261 *
262 * Return: 0 on success, -1 on failure.
263 */
264 static int rsi_rx_urb_submit(struct rsi_hw *adapter)
265 {
266 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
267 struct urb *urb = dev->rx_usb_urb[0];
268 int status;
269
270 usb_fill_bulk_urb(urb,
271 dev->usbdev,
272 usb_rcvbulkpipe(dev->usbdev,
273 dev->bulkin_endpoint_addr),
274 urb->transfer_buffer,
275 3000,
276 rsi_rx_done_handler,
277 adapter);
278
279 status = usb_submit_urb(urb, GFP_KERNEL);
280 if (status)
281 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__);
282
283 return status;
284 }
285
286 /**
287 * rsi_usb_write_register_multiple() - This function writes multiple bytes of
288 * information to multiple registers.
289 * @adapter: Pointer to the adapter structure.
290 * @addr: Address of the register.
291 * @data: Pointer to the data that has to be written.
292 * @count: Number of multiple bytes to be written on to the registers.
293 *
294 * Return: status: 0 on success, -1 on failure.
295 */
296 int rsi_usb_write_register_multiple(struct rsi_hw *adapter,
297 u32 addr,
298 u8 *data,
299 u32 count)
300 {
301 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
302 u8 *buf;
303 u8 transfer;
304 int status = 0;
305
306 buf = kzalloc(4096, GFP_KERNEL);
307 if (!buf)
308 return -ENOMEM;
309
310 while (count) {
311 transfer = (u8)(min_t(u32, count, 4096));
312 memcpy(buf, data, transfer);
313 status = usb_control_msg(dev->usbdev,
314 usb_sndctrlpipe(dev->usbdev, 0),
315 USB_VENDOR_REGISTER_WRITE,
316 USB_TYPE_VENDOR,
317 ((addr & 0xffff0000) >> 16),
318 (addr & 0xffff),
319 (void *)buf,
320 transfer,
321 HZ * 5);
322 if (status < 0) {
323 rsi_dbg(ERR_ZONE,
324 "Reg write failed with error code :%d\n",
325 status);
326 } else {
327 count -= transfer;
328 data += transfer;
329 addr += transfer;
330 }
331 }
332
333 kfree(buf);
334 return 0;
335 }
336
337 /**
338 *rsi_usb_host_intf_write_pkt() - This function writes the packet to the
339 * USB card.
340 * @adapter: Pointer to the adapter structure.
341 * @pkt: Pointer to the data to be written on to the card.
342 * @len: Length of the data to be written on to the card.
343 *
344 * Return: 0 on success, -1 on failure.
345 */
346 static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter,
347 u8 *pkt,
348 u32 len)
349 {
350 u32 queueno = ((pkt[1] >> 4) & 0xf);
351 u8 endpoint;
352
353 endpoint = ((queueno == RSI_WIFI_MGMT_Q) ? MGMT_EP : DATA_EP);
354
355 return rsi_write_multiple(adapter,
356 endpoint,
357 (u8 *)pkt,
358 len);
359 }
360
361 /**
362 * rsi_deinit_usb_interface() - This function deinitializes the usb interface.
363 * @adapter: Pointer to the adapter structure.
364 *
365 * Return: None.
366 */
367 static void rsi_deinit_usb_interface(struct rsi_hw *adapter)
368 {
369 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
370
371 rsi_kill_thread(&dev->rx_thread);
372 kfree(adapter->priv->rx_data_pkt);
373 kfree(dev->tx_buffer);
374 }
375
376 /**
377 * rsi_init_usb_interface() - This function initializes the usb interface.
378 * @adapter: Pointer to the adapter structure.
379 * @pfunction: Pointer to USB interface structure.
380 *
381 * Return: 0 on success, -1 on failure.
382 */
383 static int rsi_init_usb_interface(struct rsi_hw *adapter,
384 struct usb_interface *pfunction)
385 {
386 struct rsi_91x_usbdev *rsi_dev;
387 struct rsi_common *common = adapter->priv;
388 int status;
389
390 rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL);
391 if (!rsi_dev)
392 return -ENOMEM;
393
394 adapter->rsi_dev = rsi_dev;
395 rsi_dev->usbdev = interface_to_usbdev(pfunction);
396
397 if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter))
398 return -EINVAL;
399
400 adapter->device = &pfunction->dev;
401 usb_set_intfdata(pfunction, adapter);
402
403 common->rx_data_pkt = kmalloc(2048, GFP_KERNEL);
404 if (!common->rx_data_pkt) {
405 rsi_dbg(ERR_ZONE, "%s: Failed to allocate memory\n",
406 __func__);
407 return -ENOMEM;
408 }
409
410 rsi_dev->tx_buffer = kmalloc(2048, GFP_ATOMIC);
411 rsi_dev->rx_usb_urb[0] = usb_alloc_urb(0, GFP_KERNEL);
412 rsi_dev->rx_usb_urb[0]->transfer_buffer = adapter->priv->rx_data_pkt;
413 rsi_dev->tx_blk_size = 252;
414
415 /* Initializing function callbacks */
416 adapter->rx_urb_submit = rsi_rx_urb_submit;
417 adapter->host_intf_write_pkt = rsi_usb_host_intf_write_pkt;
418 adapter->check_hw_queue_status = rsi_usb_check_queue_status;
419 adapter->determine_event_timeout = rsi_usb_event_timeout;
420
421 rsi_init_event(&rsi_dev->rx_thread.event);
422 status = rsi_create_kthread(common, &rsi_dev->rx_thread,
423 rsi_usb_rx_thread, "RX-Thread");
424 if (status) {
425 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__);
426 goto fail;
427 }
428
429 #ifdef CONFIG_RSI_DEBUGFS
430 /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */
431 adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1);
432 #endif
433
434 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__);
435 return 0;
436
437 fail:
438 kfree(rsi_dev->tx_buffer);
439 kfree(common->rx_data_pkt);
440 return status;
441 }
442
443 /**
444 * rsi_probe() - This function is called by kernel when the driver provided
445 * Vendor and device IDs are matched. All the initialization
446 * work is done here.
447 * @pfunction: Pointer to the USB interface structure.
448 * @id: Pointer to the usb_device_id structure.
449 *
450 * Return: 0 on success, -1 on failure.
451 */
452 static int rsi_probe(struct usb_interface *pfunction,
453 const struct usb_device_id *id)
454 {
455 struct rsi_hw *adapter;
456 struct rsi_91x_usbdev *dev;
457 u16 fw_status;
458
459 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__);
460
461 adapter = rsi_91x_init();
462 if (!adapter) {
463 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n",
464 __func__);
465 return 1;
466 }
467
468 if (rsi_init_usb_interface(adapter, pfunction)) {
469 rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n",
470 __func__);
471 goto err;
472 }
473
474 rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__);
475
476 dev = (struct rsi_91x_usbdev *)adapter->rsi_dev;
477
478 if (rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2) < 0)
479 goto err1;
480 else
481 fw_status &= 1;
482
483 if (!fw_status) {
484 if (rsi_usb_device_init(adapter->priv)) {
485 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n",
486 __func__);
487 goto err1;
488 }
489
490 if (rsi_usb_reg_write(dev->usbdev,
491 USB_INTERNAL_REG_1,
492 RSI_USB_READY_MAGIC_NUM, 1) < 0)
493 goto err1;
494 rsi_dbg(INIT_ZONE, "%s: Performed device init\n", __func__);
495 }
496
497 if (rsi_rx_urb_submit(adapter))
498 goto err1;
499
500 return 0;
501 err1:
502 rsi_deinit_usb_interface(adapter);
503 err:
504 rsi_91x_deinit(adapter);
505 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__);
506 return 1;
507 }
508
509 /**
510 * rsi_disconnect() - This function performs the reverse of the probe function,
511 * it deintialize the driver structure.
512 * @pfunction: Pointer to the USB interface structure.
513 *
514 * Return: None.
515 */
516 static void rsi_disconnect(struct usb_interface *pfunction)
517 {
518 struct rsi_hw *adapter = usb_get_intfdata(pfunction);
519
520 if (!adapter)
521 return;
522
523 rsi_mac80211_detach(adapter);
524 rsi_deinit_usb_interface(adapter);
525 rsi_91x_deinit(adapter);
526
527 rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__);
528 }
529
530 #ifdef CONFIG_PM
531 static int rsi_suspend(struct usb_interface *intf, pm_message_t message)
532 {
533 /* Not yet implemented */
534 return -ENOSYS;
535 }
536
537 static int rsi_resume(struct usb_interface *intf)
538 {
539 /* Not yet implemented */
540 return -ENOSYS;
541 }
542 #endif
543
544 static const struct usb_device_id rsi_dev_table[] = {
545 { USB_DEVICE(0x0303, 0x0100) },
546 { USB_DEVICE(0x041B, 0x0301) },
547 { USB_DEVICE(0x041B, 0x0201) },
548 { USB_DEVICE(0x041B, 0x9330) },
549 { /* Blank */},
550 };
551
552 static struct usb_driver rsi_driver = {
553 .name = "RSI-USB WLAN",
554 .probe = rsi_probe,
555 .disconnect = rsi_disconnect,
556 .id_table = rsi_dev_table,
557 #ifdef CONFIG_PM
558 .suspend = rsi_suspend,
559 .resume = rsi_resume,
560 #endif
561 };
562
563 /**
564 * rsi_module_init() - This function registers the client driver.
565 * @void: Void.
566 *
567 * Return: 0 on success.
568 */
569 static int rsi_module_init(void)
570 {
571 usb_register(&rsi_driver);
572 rsi_dbg(INIT_ZONE, "%s: Registering driver\n", __func__);
573 return 0;
574 }
575
576 /**
577 * rsi_module_exit() - This function unregisters the client driver.
578 * @void: Void.
579 *
580 * Return: None.
581 */
582 static void rsi_module_exit(void)
583 {
584 usb_deregister(&rsi_driver);
585 rsi_dbg(INFO_ZONE, "%s: Unregistering driver\n", __func__);
586 }
587
588 module_init(rsi_module_init);
589 module_exit(rsi_module_exit);
590
591 MODULE_AUTHOR("Redpine Signals Inc");
592 MODULE_DESCRIPTION("Common USB layer for RSI drivers");
593 MODULE_SUPPORTED_DEVICE("RSI-91x");
594 MODULE_DEVICE_TABLE(usb, rsi_dev_table);
595 MODULE_FIRMWARE(FIRMWARE_RSI9113);
596 MODULE_VERSION("0.1");
597 MODULE_LICENSE("Dual BSD/GPL");
598
599
600
601
602
603 /* LDV_COMMENT_BEGIN_MAIN */
604 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful
605
606 /*###########################################################################*/
607
608 /*############## Driver Environment Generator 0.2 output ####################*/
609
610 /*###########################################################################*/
611
612
613
614 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */
615 void ldv_check_final_state(void);
616
617 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */
618 void ldv_check_return_value(int res);
619
620 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */
621 void ldv_check_return_value_probe(int res);
622
623 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */
624 void ldv_initialize(void);
625
626 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */
627 void ldv_handler_precall(void);
628
629 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */
630 int nondet_int(void);
631
632 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */
633 int LDV_IN_INTERRUPT;
634
635 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */
636 void ldv_main0_sequence_infinite_withcheck_stateful(void) {
637
638
639
640 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */
641 /*============================= VARIABLE DECLARATION PART =============================*/
642 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
643 /* content: static int rsi_probe(struct usb_interface *pfunction, const struct usb_device_id *id)*/
644 /* LDV_COMMENT_BEGIN_PREP */
645 #ifdef CONFIG_RSI_DEBUGFS
646 #endif
647 /* LDV_COMMENT_END_PREP */
648 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_probe" */
649 struct usb_interface * var_group1;
650 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_probe" */
651 const struct usb_device_id * var_rsi_probe_11_p1;
652 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "rsi_probe" */
653 static int res_rsi_probe_11;
654 /* LDV_COMMENT_BEGIN_PREP */
655 #ifdef CONFIG_PM
656 #endif
657 #ifdef CONFIG_PM
658 #endif
659 /* LDV_COMMENT_END_PREP */
660 /* content: static void rsi_disconnect(struct usb_interface *pfunction)*/
661 /* LDV_COMMENT_BEGIN_PREP */
662 #ifdef CONFIG_RSI_DEBUGFS
663 #endif
664 /* LDV_COMMENT_END_PREP */
665 /* LDV_COMMENT_BEGIN_PREP */
666 #ifdef CONFIG_PM
667 #endif
668 #ifdef CONFIG_PM
669 #endif
670 /* LDV_COMMENT_END_PREP */
671 /* content: static int rsi_suspend(struct usb_interface *intf, pm_message_t message)*/
672 /* LDV_COMMENT_BEGIN_PREP */
673 #ifdef CONFIG_RSI_DEBUGFS
674 #endif
675 #ifdef CONFIG_PM
676 /* LDV_COMMENT_END_PREP */
677 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_suspend" */
678 pm_message_t var_rsi_suspend_13_p1;
679 /* LDV_COMMENT_BEGIN_PREP */
680 #endif
681 #ifdef CONFIG_PM
682 #endif
683 /* LDV_COMMENT_END_PREP */
684 /* content: static int rsi_resume(struct usb_interface *intf)*/
685 /* LDV_COMMENT_BEGIN_PREP */
686 #ifdef CONFIG_RSI_DEBUGFS
687 #endif
688 #ifdef CONFIG_PM
689 /* LDV_COMMENT_END_PREP */
690 /* LDV_COMMENT_BEGIN_PREP */
691 #endif
692 #ifdef CONFIG_PM
693 #endif
694 /* LDV_COMMENT_END_PREP */
695
696
697
698
699 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */
700 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */
701 /*============================= VARIABLE INITIALIZING PART =============================*/
702 LDV_IN_INTERRUPT=1;
703
704
705
706
707 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */
708 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */
709 /*============================= FUNCTION CALL SECTION =============================*/
710 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */
711 ldv_initialize();
712
713 /** INIT: init_type: ST_MODULE_INIT **/
714 /* content: static int rsi_module_init(void)*/
715 /* LDV_COMMENT_BEGIN_PREP */
716 #ifdef CONFIG_RSI_DEBUGFS
717 #endif
718 #ifdef CONFIG_PM
719 #endif
720 #ifdef CONFIG_PM
721 #endif
722 /* LDV_COMMENT_END_PREP */
723 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver init function after driver loading to kernel. This function declared as "MODULE_INIT(function name)". */
724 ldv_handler_precall();
725 if(rsi_module_init())
726 goto ldv_final;
727 int ldv_s_rsi_driver_usb_driver = 0;
728
729
730 while( nondet_int()
731 || !(ldv_s_rsi_driver_usb_driver == 0)
732 ) {
733
734 switch(nondet_int()) {
735
736 case 0: {
737
738 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
739 if(ldv_s_rsi_driver_usb_driver==0) {
740
741 /* content: static int rsi_probe(struct usb_interface *pfunction, const struct usb_device_id *id)*/
742 /* LDV_COMMENT_BEGIN_PREP */
743 #ifdef CONFIG_RSI_DEBUGFS
744 #endif
745 /* LDV_COMMENT_END_PREP */
746 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "rsi_driver". Standart function test for correct return result. */
747 res_rsi_probe_11 = rsi_probe( var_group1, var_rsi_probe_11_p1);
748 ldv_check_return_value(res_rsi_probe_11);
749 ldv_check_return_value_probe(res_rsi_probe_11);
750 if(res_rsi_probe_11)
751 goto ldv_module_exit;
752 /* LDV_COMMENT_BEGIN_PREP */
753 #ifdef CONFIG_PM
754 #endif
755 #ifdef CONFIG_PM
756 #endif
757 /* LDV_COMMENT_END_PREP */
758 ldv_s_rsi_driver_usb_driver++;
759
760 }
761
762 }
763
764 break;
765 case 1: {
766
767 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
768 if(ldv_s_rsi_driver_usb_driver==1) {
769
770 /* content: static int rsi_suspend(struct usb_interface *intf, pm_message_t message)*/
771 /* LDV_COMMENT_BEGIN_PREP */
772 #ifdef CONFIG_RSI_DEBUGFS
773 #endif
774 #ifdef CONFIG_PM
775 /* LDV_COMMENT_END_PREP */
776 /* LDV_COMMENT_FUNCTION_CALL Function from field "suspend" from driver structure with callbacks "rsi_driver" */
777 ldv_handler_precall();
778 rsi_suspend( var_group1, var_rsi_suspend_13_p1);
779 /* LDV_COMMENT_BEGIN_PREP */
780 #endif
781 #ifdef CONFIG_PM
782 #endif
783 /* LDV_COMMENT_END_PREP */
784 ldv_s_rsi_driver_usb_driver++;
785
786 }
787
788 }
789
790 break;
791 case 2: {
792
793 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
794 if(ldv_s_rsi_driver_usb_driver==2) {
795
796 /* content: static int rsi_resume(struct usb_interface *intf)*/
797 /* LDV_COMMENT_BEGIN_PREP */
798 #ifdef CONFIG_RSI_DEBUGFS
799 #endif
800 #ifdef CONFIG_PM
801 /* LDV_COMMENT_END_PREP */
802 /* LDV_COMMENT_FUNCTION_CALL Function from field "resume" from driver structure with callbacks "rsi_driver" */
803 ldv_handler_precall();
804 rsi_resume( var_group1);
805 /* LDV_COMMENT_BEGIN_PREP */
806 #endif
807 #ifdef CONFIG_PM
808 #endif
809 /* LDV_COMMENT_END_PREP */
810 ldv_s_rsi_driver_usb_driver++;
811
812 }
813
814 }
815
816 break;
817 case 3: {
818
819 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/
820 if(ldv_s_rsi_driver_usb_driver==3) {
821
822 /* content: static void rsi_disconnect(struct usb_interface *pfunction)*/
823 /* LDV_COMMENT_BEGIN_PREP */
824 #ifdef CONFIG_RSI_DEBUGFS
825 #endif
826 /* LDV_COMMENT_END_PREP */
827 /* LDV_COMMENT_FUNCTION_CALL Function from field "disconnect" from driver structure with callbacks "rsi_driver" */
828 ldv_handler_precall();
829 rsi_disconnect( var_group1);
830 /* LDV_COMMENT_BEGIN_PREP */
831 #ifdef CONFIG_PM
832 #endif
833 #ifdef CONFIG_PM
834 #endif
835 /* LDV_COMMENT_END_PREP */
836 ldv_s_rsi_driver_usb_driver=0;
837
838 }
839
840 }
841
842 break;
843 default: break;
844
845 }
846
847 }
848
849 ldv_module_exit:
850
851 /** INIT: init_type: ST_MODULE_EXIT **/
852 /* content: static void rsi_module_exit(void)*/
853 /* LDV_COMMENT_BEGIN_PREP */
854 #ifdef CONFIG_RSI_DEBUGFS
855 #endif
856 #ifdef CONFIG_PM
857 #endif
858 #ifdef CONFIG_PM
859 #endif
860 /* LDV_COMMENT_END_PREP */
861 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver release function before driver will be uploaded from kernel. This function declared as "MODULE_EXIT(function name)". */
862 ldv_handler_precall();
863 rsi_module_exit();
864
865 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */
866 ldv_final: ldv_check_final_state();
867
868 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */
869 return;
870
871 }
872 #endif
873
874 /* LDV_COMMENT_END_MAIN */
875
876 #line 9 "/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--68_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8072/dscv_tempdir/dscv/ri/68_1a/drivers/net/wireless/rsi/rsi_91x_usb.o.c.prepared" 1
2 #include <linux/kernel.h>
3 #include <verifier/rcv.h>
4
5 struct urb;
6 /* LDV_COMMENT_CHANGE_STATE Initialize allocated urb counter to zero. */
7 int ldv_urb_state = 0;
8 /* LDV_COMMENT_CHANGE_STATE Initialize allocated coherent counter to zero. */
9 int ldv_coherent_state = 0;
10
11 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='usb_alloc_coherent') Allocates coherent memory. */
12 void *ldv_usb_alloc_coherent(void)
13 {
14 /* LDV_COMMENT_OTHER Choose an arbitrary memory location. */
15 void *arbitrary_memory = ldv_undef_ptr();
16 /* LDV_COMMENT_OTHER If memory is not available. */
17 if(!arbitrary_memory) {
18 /* LDV_COMMENT_RETURN Failed to allocate memory. */
19 return NULL;
20 }
21 /* LDV_COMMENT_CHANGE_STATE Increase allocated counter. */
22 ldv_coherent_state += 1;
23 /* LDV_COMMENT_RETURN The memory is successfully allocated. */
24 return arbitrary_memory;
25 }
26
27 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='usb_free_coherent') Releases coherent memory. */
28 void ldv_usb_free_coherent(void *addr) {
29 //TODO: this assume is dangerous and should be replaced with commented if.
30 ldv_assume(addr!=0);
31 //if (addr){
32 /* LDV_COMMENT_ASSERT The memory must be allocated before. */
33 ldv_assert(ldv_coherent_state>=1);
34 /* LDV_COMMENT_CHANGE_STATE Decrease allocated counter. */
35 ldv_coherent_state -= 1;
36 //}
37 }
38
39 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='usb_alloc_urb') Allocates memory for urb request. */
40 struct urb *ldv_usb_alloc_urb(void)
41 {
42 /* LDV_COMMENT_OTHER Choose an arbitrary memory location. */
43 void *arbitrary_memory = ldv_undef_ptr();
44 /* LDV_COMMENT_OTHER If memory is not available. */
45 if(!arbitrary_memory) {
46 /* LDV_COMMENT_RETURN Failed to allocate memory. */
47 return NULL;
48 }
49 /* LDV_COMMENT_CHANGE_STATE Increase allocated counter. */
50 ldv_urb_state += 1;
51 /* LDV_COMMENT_RETURN The memory is successfully allocated. */
52 return arbitrary_memory;
53 }
54
55 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='usb_free_urb') Releases memory of urb request. */
56 void ldv_usb_free_urb(struct urb *urb) {
57 //TODO: this assume is dangerous and should be replaced with commented if.
58 ldv_assume(urb!=0);
59 //if (urb){
60 /* LDV_COMMENT_ASSERT The memory must be allocated before. */
61 ldv_assert(ldv_urb_state>=1);
62 /* LDV_COMMENT_CHANGE_STATE Decrease allocated counter. */
63 ldv_urb_state -= 1;
64 //}
65 }
66
67 void ldv_check_final_state( void )
68 {
69 /* LDV_COMMENT_ASSERT The urb requests must be freed at the end. */
70 ldv_assert(ldv_urb_state==0);
71 /* LDV_COMMENT_ASSERT The coherent memory must be freed at the end. */
72 ldv_assert(ldv_coherent_state==0);
73 } 1 #ifndef _LDV_RCV_H_
2 #define _LDV_RCV_H_
3
4 /* If expr evaluates to zero, ldv_assert() causes a program to reach the error
5 label like the standard assert(). */
6 #define ldv_assert(expr) ((expr) ? 0 : ldv_error())
7
8 /* The error label wrapper. It is used because of some static verifiers (like
9 BLAST) don't accept multiple error labels through a program. */
10 static inline void ldv_error(void)
11 {
12 LDV_ERROR: goto LDV_ERROR;
13 }
14
15 /* If expr evaluates to zero, ldv_assume() causes an infinite loop that is
16 avoided by verifiers. */
17 #define ldv_assume(expr) ((expr) ? 0 : ldv_stop())
18
19 /* Infinite loop, that causes verifiers to skip such paths. */
20 static inline void ldv_stop(void) {
21 LDV_STOP: goto LDV_STOP;
22 }
23
24 /* Special nondeterministic functions. */
25 int ldv_undef_int(void);
26 void *ldv_undef_ptr(void);
27 unsigned long ldv_undef_ulong(void);
28 /* Return nondeterministic negative integer number. */
29 static inline int ldv_undef_int_negative(void)
30 {
31 int ret = ldv_undef_int();
32
33 ldv_assume(ret < 0);
34
35 return ret;
36 }
37 /* Return nondeterministic nonpositive integer number. */
38 static inline int ldv_undef_int_nonpositive(void)
39 {
40 int ret = ldv_undef_int();
41
42 ldv_assume(ret <= 0);
43
44 return ret;
45 }
46
47 /* Add explicit model for __builin_expect GCC function. Without the model a
48 return value will be treated as nondetermined by verifiers. */
49 long __builtin_expect(long exp, long c)
50 {
51 return exp;
52 }
53
54 /* This function causes the program to exit abnormally. GCC implements this
55 function by using a target-dependent mechanism (such as intentionally executing
56 an illegal instruction) or by calling abort. The mechanism used may vary from
57 release to release so you should not rely on any particular implementation.
58 http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */
59 void __builtin_trap(void)
60 {
61 ldv_assert(0);
62 }
63
64 /* The constant is for simulating an error of ldv_undef_ptr() function. */
65 #define LDV_PTR_MAX 2012
66
67 #endif /* _LDV_RCV_H_ */ 1 #ifndef __LINUX_COMPLETION_H
2 #define __LINUX_COMPLETION_H
3
4 /*
5 * (C) Copyright 2001 Linus Torvalds
6 *
7 * Atomic wait-for-completion handler data structures.
8 * See kernel/sched/completion.c for details.
9 */
10
11 #include <linux/wait.h>
12
13 /*
14 * struct completion - structure used to maintain state for a "completion"
15 *
16 * This is the opaque structure used to maintain the state for a "completion".
17 * Completions currently use a FIFO to queue threads that have to wait for
18 * the "completion" event.
19 *
20 * See also: complete(), wait_for_completion() (and friends _timeout,
21 * _interruptible, _interruptible_timeout, and _killable), init_completion(),
22 * reinit_completion(), and macros DECLARE_COMPLETION(),
23 * DECLARE_COMPLETION_ONSTACK().
24 */
25 struct completion {
26 unsigned int done;
27 wait_queue_head_t wait;
28 };
29
30 #define COMPLETION_INITIALIZER(work) \
31 { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
32
33 #define COMPLETION_INITIALIZER_ONSTACK(work) \
34 ({ init_completion(&work); work; })
35
36 /**
37 * DECLARE_COMPLETION - declare and initialize a completion structure
38 * @work: identifier for the completion structure
39 *
40 * This macro declares and initializes a completion structure. Generally used
41 * for static declarations. You should use the _ONSTACK variant for automatic
42 * variables.
43 */
44 #define DECLARE_COMPLETION(work) \
45 struct completion work = COMPLETION_INITIALIZER(work)
46
47 /*
48 * Lockdep needs to run a non-constant initializer for on-stack
49 * completions - so we use the _ONSTACK() variant for those that
50 * are on the kernel stack:
51 */
52 /**
53 * DECLARE_COMPLETION_ONSTACK - declare and initialize a completion structure
54 * @work: identifier for the completion structure
55 *
56 * This macro declares and initializes a completion structure on the kernel
57 * stack.
58 */
59 #ifdef CONFIG_LOCKDEP
60 # define DECLARE_COMPLETION_ONSTACK(work) \
61 struct completion work = COMPLETION_INITIALIZER_ONSTACK(work)
62 #else
63 # define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work)
64 #endif
65
66 /**
67 * init_completion - Initialize a dynamically allocated completion
68 * @x: pointer to completion structure that is to be initialized
69 *
70 * This inline function will initialize a dynamically created completion
71 * structure.
72 */
73 static inline void init_completion(struct completion *x)
74 {
75 x->done = 0;
76 init_waitqueue_head(&x->wait);
77 }
78
79 /**
80 * reinit_completion - reinitialize a completion structure
81 * @x: pointer to completion structure that is to be reinitialized
82 *
83 * This inline function should be used to reinitialize a completion structure so it can
84 * be reused. This is especially important after complete_all() is used.
85 */
86 static inline void reinit_completion(struct completion *x)
87 {
88 x->done = 0;
89 }
90
91 extern void wait_for_completion(struct completion *);
92 extern void wait_for_completion_io(struct completion *);
93 extern int wait_for_completion_interruptible(struct completion *x);
94 extern int wait_for_completion_killable(struct completion *x);
95 extern unsigned long wait_for_completion_timeout(struct completion *x,
96 unsigned long timeout);
97 extern unsigned long wait_for_completion_io_timeout(struct completion *x,
98 unsigned long timeout);
99 extern long wait_for_completion_interruptible_timeout(
100 struct completion *x, unsigned long timeout);
101 extern long wait_for_completion_killable_timeout(
102 struct completion *x, unsigned long timeout);
103 extern bool try_wait_for_completion(struct completion *x);
104 extern bool completion_done(struct completion *x);
105
106 extern void complete(struct completion *);
107 extern void complete_all(struct completion *);
108
109 #endif 1 /*
2 * device.h - generic, centralized driver model
3 *
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
6 * Copyright (c) 2008-2009 Novell Inc.
7 *
8 * This file is released under the GPLv2
9 *
10 * See Documentation/driver-model/ for more information.
11 */
12
13 #ifndef _DEVICE_H_
14 #define _DEVICE_H_
15
16 #include <linux/ioport.h>
17 #include <linux/kobject.h>
18 #include <linux/klist.h>
19 #include <linux/list.h>
20 #include <linux/lockdep.h>
21 #include <linux/compiler.h>
22 #include <linux/types.h>
23 #include <linux/mutex.h>
24 #include <linux/pinctrl/devinfo.h>
25 #include <linux/pm.h>
26 #include <linux/atomic.h>
27 #include <linux/ratelimit.h>
28 #include <linux/uidgid.h>
29 #include <linux/gfp.h>
30 #include <asm/device.h>
31
32 struct device;
33 struct device_private;
34 struct device_driver;
35 struct driver_private;
36 struct module;
37 struct class;
38 struct subsys_private;
39 struct bus_type;
40 struct device_node;
41 struct iommu_ops;
42 struct iommu_group;
43
44 struct bus_attribute {
45 struct attribute attr;
46 ssize_t (*show)(struct bus_type *bus, char *buf);
47 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
48 };
49
50 #define BUS_ATTR(_name, _mode, _show, _store) \
51 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
52 #define BUS_ATTR_RW(_name) \
53 struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
54 #define BUS_ATTR_RO(_name) \
55 struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
56
57 extern int __must_check bus_create_file(struct bus_type *,
58 struct bus_attribute *);
59 extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
60
61 /**
62 * struct bus_type - The bus type of the device
63 *
64 * @name: The name of the bus.
65 * @dev_name: Used for subsystems to enumerate devices like ("foo%u", dev->id).
66 * @dev_root: Default device to use as the parent.
67 * @dev_attrs: Default attributes of the devices on the bus.
68 * @bus_groups: Default attributes of the bus.
69 * @dev_groups: Default attributes of the devices on the bus.
70 * @drv_groups: Default attributes of the device drivers on the bus.
71 * @match: Called, perhaps multiple times, whenever a new device or driver
72 * is added for this bus. It should return a nonzero value if the
73 * given device can be handled by the given driver.
74 * @uevent: Called when a device is added, removed, or a few other things
75 * that generate uevents to add the environment variables.
76 * @probe: Called when a new device or driver add to this bus, and callback
77 * the specific driver's probe to initial the matched device.
78 * @remove: Called when a device removed from this bus.
79 * @shutdown: Called at shut-down time to quiesce the device.
80 *
81 * @online: Called to put the device back online (after offlining it).
82 * @offline: Called to put the device offline for hot-removal. May fail.
83 *
84 * @suspend: Called when a device on this bus wants to go to sleep mode.
85 * @resume: Called to bring a device on this bus out of sleep mode.
86 * @pm: Power management operations of this bus, callback the specific
87 * device driver's pm-ops.
88 * @iommu_ops: IOMMU specific operations for this bus, used to attach IOMMU
89 * driver implementations to a bus and allow the driver to do
90 * bus-specific setup
91 * @p: The private data of the driver core, only the driver core can
92 * touch this.
93 * @lock_key: Lock class key for use by the lock validator
94 *
95 * A bus is a channel between the processor and one or more devices. For the
96 * purposes of the device model, all devices are connected via a bus, even if
97 * it is an internal, virtual, "platform" bus. Buses can plug into each other.
98 * A USB controller is usually a PCI device, for example. The device model
99 * represents the actual connections between buses and the devices they control.
100 * A bus is represented by the bus_type structure. It contains the name, the
101 * default attributes, the bus' methods, PM operations, and the driver core's
102 * private data.
103 */
104 struct bus_type {
105 const char *name;
106 const char *dev_name;
107 struct device *dev_root;
108 struct device_attribute *dev_attrs; /* use dev_groups instead */
109 const struct attribute_group **bus_groups;
110 const struct attribute_group **dev_groups;
111 const struct attribute_group **drv_groups;
112
113 int (*match)(struct device *dev, struct device_driver *drv);
114 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
115 int (*probe)(struct device *dev);
116 int (*remove)(struct device *dev);
117 void (*shutdown)(struct device *dev);
118
119 int (*online)(struct device *dev);
120 int (*offline)(struct device *dev);
121
122 int (*suspend)(struct device *dev, pm_message_t state);
123 int (*resume)(struct device *dev);
124
125 const struct dev_pm_ops *pm;
126
127 struct iommu_ops *iommu_ops;
128
129 struct subsys_private *p;
130 struct lock_class_key lock_key;
131 };
132
133 extern int __must_check bus_register(struct bus_type *bus);
134
135 extern void bus_unregister(struct bus_type *bus);
136
137 extern int __must_check bus_rescan_devices(struct bus_type *bus);
138
139 /* iterator helpers for buses */
140 struct subsys_dev_iter {
141 struct klist_iter ki;
142 const struct device_type *type;
143 };
144 void subsys_dev_iter_init(struct subsys_dev_iter *iter,
145 struct bus_type *subsys,
146 struct device *start,
147 const struct device_type *type);
148 struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
149 void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
150
151 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
152 int (*fn)(struct device *dev, void *data));
153 struct device *bus_find_device(struct bus_type *bus, struct device *start,
154 void *data,
155 int (*match)(struct device *dev, void *data));
156 struct device *bus_find_device_by_name(struct bus_type *bus,
157 struct device *start,
158 const char *name);
159 struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
160 struct device *hint);
161 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
162 void *data, int (*fn)(struct device_driver *, void *));
163 void bus_sort_breadthfirst(struct bus_type *bus,
164 int (*compare)(const struct device *a,
165 const struct device *b));
166 /*
167 * Bus notifiers: Get notified of addition/removal of devices
168 * and binding/unbinding of drivers to devices.
169 * In the long run, it should be a replacement for the platform
170 * notify hooks.
171 */
172 struct notifier_block;
173
174 extern int bus_register_notifier(struct bus_type *bus,
175 struct notifier_block *nb);
176 extern int bus_unregister_notifier(struct bus_type *bus,
177 struct notifier_block *nb);
178
179 /* All 4 notifers below get called with the target struct device *
180 * as an argument. Note that those functions are likely to be called
181 * with the device lock held in the core, so be careful.
182 */
183 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
184 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
185 #define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be
186 bound */
187 #define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */
188 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be
189 unbound */
190 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound
191 from the device */
192
193 extern struct kset *bus_get_kset(struct bus_type *bus);
194 extern struct klist *bus_get_device_klist(struct bus_type *bus);
195
196 /**
197 * struct device_driver - The basic device driver structure
198 * @name: Name of the device driver.
199 * @bus: The bus which the device of this driver belongs to.
200 * @owner: The module owner.
201 * @mod_name: Used for built-in modules.
202 * @suppress_bind_attrs: Disables bind/unbind via sysfs.
203 * @of_match_table: The open firmware table.
204 * @acpi_match_table: The ACPI match table.
205 * @probe: Called to query the existence of a specific device,
206 * whether this driver can work with it, and bind the driver
207 * to a specific device.
208 * @remove: Called when the device is removed from the system to
209 * unbind a device from this driver.
210 * @shutdown: Called at shut-down time to quiesce the device.
211 * @suspend: Called to put the device to sleep mode. Usually to a
212 * low power state.
213 * @resume: Called to bring a device from sleep mode.
214 * @groups: Default attributes that get created by the driver core
215 * automatically.
216 * @pm: Power management operations of the device which matched
217 * this driver.
218 * @p: Driver core's private data, no one other than the driver
219 * core can touch this.
220 *
221 * The device driver-model tracks all of the drivers known to the system.
222 * The main reason for this tracking is to enable the driver core to match
223 * up drivers with new devices. Once drivers are known objects within the
224 * system, however, a number of other things become possible. Device drivers
225 * can export information and configuration variables that are independent
226 * of any specific device.
227 */
228 struct device_driver {
229 const char *name;
230 struct bus_type *bus;
231
232 struct module *owner;
233 const char *mod_name; /* used for built-in modules */
234
235 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
236
237 const struct of_device_id *of_match_table;
238 const struct acpi_device_id *acpi_match_table;
239
240 int (*probe) (struct device *dev);
241 int (*remove) (struct device *dev);
242 void (*shutdown) (struct device *dev);
243 int (*suspend) (struct device *dev, pm_message_t state);
244 int (*resume) (struct device *dev);
245 const struct attribute_group **groups;
246
247 const struct dev_pm_ops *pm;
248
249 struct driver_private *p;
250 };
251
252
253 extern int __must_check driver_register(struct device_driver *drv);
254 extern void driver_unregister(struct device_driver *drv);
255
256 extern struct device_driver *driver_find(const char *name,
257 struct bus_type *bus);
258 extern int driver_probe_done(void);
259 extern void wait_for_device_probe(void);
260
261
262 /* sysfs interface for exporting driver attributes */
263
264 struct driver_attribute {
265 struct attribute attr;
266 ssize_t (*show)(struct device_driver *driver, char *buf);
267 ssize_t (*store)(struct device_driver *driver, const char *buf,
268 size_t count);
269 };
270
271 #define DRIVER_ATTR(_name, _mode, _show, _store) \
272 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store)
273 #define DRIVER_ATTR_RW(_name) \
274 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
275 #define DRIVER_ATTR_RO(_name) \
276 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
277 #define DRIVER_ATTR_WO(_name) \
278 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)
279
280 extern int __must_check driver_create_file(struct device_driver *driver,
281 const struct driver_attribute *attr);
282 extern void driver_remove_file(struct device_driver *driver,
283 const struct driver_attribute *attr);
284
285 extern int __must_check driver_for_each_device(struct device_driver *drv,
286 struct device *start,
287 void *data,
288 int (*fn)(struct device *dev,
289 void *));
290 struct device *driver_find_device(struct device_driver *drv,
291 struct device *start, void *data,
292 int (*match)(struct device *dev, void *data));
293
294 /**
295 * struct subsys_interface - interfaces to device functions
296 * @name: name of the device function
297 * @subsys: subsytem of the devices to attach to
298 * @node: the list of functions registered at the subsystem
299 * @add_dev: device hookup to device function handler
300 * @remove_dev: device hookup to device function handler
301 *
302 * Simple interfaces attached to a subsystem. Multiple interfaces can
303 * attach to a subsystem and its devices. Unlike drivers, they do not
304 * exclusively claim or control devices. Interfaces usually represent
305 * a specific functionality of a subsystem/class of devices.
306 */
307 struct subsys_interface {
308 const char *name;
309 struct bus_type *subsys;
310 struct list_head node;
311 int (*add_dev)(struct device *dev, struct subsys_interface *sif);
312 int (*remove_dev)(struct device *dev, struct subsys_interface *sif);
313 };
314
315 int subsys_interface_register(struct subsys_interface *sif);
316 void subsys_interface_unregister(struct subsys_interface *sif);
317
318 int subsys_system_register(struct bus_type *subsys,
319 const struct attribute_group **groups);
320 int subsys_virtual_register(struct bus_type *subsys,
321 const struct attribute_group **groups);
322
323 /**
324 * struct class - device classes
325 * @name: Name of the class.
326 * @owner: The module owner.
327 * @class_attrs: Default attributes of this class.
328 * @dev_groups: Default attributes of the devices that belong to the class.
329 * @dev_kobj: The kobject that represents this class and links it into the hierarchy.
330 * @dev_uevent: Called when a device is added, removed from this class, or a
331 * few other things that generate uevents to add the environment
332 * variables.
333 * @devnode: Callback to provide the devtmpfs.
334 * @class_release: Called to release this class.
335 * @dev_release: Called to release the device.
336 * @suspend: Used to put the device to sleep mode, usually to a low power
337 * state.
338 * @resume: Used to bring the device from the sleep mode.
339 * @ns_type: Callbacks so sysfs can detemine namespaces.
340 * @namespace: Namespace of the device belongs to this class.
341 * @pm: The default device power management operations of this class.
342 * @p: The private data of the driver core, no one other than the
343 * driver core can touch this.
344 *
345 * A class is a higher-level view of a device that abstracts out low-level
346 * implementation details. Drivers may see a SCSI disk or an ATA disk, but,
347 * at the class level, they are all simply disks. Classes allow user space
348 * to work with devices based on what they do, rather than how they are
349 * connected or how they work.
350 */
351 struct class {
352 const char *name;
353 struct module *owner;
354
355 struct class_attribute *class_attrs;
356 const struct attribute_group **dev_groups;
357 struct kobject *dev_kobj;
358
359 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
360 char *(*devnode)(struct device *dev, umode_t *mode);
361
362 void (*class_release)(struct class *class);
363 void (*dev_release)(struct device *dev);
364
365 int (*suspend)(struct device *dev, pm_message_t state);
366 int (*resume)(struct device *dev);
367
368 const struct kobj_ns_type_operations *ns_type;
369 const void *(*namespace)(struct device *dev);
370
371 const struct dev_pm_ops *pm;
372
373 struct subsys_private *p;
374 };
375
376 struct class_dev_iter {
377 struct klist_iter ki;
378 const struct device_type *type;
379 };
380
381 extern struct kobject *sysfs_dev_block_kobj;
382 extern struct kobject *sysfs_dev_char_kobj;
383 extern int __must_check __class_register(struct class *class,
384 struct lock_class_key *key);
385 extern void class_unregister(struct class *class);
386
387 /* This is a #define to keep the compiler from merging different
388 * instances of the __key variable */
389 #define class_register(class) \
390 ({ \
391 static struct lock_class_key __key; \
392 __class_register(class, &__key); \
393 })
394
395 struct class_compat;
396 struct class_compat *class_compat_register(const char *name);
397 void class_compat_unregister(struct class_compat *cls);
398 int class_compat_create_link(struct class_compat *cls, struct device *dev,
399 struct device *device_link);
400 void class_compat_remove_link(struct class_compat *cls, struct device *dev,
401 struct device *device_link);
402
403 extern void class_dev_iter_init(struct class_dev_iter *iter,
404 struct class *class,
405 struct device *start,
406 const struct device_type *type);
407 extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
408 extern void class_dev_iter_exit(struct class_dev_iter *iter);
409
410 extern int class_for_each_device(struct class *class, struct device *start,
411 void *data,
412 int (*fn)(struct device *dev, void *data));
413 extern struct device *class_find_device(struct class *class,
414 struct device *start, const void *data,
415 int (*match)(struct device *, const void *));
416
417 struct class_attribute {
418 struct attribute attr;
419 ssize_t (*show)(struct class *class, struct class_attribute *attr,
420 char *buf);
421 ssize_t (*store)(struct class *class, struct class_attribute *attr,
422 const char *buf, size_t count);
423 };
424
425 #define CLASS_ATTR(_name, _mode, _show, _store) \
426 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
427 #define CLASS_ATTR_RW(_name) \
428 struct class_attribute class_attr_##_name = __ATTR_RW(_name)
429 #define CLASS_ATTR_RO(_name) \
430 struct class_attribute class_attr_##_name = __ATTR_RO(_name)
431
432 extern int __must_check class_create_file_ns(struct class *class,
433 const struct class_attribute *attr,
434 const void *ns);
435 extern void class_remove_file_ns(struct class *class,
436 const struct class_attribute *attr,
437 const void *ns);
438
439 static inline int __must_check class_create_file(struct class *class,
440 const struct class_attribute *attr)
441 {
442 return class_create_file_ns(class, attr, NULL);
443 }
444
445 static inline void class_remove_file(struct class *class,
446 const struct class_attribute *attr)
447 {
448 return class_remove_file_ns(class, attr, NULL);
449 }
450
451 /* Simple class attribute that is just a static string */
452 struct class_attribute_string {
453 struct class_attribute attr;
454 char *str;
455 };
456
457 /* Currently read-only only */
458 #define _CLASS_ATTR_STRING(_name, _mode, _str) \
459 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
460 #define CLASS_ATTR_STRING(_name, _mode, _str) \
461 struct class_attribute_string class_attr_##_name = \
462 _CLASS_ATTR_STRING(_name, _mode, _str)
463
464 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
465 char *buf);
466
467 struct class_interface {
468 struct list_head node;
469 struct class *class;
470
471 int (*add_dev) (struct device *, struct class_interface *);
472 void (*remove_dev) (struct device *, struct class_interface *);
473 };
474
475 extern int __must_check class_interface_register(struct class_interface *);
476 extern void class_interface_unregister(struct class_interface *);
477
478 extern struct class * __must_check __class_create(struct module *owner,
479 const char *name,
480 struct lock_class_key *key);
481 extern void class_destroy(struct class *cls);
482
483 /* This is a #define to keep the compiler from merging different
484 * instances of the __key variable */
485 #define class_create(owner, name) \
486 ({ \
487 static struct lock_class_key __key; \
488 __class_create(owner, name, &__key); \
489 })
490
491 /*
492 * The type of device, "struct device" is embedded in. A class
493 * or bus can contain devices of different types
494 * like "partitions" and "disks", "mouse" and "event".
495 * This identifies the device type and carries type-specific
496 * information, equivalent to the kobj_type of a kobject.
497 * If "name" is specified, the uevent will contain it in
498 * the DEVTYPE variable.
499 */
500 struct device_type {
501 const char *name;
502 const struct attribute_group **groups;
503 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
504 char *(*devnode)(struct device *dev, umode_t *mode,
505 kuid_t *uid, kgid_t *gid);
506 void (*release)(struct device *dev);
507
508 const struct dev_pm_ops *pm;
509 };
510
511 /* interface for exporting device attributes */
512 struct device_attribute {
513 struct attribute attr;
514 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
515 char *buf);
516 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
517 const char *buf, size_t count);
518 };
519
520 struct dev_ext_attribute {
521 struct device_attribute attr;
522 void *var;
523 };
524
525 ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
526 char *buf);
527 ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
528 const char *buf, size_t count);
529 ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
530 char *buf);
531 ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
532 const char *buf, size_t count);
533 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
534 char *buf);
535 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
536 const char *buf, size_t count);
537
538 #define DEVICE_ATTR(_name, _mode, _show, _store) \
539 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
540 #define DEVICE_ATTR_RW(_name) \
541 struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
542 #define DEVICE_ATTR_RO(_name) \
543 struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
544 #define DEVICE_ATTR_WO(_name) \
545 struct device_attribute dev_attr_##_name = __ATTR_WO(_name)
546 #define DEVICE_ULONG_ATTR(_name, _mode, _var) \
547 struct dev_ext_attribute dev_attr_##_name = \
548 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
549 #define DEVICE_INT_ATTR(_name, _mode, _var) \
550 struct dev_ext_attribute dev_attr_##_name = \
551 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
552 #define DEVICE_BOOL_ATTR(_name, _mode, _var) \
553 struct dev_ext_attribute dev_attr_##_name = \
554 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) }
555 #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
556 struct device_attribute dev_attr_##_name = \
557 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
558
559 extern int device_create_file(struct device *device,
560 const struct device_attribute *entry);
561 extern void device_remove_file(struct device *dev,
562 const struct device_attribute *attr);
563 extern bool device_remove_file_self(struct device *dev,
564 const struct device_attribute *attr);
565 extern int __must_check device_create_bin_file(struct device *dev,
566 const struct bin_attribute *attr);
567 extern void device_remove_bin_file(struct device *dev,
568 const struct bin_attribute *attr);
569
570 /* device resource management */
571 typedef void (*dr_release_t)(struct device *dev, void *res);
572 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
573
574 #ifdef CONFIG_DEBUG_DEVRES
575 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
576 const char *name);
577 #define devres_alloc(release, size, gfp) \
578 __devres_alloc(release, size, gfp, #release)
579 #else
580 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
581 #endif
582 extern void devres_for_each_res(struct device *dev, dr_release_t release,
583 dr_match_t match, void *match_data,
584 void (*fn)(struct device *, void *, void *),
585 void *data);
586 extern void devres_free(void *res);
587 extern void devres_add(struct device *dev, void *res);
588 extern void *devres_find(struct device *dev, dr_release_t release,
589 dr_match_t match, void *match_data);
590 extern void *devres_get(struct device *dev, void *new_res,
591 dr_match_t match, void *match_data);
592 extern void *devres_remove(struct device *dev, dr_release_t release,
593 dr_match_t match, void *match_data);
594 extern int devres_destroy(struct device *dev, dr_release_t release,
595 dr_match_t match, void *match_data);
596 extern int devres_release(struct device *dev, dr_release_t release,
597 dr_match_t match, void *match_data);
598
599 /* devres group */
600 extern void * __must_check devres_open_group(struct device *dev, void *id,
601 gfp_t gfp);
602 extern void devres_close_group(struct device *dev, void *id);
603 extern void devres_remove_group(struct device *dev, void *id);
604 extern int devres_release_group(struct device *dev, void *id);
605
606 /* managed devm_k.alloc/kfree for device drivers */
607 extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
608 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
609 {
610 return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
611 }
612 static inline void *devm_kmalloc_array(struct device *dev,
613 size_t n, size_t size, gfp_t flags)
614 {
615 if (size != 0 && n > SIZE_MAX / size)
616 return NULL;
617 return devm_kmalloc(dev, n * size, flags);
618 }
619 static inline void *devm_kcalloc(struct device *dev,
620 size_t n, size_t size, gfp_t flags)
621 {
622 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
623 }
624 extern void devm_kfree(struct device *dev, void *p);
625 extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp);
626 extern void *devm_kmemdup(struct device *dev, const void *src, size_t len,
627 gfp_t gfp);
628
629 extern unsigned long devm_get_free_pages(struct device *dev,
630 gfp_t gfp_mask, unsigned int order);
631 extern void devm_free_pages(struct device *dev, unsigned long addr);
632
633 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
634 void __iomem *devm_request_and_ioremap(struct device *dev,
635 struct resource *res);
636
637 /* allows to add/remove a custom action to devres stack */
638 int devm_add_action(struct device *dev, void (*action)(void *), void *data);
639 void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
640
641 struct device_dma_parameters {
642 /*
643 * a low level driver may set these to teach IOMMU code about
644 * sg limitations.
645 */
646 unsigned int max_segment_size;
647 unsigned long segment_boundary_mask;
648 };
649
650 struct acpi_device;
651
652 struct acpi_dev_node {
653 #ifdef CONFIG_ACPI
654 struct acpi_device *companion;
655 #endif
656 };
657
658 /**
659 * struct device - The basic device structure
660 * @parent: The device's "parent" device, the device to which it is attached.
661 * In most cases, a parent device is some sort of bus or host
662 * controller. If parent is NULL, the device, is a top-level device,
663 * which is not usually what you want.
664 * @p: Holds the private data of the driver core portions of the device.
665 * See the comment of the struct device_private for detail.
666 * @kobj: A top-level, abstract class from which other classes are derived.
667 * @init_name: Initial name of the device.
668 * @type: The type of device.
669 * This identifies the device type and carries type-specific
670 * information.
671 * @mutex: Mutex to synchronize calls to its driver.
672 * @bus: Type of bus device is on.
673 * @driver: Which driver has allocated this
674 * @platform_data: Platform data specific to the device.
675 * Example: For devices on custom boards, as typical of embedded
676 * and SOC based hardware, Linux often uses platform_data to point
677 * to board-specific structures describing devices and how they
678 * are wired. That can include what ports are available, chip
679 * variants, which GPIO pins act in what additional roles, and so
680 * on. This shrinks the "Board Support Packages" (BSPs) and
681 * minimizes board-specific #ifdefs in drivers.
682 * @driver_data: Private pointer for driver specific info.
683 * @power: For device power management.
684 * See Documentation/power/devices.txt for details.
685 * @pm_domain: Provide callbacks that are executed during system suspend,
686 * hibernation, system resume and during runtime PM transitions
687 * along with subsystem-level and driver-level callbacks.
688 * @pins: For device pin management.
689 * See Documentation/pinctrl.txt for details.
690 * @numa_node: NUMA node this device is close to.
691 * @dma_mask: Dma mask (if dma'ble device).
692 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
693 * hardware supports 64-bit addresses for consistent allocations
694 * such descriptors.
695 * @dma_pfn_offset: offset of DMA memory range relatively of RAM
696 * @dma_parms: A low level driver may set these to teach IOMMU code about
697 * segment limitations.
698 * @dma_pools: Dma pools (if dma'ble device).
699 * @dma_mem: Internal for coherent mem override.
700 * @cma_area: Contiguous memory area for dma allocations
701 * @archdata: For arch-specific additions.
702 * @of_node: Associated device tree node.
703 * @acpi_node: Associated ACPI device node.
704 * @devt: For creating the sysfs "dev".
705 * @id: device instance
706 * @devres_lock: Spinlock to protect the resource of the device.
707 * @devres_head: The resources list of the device.
708 * @knode_class: The node used to add the device to the class list.
709 * @class: The class of the device.
710 * @groups: Optional attribute groups.
711 * @release: Callback to free the device after all references have
712 * gone away. This should be set by the allocator of the
713 * device (i.e. the bus driver that discovered the device).
714 * @iommu_group: IOMMU group the device belongs to.
715 *
716 * @offline_disabled: If set, the device is permanently online.
717 * @offline: Set after successful invocation of bus type's .offline().
718 *
719 * At the lowest level, every device in a Linux system is represented by an
720 * instance of struct device. The device structure contains the information
721 * that the device model core needs to model the system. Most subsystems,
722 * however, track additional information about the devices they host. As a
723 * result, it is rare for devices to be represented by bare device structures;
724 * instead, that structure, like kobject structures, is usually embedded within
725 * a higher-level representation of the device.
726 */
727 struct device {
728 struct device *parent;
729
730 struct device_private *p;
731
732 struct kobject kobj;
733 const char *init_name; /* initial name of the device */
734 const struct device_type *type;
735
736 struct mutex mutex; /* mutex to synchronize calls to
737 * its driver.
738 */
739
740 struct bus_type *bus; /* type of bus device is on */
741 struct device_driver *driver; /* which driver has allocated this
742 device */
743 void *platform_data; /* Platform specific data, device
744 core doesn't touch it */
745 void *driver_data; /* Driver data, set and get with
746 dev_set/get_drvdata */
747 struct dev_pm_info power;
748 struct dev_pm_domain *pm_domain;
749
750 #ifdef CONFIG_PINCTRL
751 struct dev_pin_info *pins;
752 #endif
753
754 #ifdef CONFIG_NUMA
755 int numa_node; /* NUMA node this device is close to */
756 #endif
757 u64 *dma_mask; /* dma mask (if dma'able device) */
758 u64 coherent_dma_mask;/* Like dma_mask, but for
759 alloc_coherent mappings as
760 not all hardware supports
761 64 bit addresses for consistent
762 allocations such descriptors. */
763 unsigned long dma_pfn_offset;
764
765 struct device_dma_parameters *dma_parms;
766
767 struct list_head dma_pools; /* dma pools (if dma'ble) */
768
769 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
770 override */
771 #ifdef CONFIG_DMA_CMA
772 struct cma *cma_area; /* contiguous memory area for dma
773 allocations */
774 #endif
775 /* arch specific additions */
776 struct dev_archdata archdata;
777
778 struct device_node *of_node; /* associated device tree node */
779 struct acpi_dev_node acpi_node; /* associated ACPI device node */
780
781 dev_t devt; /* dev_t, creates the sysfs "dev" */
782 u32 id; /* device instance */
783
784 spinlock_t devres_lock;
785 struct list_head devres_head;
786
787 struct klist_node knode_class;
788 struct class *class;
789 const struct attribute_group **groups; /* optional groups */
790
791 void (*release)(struct device *dev);
792 struct iommu_group *iommu_group;
793
794 bool offline_disabled:1;
795 bool offline:1;
796 };
797
798 static inline struct device *kobj_to_dev(struct kobject *kobj)
799 {
800 return container_of(kobj, struct device, kobj);
801 }
802
803 /* Get the wakeup routines, which depend on struct device */
804 #include <linux/pm_wakeup.h>
805
806 static inline const char *dev_name(const struct device *dev)
807 {
808 /* Use the init name until the kobject becomes available */
809 if (dev->init_name)
810 return dev->init_name;
811
812 return kobject_name(&dev->kobj);
813 }
814
815 extern __printf(2, 3)
816 int dev_set_name(struct device *dev, const char *name, ...);
817
818 #ifdef CONFIG_NUMA
819 static inline int dev_to_node(struct device *dev)
820 {
821 return dev->numa_node;
822 }
823 static inline void set_dev_node(struct device *dev, int node)
824 {
825 dev->numa_node = node;
826 }
827 #else
828 static inline int dev_to_node(struct device *dev)
829 {
830 return -1;
831 }
832 static inline void set_dev_node(struct device *dev, int node)
833 {
834 }
835 #endif
836
837 static inline void *dev_get_drvdata(const struct device *dev)
838 {
839 return dev->driver_data;
840 }
841
842 static inline void dev_set_drvdata(struct device *dev, void *data)
843 {
844 dev->driver_data = data;
845 }
846
847 static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
848 {
849 return dev ? dev->power.subsys_data : NULL;
850 }
851
852 static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
853 {
854 return dev->kobj.uevent_suppress;
855 }
856
857 static inline void dev_set_uevent_suppress(struct device *dev, int val)
858 {
859 dev->kobj.uevent_suppress = val;
860 }
861
862 static inline int device_is_registered(struct device *dev)
863 {
864 return dev->kobj.state_in_sysfs;
865 }
866
867 static inline void device_enable_async_suspend(struct device *dev)
868 {
869 if (!dev->power.is_prepared)
870 dev->power.async_suspend = true;
871 }
872
873 static inline void device_disable_async_suspend(struct device *dev)
874 {
875 if (!dev->power.is_prepared)
876 dev->power.async_suspend = false;
877 }
878
879 static inline bool device_async_suspend_enabled(struct device *dev)
880 {
881 return !!dev->power.async_suspend;
882 }
883
884 static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
885 {
886 dev->power.ignore_children = enable;
887 }
888
889 static inline void dev_pm_syscore_device(struct device *dev, bool val)
890 {
891 #ifdef CONFIG_PM_SLEEP
892 dev->power.syscore = val;
893 #endif
894 }
895
896 static inline void device_lock(struct device *dev)
897 {
898 mutex_lock(&dev->mutex);
899 }
900
901 static inline int device_trylock(struct device *dev)
902 {
903 return mutex_trylock(&dev->mutex);
904 }
905
906 static inline void device_unlock(struct device *dev)
907 {
908 mutex_unlock(&dev->mutex);
909 }
910
911 void driver_init(void);
912
913 /*
914 * High level routines for use by the bus drivers
915 */
916 extern int __must_check device_register(struct device *dev);
917 extern void device_unregister(struct device *dev);
918 extern void device_initialize(struct device *dev);
919 extern int __must_check device_add(struct device *dev);
920 extern void device_del(struct device *dev);
921 extern int device_for_each_child(struct device *dev, void *data,
922 int (*fn)(struct device *dev, void *data));
923 extern struct device *device_find_child(struct device *dev, void *data,
924 int (*match)(struct device *dev, void *data));
925 extern int device_rename(struct device *dev, const char *new_name);
926 extern int device_move(struct device *dev, struct device *new_parent,
927 enum dpm_order dpm_order);
928 extern const char *device_get_devnode(struct device *dev,
929 umode_t *mode, kuid_t *uid, kgid_t *gid,
930 const char **tmp);
931
932 static inline bool device_supports_offline(struct device *dev)
933 {
934 return dev->bus && dev->bus->offline && dev->bus->online;
935 }
936
937 extern void lock_device_hotplug(void);
938 extern void unlock_device_hotplug(void);
939 extern int lock_device_hotplug_sysfs(void);
940 extern int device_offline(struct device *dev);
941 extern int device_online(struct device *dev);
942 /*
943 * Root device objects for grouping under /sys/devices
944 */
945 extern struct device *__root_device_register(const char *name,
946 struct module *owner);
947
948 /* This is a macro to avoid include problems with THIS_MODULE */
949 #define root_device_register(name) \
950 __root_device_register(name, THIS_MODULE)
951
952 extern void root_device_unregister(struct device *root);
953
954 static inline void *dev_get_platdata(const struct device *dev)
955 {
956 return dev->platform_data;
957 }
958
959 /*
960 * Manual binding of a device to driver. See drivers/base/bus.c
961 * for information on use.
962 */
963 extern int __must_check device_bind_driver(struct device *dev);
964 extern void device_release_driver(struct device *dev);
965 extern int __must_check device_attach(struct device *dev);
966 extern int __must_check driver_attach(struct device_driver *drv);
967 extern int __must_check device_reprobe(struct device *dev);
968
969 /*
970 * Easy functions for dynamically creating devices on the fly
971 */
972 extern struct device *device_create_vargs(struct class *cls,
973 struct device *parent,
974 dev_t devt,
975 void *drvdata,
976 const char *fmt,
977 va_list vargs);
978 extern __printf(5, 6)
979 struct device *device_create(struct class *cls, struct device *parent,
980 dev_t devt, void *drvdata,
981 const char *fmt, ...);
982 extern __printf(6, 7)
983 struct device *device_create_with_groups(struct class *cls,
984 struct device *parent, dev_t devt, void *drvdata,
985 const struct attribute_group **groups,
986 const char *fmt, ...);
987 extern void device_destroy(struct class *cls, dev_t devt);
988
989 /*
990 * Platform "fixup" functions - allow the platform to have their say
991 * about devices and actions that the general device layer doesn't
992 * know about.
993 */
994 /* Notify platform of device discovery */
995 extern int (*platform_notify)(struct device *dev);
996
997 extern int (*platform_notify_remove)(struct device *dev);
998
999
1000 /*
1001 * get_device - atomically increment the reference count for the device.
1002 *
1003 */
1004 extern struct device *get_device(struct device *dev);
1005 extern void put_device(struct device *dev);
1006
1007 #ifdef CONFIG_DEVTMPFS
1008 extern int devtmpfs_create_node(struct device *dev);
1009 extern int devtmpfs_delete_node(struct device *dev);
1010 extern int devtmpfs_mount(const char *mntdir);
1011 #else
1012 static inline int devtmpfs_create_node(struct device *dev) { return 0; }
1013 static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
1014 static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
1015 #endif
1016
1017 /* drivers/base/power/shutdown.c */
1018 extern void device_shutdown(void);
1019
1020 /* debugging and troubleshooting/diagnostic helpers. */
1021 extern const char *dev_driver_string(const struct device *dev);
1022
1023
1024 #ifdef CONFIG_PRINTK
1025
1026 extern __printf(3, 0)
1027 int dev_vprintk_emit(int level, const struct device *dev,
1028 const char *fmt, va_list args);
1029 extern __printf(3, 4)
1030 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
1031
1032 extern __printf(3, 4)
1033 int dev_printk(const char *level, const struct device *dev,
1034 const char *fmt, ...);
1035 extern __printf(2, 3)
1036 int dev_emerg(const struct device *dev, const char *fmt, ...);
1037 extern __printf(2, 3)
1038 int dev_alert(const struct device *dev, const char *fmt, ...);
1039 extern __printf(2, 3)
1040 int dev_crit(const struct device *dev, const char *fmt, ...);
1041 extern __printf(2, 3)
1042 int dev_err(const struct device *dev, const char *fmt, ...);
1043 extern __printf(2, 3)
1044 int dev_warn(const struct device *dev, const char *fmt, ...);
1045 extern __printf(2, 3)
1046 int dev_notice(const struct device *dev, const char *fmt, ...);
1047 extern __printf(2, 3)
1048 int _dev_info(const struct device *dev, const char *fmt, ...);
1049
1050 #else
1051
1052 static inline __printf(3, 0)
1053 int dev_vprintk_emit(int level, const struct device *dev,
1054 const char *fmt, va_list args)
1055 { return 0; }
1056 static inline __printf(3, 4)
1057 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
1058 { return 0; }
1059
1060 static inline int __dev_printk(const char *level, const struct device *dev,
1061 struct va_format *vaf)
1062 { return 0; }
1063 static inline __printf(3, 4)
1064 int dev_printk(const char *level, const struct device *dev,
1065 const char *fmt, ...)
1066 { return 0; }
1067
1068 static inline __printf(2, 3)
1069 int dev_emerg(const struct device *dev, const char *fmt, ...)
1070 { return 0; }
1071 static inline __printf(2, 3)
1072 int dev_crit(const struct device *dev, const char *fmt, ...)
1073 { return 0; }
1074 static inline __printf(2, 3)
1075 int dev_alert(const struct device *dev, const char *fmt, ...)
1076 { return 0; }
1077 static inline __printf(2, 3)
1078 int dev_err(const struct device *dev, const char *fmt, ...)
1079 { return 0; }
1080 static inline __printf(2, 3)
1081 int dev_warn(const struct device *dev, const char *fmt, ...)
1082 { return 0; }
1083 static inline __printf(2, 3)
1084 int dev_notice(const struct device *dev, const char *fmt, ...)
1085 { return 0; }
1086 static inline __printf(2, 3)
1087 int _dev_info(const struct device *dev, const char *fmt, ...)
1088 { return 0; }
1089
1090 #endif
1091
1092 /*
1093 * Stupid hackaround for existing uses of non-printk uses dev_info
1094 *
1095 * Note that the definition of dev_info below is actually _dev_info
1096 * and a macro is used to avoid redefining dev_info
1097 */
1098
1099 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
1100
1101 #if defined(CONFIG_DYNAMIC_DEBUG)
1102 #define dev_dbg(dev, format, ...) \
1103 do { \
1104 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
1105 } while (0)
1106 #elif defined(DEBUG)
1107 #define dev_dbg(dev, format, arg...) \
1108 dev_printk(KERN_DEBUG, dev, format, ##arg)
1109 #else
1110 #define dev_dbg(dev, format, arg...) \
1111 ({ \
1112 if (0) \
1113 dev_printk(KERN_DEBUG, dev, format, ##arg); \
1114 0; \
1115 })
1116 #endif
1117
1118 #define dev_level_ratelimited(dev_level, dev, fmt, ...) \
1119 do { \
1120 static DEFINE_RATELIMIT_STATE(_rs, \
1121 DEFAULT_RATELIMIT_INTERVAL, \
1122 DEFAULT_RATELIMIT_BURST); \
1123 if (__ratelimit(&_rs)) \
1124 dev_level(dev, fmt, ##__VA_ARGS__); \
1125 } while (0)
1126
1127 #define dev_emerg_ratelimited(dev, fmt, ...) \
1128 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
1129 #define dev_alert_ratelimited(dev, fmt, ...) \
1130 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
1131 #define dev_crit_ratelimited(dev, fmt, ...) \
1132 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
1133 #define dev_err_ratelimited(dev, fmt, ...) \
1134 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
1135 #define dev_warn_ratelimited(dev, fmt, ...) \
1136 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
1137 #define dev_notice_ratelimited(dev, fmt, ...) \
1138 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
1139 #define dev_info_ratelimited(dev, fmt, ...) \
1140 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
1141 #if defined(CONFIG_DYNAMIC_DEBUG)
1142 /* descriptor check is first to prevent flooding with "callbacks suppressed" */
1143 #define dev_dbg_ratelimited(dev, fmt, ...) \
1144 do { \
1145 static DEFINE_RATELIMIT_STATE(_rs, \
1146 DEFAULT_RATELIMIT_INTERVAL, \
1147 DEFAULT_RATELIMIT_BURST); \
1148 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
1149 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \
1150 __ratelimit(&_rs)) \
1151 __dynamic_dev_dbg(&descriptor, dev, fmt, \
1152 ##__VA_ARGS__); \
1153 } while (0)
1154 #elif defined(DEBUG)
1155 #define dev_dbg_ratelimited(dev, fmt, ...) \
1156 do { \
1157 static DEFINE_RATELIMIT_STATE(_rs, \
1158 DEFAULT_RATELIMIT_INTERVAL, \
1159 DEFAULT_RATELIMIT_BURST); \
1160 if (__ratelimit(&_rs)) \
1161 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \
1162 } while (0)
1163 #else
1164 #define dev_dbg_ratelimited(dev, fmt, ...) \
1165 no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
1166 #endif
1167
1168 #ifdef VERBOSE_DEBUG
1169 #define dev_vdbg dev_dbg
1170 #else
1171 #define dev_vdbg(dev, format, arg...) \
1172 ({ \
1173 if (0) \
1174 dev_printk(KERN_DEBUG, dev, format, ##arg); \
1175 0; \
1176 })
1177 #endif
1178
1179 /*
1180 * dev_WARN*() acts like dev_printk(), but with the key difference of
1181 * using WARN/WARN_ONCE to include file/line information and a backtrace.
1182 */
1183 #define dev_WARN(dev, format, arg...) \
1184 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg);
1185
1186 #define dev_WARN_ONCE(dev, condition, format, arg...) \
1187 WARN_ONCE(condition, "%s %s: " format, \
1188 dev_driver_string(dev), dev_name(dev), ## arg)
1189
1190 /* Create alias, so I can be autoloaded. */
1191 #define MODULE_ALIAS_CHARDEV(major,minor) \
1192 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
1193 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
1194 MODULE_ALIAS("char-major-" __stringify(major) "-*")
1195
1196 #ifdef CONFIG_SYSFS_DEPRECATED
1197 extern long sysfs_deprecated;
1198 #else
1199 #define sysfs_deprecated 0
1200 #endif
1201
1202 /**
1203 * module_driver() - Helper macro for drivers that don't do anything
1204 * special in module init/exit. This eliminates a lot of boilerplate.
1205 * Each module may only use this macro once, and calling it replaces
1206 * module_init() and module_exit().
1207 *
1208 * @__driver: driver name
1209 * @__register: register function for this driver type
1210 * @__unregister: unregister function for this driver type
1211 * @...: Additional arguments to be passed to __register and __unregister.
1212 *
1213 * Use this macro to construct bus specific macros for registering
1214 * drivers, and do not use it on its own.
1215 */
1216 #define module_driver(__driver, __register, __unregister, ...) \
1217 static int __init __driver##_init(void) \
1218 { \
1219 return __register(&(__driver) , ##__VA_ARGS__); \
1220 } \
1221 module_init(__driver##_init); \
1222 static void __exit __driver##_exit(void) \
1223 { \
1224 __unregister(&(__driver) , ##__VA_ARGS__); \
1225 } \
1226 module_exit(__driver##_exit);
1227
1228 #endif /* _DEVICE_H_ */ 1 #ifndef _LINUX_ERR_H
2 #define _LINUX_ERR_H
3
4 #include <linux/compiler.h>
5 #include <linux/types.h>
6
7 #include <asm/errno.h>
8
9 /*
10 * Kernel pointers have redundant information, so we can use a
11 * scheme where we can return either an error code or a normal
12 * pointer with the same return value.
13 *
14 * This should be a per-architecture thing, to allow different
15 * error and pointer decisions.
16 */
17 #define MAX_ERRNO 4095
18
19 #ifndef __ASSEMBLY__
20
21 #define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO)
22
23 static inline void * __must_check ERR_PTR(long error)
24 {
25 return (void *) error;
26 }
27
28 static inline long __must_check PTR_ERR(__force const void *ptr)
29 {
30 return (long) ptr;
31 }
32
33 static inline bool __must_check IS_ERR(__force const void *ptr)
34 {
35 return IS_ERR_VALUE((unsigned long)ptr);
36 }
37
38 static inline bool __must_check IS_ERR_OR_NULL(__force const void *ptr)
39 {
40 return !ptr || IS_ERR_VALUE((unsigned long)ptr);
41 }
42
43 /**
44 * ERR_CAST - Explicitly cast an error-valued pointer to another pointer type
45 * @ptr: The pointer to cast.
46 *
47 * Explicitly cast an error-valued pointer to another pointer type in such a
48 * way as to make it clear that's what's going on.
49 */
50 static inline void * __must_check ERR_CAST(__force const void *ptr)
51 {
52 /* cast away the const */
53 return (void *) ptr;
54 }
55
56 static inline int __must_check PTR_ERR_OR_ZERO(__force const void *ptr)
57 {
58 if (IS_ERR(ptr))
59 return PTR_ERR(ptr);
60 else
61 return 0;
62 }
63
64 /* Deprecated */
65 #define PTR_RET(p) PTR_ERR_OR_ZERO(p)
66
67 #endif
68
69 #endif /* _LINUX_ERR_H */ 1 /*
2 * Written by Mark Hemment, 1996 (markhe@nextd.demon.co.uk).
3 *
4 * (C) SGI 2006, Christoph Lameter
5 * Cleaned up and restructured to ease the addition of alternative
6 * implementations of SLAB allocators.
7 * (C) Linux Foundation 2008-2013
8 * Unified interface for all slab allocators
9 */
10
11 #ifndef _LINUX_SLAB_H
12 #define _LINUX_SLAB_H
13
14 #include <linux/gfp.h>
15 #include <linux/types.h>
16 #include <linux/workqueue.h>
17
18
19 /*
20 * Flags to pass to kmem_cache_create().
21 * The ones marked DEBUG are only valid if CONFIG_SLAB_DEBUG is set.
22 */
23 #define SLAB_DEBUG_FREE 0x00000100UL /* DEBUG: Perform (expensive) checks on free */
24 #define SLAB_RED_ZONE 0x00000400UL /* DEBUG: Red zone objs in a cache */
25 #define SLAB_POISON 0x00000800UL /* DEBUG: Poison objects */
26 #define SLAB_HWCACHE_ALIGN 0x00002000UL /* Align objs on cache lines */
27 #define SLAB_CACHE_DMA 0x00004000UL /* Use GFP_DMA memory */
28 #define SLAB_STORE_USER 0x00010000UL /* DEBUG: Store the last owner for bug hunting */
29 #define SLAB_PANIC 0x00040000UL /* Panic if kmem_cache_create() fails */
30 /*
31 * SLAB_DESTROY_BY_RCU - **WARNING** READ THIS!
32 *
33 * This delays freeing the SLAB page by a grace period, it does _NOT_
34 * delay object freeing. This means that if you do kmem_cache_free()
35 * that memory location is free to be reused at any time. Thus it may
36 * be possible to see another object there in the same RCU grace period.
37 *
38 * This feature only ensures the memory location backing the object
39 * stays valid, the trick to using this is relying on an independent
40 * object validation pass. Something like:
41 *
42 * rcu_read_lock()
43 * again:
44 * obj = lockless_lookup(key);
45 * if (obj) {
46 * if (!try_get_ref(obj)) // might fail for free objects
47 * goto again;
48 *
49 * if (obj->key != key) { // not the object we expected
50 * put_ref(obj);
51 * goto again;
52 * }
53 * }
54 * rcu_read_unlock();
55 *
56 * This is useful if we need to approach a kernel structure obliquely,
57 * from its address obtained without the usual locking. We can lock
58 * the structure to stabilize it and check it's still at the given address,
59 * only if we can be sure that the memory has not been meanwhile reused
60 * for some other kind of object (which our subsystem's lock might corrupt).
61 *
62 * rcu_read_lock before reading the address, then rcu_read_unlock after
63 * taking the spinlock within the structure expected at that address.
64 */
65 #define SLAB_DESTROY_BY_RCU 0x00080000UL /* Defer freeing slabs to RCU */
66 #define SLAB_MEM_SPREAD 0x00100000UL /* Spread some memory over cpuset */
67 #define SLAB_TRACE 0x00200000UL /* Trace allocations and frees */
68
69 /* Flag to prevent checks on free */
70 #ifdef CONFIG_DEBUG_OBJECTS
71 # define SLAB_DEBUG_OBJECTS 0x00400000UL
72 #else
73 # define SLAB_DEBUG_OBJECTS 0x00000000UL
74 #endif
75
76 #define SLAB_NOLEAKTRACE 0x00800000UL /* Avoid kmemleak tracing */
77
78 /* Don't track use of uninitialized memory */
79 #ifdef CONFIG_KMEMCHECK
80 # define SLAB_NOTRACK 0x01000000UL
81 #else
82 # define SLAB_NOTRACK 0x00000000UL
83 #endif
84 #ifdef CONFIG_FAILSLAB
85 # define SLAB_FAILSLAB 0x02000000UL /* Fault injection mark */
86 #else
87 # define SLAB_FAILSLAB 0x00000000UL
88 #endif
89
90 /* The following flags affect the page allocator grouping pages by mobility */
91 #define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* Objects are reclaimable */
92 #define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT /* Objects are short-lived */
93 /*
94 * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
95 *
96 * Dereferencing ZERO_SIZE_PTR will lead to a distinct access fault.
97 *
98 * ZERO_SIZE_PTR can be passed to kfree though in the same way that NULL can.
99 * Both make kfree a no-op.
100 */
101 #define ZERO_SIZE_PTR ((void *)16)
102
103 #define ZERO_OR_NULL_PTR(x) ((unsigned long)(x) <= \
104 (unsigned long)ZERO_SIZE_PTR)
105
106 #include <linux/kmemleak.h>
107
108 struct mem_cgroup;
109 /*
110 * struct kmem_cache related prototypes
111 */
112 void __init kmem_cache_init(void);
113 int slab_is_available(void);
114
115 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
116 unsigned long,
117 void (*)(void *));
118 #ifdef CONFIG_MEMCG_KMEM
119 struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *,
120 struct kmem_cache *,
121 const char *);
122 #endif
123 void kmem_cache_destroy(struct kmem_cache *);
124 int kmem_cache_shrink(struct kmem_cache *);
125 void kmem_cache_free(struct kmem_cache *, void *);
126
127 /*
128 * Please use this macro to create slab caches. Simply specify the
129 * name of the structure and maybe some flags that are listed above.
130 *
131 * The alignment of the struct determines object alignment. If you
132 * f.e. add ____cacheline_aligned_in_smp to the struct declaration
133 * then the objects will be properly aligned in SMP configurations.
134 */
135 #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
136 sizeof(struct __struct), __alignof__(struct __struct),\
137 (__flags), NULL)
138
139 /*
140 * Common kmalloc functions provided by all allocators
141 */
142 void * __must_check __krealloc(const void *, size_t, gfp_t);
143 void * __must_check krealloc(const void *, size_t, gfp_t);
144 void kfree(const void *);
145 void kzfree(const void *);
146 size_t ksize(const void *);
147
148 /*
149 * Some archs want to perform DMA into kmalloc caches and need a guaranteed
150 * alignment larger than the alignment of a 64-bit integer.
151 * Setting ARCH_KMALLOC_MINALIGN in arch headers allows that.
152 */
153 #if defined(ARCH_DMA_MINALIGN) && ARCH_DMA_MINALIGN > 8
154 #define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
155 #define KMALLOC_MIN_SIZE ARCH_DMA_MINALIGN
156 #define KMALLOC_SHIFT_LOW ilog2(ARCH_DMA_MINALIGN)
157 #else
158 #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
159 #endif
160
161 #ifdef CONFIG_SLOB
162 /*
163 * Common fields provided in kmem_cache by all slab allocators
164 * This struct is either used directly by the allocator (SLOB)
165 * or the allocator must include definitions for all fields
166 * provided in kmem_cache_common in their definition of kmem_cache.
167 *
168 * Once we can do anonymous structs (C11 standard) we could put a
169 * anonymous struct definition in these allocators so that the
170 * separate allocations in the kmem_cache structure of SLAB and
171 * SLUB is no longer needed.
172 */
173 struct kmem_cache {
174 unsigned int object_size;/* The original size of the object */
175 unsigned int size; /* The aligned/padded/added on size */
176 unsigned int align; /* Alignment as calculated */
177 unsigned long flags; /* Active flags on the slab */
178 const char *name; /* Slab name for sysfs */
179 int refcount; /* Use counter */
180 void (*ctor)(void *); /* Called on object slot creation */
181 struct list_head list; /* List of all slab caches on the system */
182 };
183
184 #endif /* CONFIG_SLOB */
185
186 /*
187 * Kmalloc array related definitions
188 */
189
190 #ifdef CONFIG_SLAB
191 /*
192 * The largest kmalloc size supported by the SLAB allocators is
193 * 32 megabyte (2^25) or the maximum allocatable page order if that is
194 * less than 32 MB.
195 *
196 * WARNING: Its not easy to increase this value since the allocators have
197 * to do various tricks to work around compiler limitations in order to
198 * ensure proper constant folding.
199 */
200 #define KMALLOC_SHIFT_HIGH ((MAX_ORDER + PAGE_SHIFT - 1) <= 25 ? \
201 (MAX_ORDER + PAGE_SHIFT - 1) : 25)
202 #define KMALLOC_SHIFT_MAX KMALLOC_SHIFT_HIGH
203 #ifndef KMALLOC_SHIFT_LOW
204 #define KMALLOC_SHIFT_LOW 5
205 #endif
206 #endif
207
208 #ifdef CONFIG_SLUB
209 /*
210 * SLUB directly allocates requests fitting in to an order-1 page
211 * (PAGE_SIZE*2). Larger requests are passed to the page allocator.
212 */
213 #define KMALLOC_SHIFT_HIGH (PAGE_SHIFT + 1)
214 #define KMALLOC_SHIFT_MAX (MAX_ORDER + PAGE_SHIFT)
215 #ifndef KMALLOC_SHIFT_LOW
216 #define KMALLOC_SHIFT_LOW 3
217 #endif
218 #endif
219
220 #ifdef CONFIG_SLOB
221 /*
222 * SLOB passes all requests larger than one page to the page allocator.
223 * No kmalloc array is necessary since objects of different sizes can
224 * be allocated from the same page.
225 */
226 #define KMALLOC_SHIFT_HIGH PAGE_SHIFT
227 #define KMALLOC_SHIFT_MAX 30
228 #ifndef KMALLOC_SHIFT_LOW
229 #define KMALLOC_SHIFT_LOW 3
230 #endif
231 #endif
232
233 /* Maximum allocatable size */
234 #define KMALLOC_MAX_SIZE (1UL << KMALLOC_SHIFT_MAX)
235 /* Maximum size for which we actually use a slab cache */
236 #define KMALLOC_MAX_CACHE_SIZE (1UL << KMALLOC_SHIFT_HIGH)
237 /* Maximum order allocatable via the slab allocagtor */
238 #define KMALLOC_MAX_ORDER (KMALLOC_SHIFT_MAX - PAGE_SHIFT)
239
240 /*
241 * Kmalloc subsystem.
242 */
243 #ifndef KMALLOC_MIN_SIZE
244 #define KMALLOC_MIN_SIZE (1 << KMALLOC_SHIFT_LOW)
245 #endif
246
247 /*
248 * This restriction comes from byte sized index implementation.
249 * Page size is normally 2^12 bytes and, in this case, if we want to use
250 * byte sized index which can represent 2^8 entries, the size of the object
251 * should be equal or greater to 2^12 / 2^8 = 2^4 = 16.
252 * If minimum size of kmalloc is less than 16, we use it as minimum object
253 * size and give up to use byte sized index.
254 */
255 #define SLAB_OBJ_MIN_SIZE (KMALLOC_MIN_SIZE < 16 ? \
256 (KMALLOC_MIN_SIZE) : 16)
257
258 #ifndef CONFIG_SLOB
259 extern struct kmem_cache *kmalloc_caches[KMALLOC_SHIFT_HIGH + 1];
260 #ifdef CONFIG_ZONE_DMA
261 extern struct kmem_cache *kmalloc_dma_caches[KMALLOC_SHIFT_HIGH + 1];
262 #endif
263
264 /*
265 * Figure out which kmalloc slab an allocation of a certain size
266 * belongs to.
267 * 0 = zero alloc
268 * 1 = 65 .. 96 bytes
269 * 2 = 120 .. 192 bytes
270 * n = 2^(n-1) .. 2^n -1
271 */
272 static __always_inline int kmalloc_index(size_t size)
273 {
274 if (!size)
275 return 0;
276
277 if (size <= KMALLOC_MIN_SIZE)
278 return KMALLOC_SHIFT_LOW;
279
280 if (KMALLOC_MIN_SIZE <= 32 && size > 64 && size <= 96)
281 return 1;
282 if (KMALLOC_MIN_SIZE <= 64 && size > 128 && size <= 192)
283 return 2;
284 if (size <= 8) return 3;
285 if (size <= 16) return 4;
286 if (size <= 32) return 5;
287 if (size <= 64) return 6;
288 if (size <= 128) return 7;
289 if (size <= 256) return 8;
290 if (size <= 512) return 9;
291 if (size <= 1024) return 10;
292 if (size <= 2 * 1024) return 11;
293 if (size <= 4 * 1024) return 12;
294 if (size <= 8 * 1024) return 13;
295 if (size <= 16 * 1024) return 14;
296 if (size <= 32 * 1024) return 15;
297 if (size <= 64 * 1024) return 16;
298 if (size <= 128 * 1024) return 17;
299 if (size <= 256 * 1024) return 18;
300 if (size <= 512 * 1024) return 19;
301 if (size <= 1024 * 1024) return 20;
302 if (size <= 2 * 1024 * 1024) return 21;
303 if (size <= 4 * 1024 * 1024) return 22;
304 if (size <= 8 * 1024 * 1024) return 23;
305 if (size <= 16 * 1024 * 1024) return 24;
306 if (size <= 32 * 1024 * 1024) return 25;
307 if (size <= 64 * 1024 * 1024) return 26;
308 BUG();
309
310 /* Will never be reached. Needed because the compiler may complain */
311 return -1;
312 }
313 #endif /* !CONFIG_SLOB */
314
315 void *__kmalloc(size_t size, gfp_t flags);
316 void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags);
317
318 #ifdef CONFIG_NUMA
319 void *__kmalloc_node(size_t size, gfp_t flags, int node);
320 void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
321 #else
322 static __always_inline void *__kmalloc_node(size_t size, gfp_t flags, int node)
323 {
324 return __kmalloc(size, flags);
325 }
326
327 static __always_inline void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t flags, int node)
328 {
329 return kmem_cache_alloc(s, flags);
330 }
331 #endif
332
333 #ifdef CONFIG_TRACING
334 extern void *kmem_cache_alloc_trace(struct kmem_cache *, gfp_t, size_t);
335
336 #ifdef CONFIG_NUMA
337 extern void *kmem_cache_alloc_node_trace(struct kmem_cache *s,
338 gfp_t gfpflags,
339 int node, size_t size);
340 #else
341 static __always_inline void *
342 kmem_cache_alloc_node_trace(struct kmem_cache *s,
343 gfp_t gfpflags,
344 int node, size_t size)
345 {
346 return kmem_cache_alloc_trace(s, gfpflags, size);
347 }
348 #endif /* CONFIG_NUMA */
349
350 #else /* CONFIG_TRACING */
351 static __always_inline void *kmem_cache_alloc_trace(struct kmem_cache *s,
352 gfp_t flags, size_t size)
353 {
354 return kmem_cache_alloc(s, flags);
355 }
356
357 static __always_inline void *
358 kmem_cache_alloc_node_trace(struct kmem_cache *s,
359 gfp_t gfpflags,
360 int node, size_t size)
361 {
362 return kmem_cache_alloc_node(s, gfpflags, node);
363 }
364 #endif /* CONFIG_TRACING */
365
366 #ifdef CONFIG_SLAB
367 #include <linux/slab_def.h>
368 #endif
369
370 #ifdef CONFIG_SLUB
371 #include <linux/slub_def.h>
372 #endif
373
374 extern void *kmalloc_order(size_t size, gfp_t flags, unsigned int order);
375
376 #ifdef CONFIG_TRACING
377 extern void *kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order);
378 #else
379 static __always_inline void *
380 kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order)
381 {
382 return kmalloc_order(size, flags, order);
383 }
384 #endif
385
386 static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
387 {
388 unsigned int order = get_order(size);
389 return kmalloc_order_trace(size, flags, order);
390 }
391
392 /**
393 * kmalloc - allocate memory
394 * @size: how many bytes of memory are required.
395 * @flags: the type of memory to allocate.
396 *
397 * kmalloc is the normal method of allocating memory
398 * for objects smaller than page size in the kernel.
399 *
400 * The @flags argument may be one of:
401 *
402 * %GFP_USER - Allocate memory on behalf of user. May sleep.
403 *
404 * %GFP_KERNEL - Allocate normal kernel ram. May sleep.
405 *
406 * %GFP_ATOMIC - Allocation will not sleep. May use emergency pools.
407 * For example, use this inside interrupt handlers.
408 *
409 * %GFP_HIGHUSER - Allocate pages from high memory.
410 *
411 * %GFP_NOIO - Do not do any I/O at all while trying to get memory.
412 *
413 * %GFP_NOFS - Do not make any fs calls while trying to get memory.
414 *
415 * %GFP_NOWAIT - Allocation will not sleep.
416 *
417 * %__GFP_THISNODE - Allocate node-local memory only.
418 *
419 * %GFP_DMA - Allocation suitable for DMA.
420 * Should only be used for kmalloc() caches. Otherwise, use a
421 * slab created with SLAB_DMA.
422 *
423 * Also it is possible to set different flags by OR'ing
424 * in one or more of the following additional @flags:
425 *
426 * %__GFP_COLD - Request cache-cold pages instead of
427 * trying to return cache-warm pages.
428 *
429 * %__GFP_HIGH - This allocation has high priority and may use emergency pools.
430 *
431 * %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail
432 * (think twice before using).
433 *
434 * %__GFP_NORETRY - If memory is not immediately available,
435 * then give up at once.
436 *
437 * %__GFP_NOWARN - If allocation fails, don't issue any warnings.
438 *
439 * %__GFP_REPEAT - If allocation fails initially, try once more before failing.
440 *
441 * There are other flags available as well, but these are not intended
442 * for general use, and so are not documented here. For a full list of
443 * potential flags, always refer to linux/gfp.h.
444 */
445 static __always_inline void *kmalloc(size_t size, gfp_t flags)
446 {
447 if (__builtin_constant_p(size)) {
448 if (size > KMALLOC_MAX_CACHE_SIZE)
449 return kmalloc_large(size, flags);
450 #ifndef CONFIG_SLOB
451 if (!(flags & GFP_DMA)) {
452 int index = kmalloc_index(size);
453
454 if (!index)
455 return ZERO_SIZE_PTR;
456
457 return kmem_cache_alloc_trace(kmalloc_caches[index],
458 flags, size);
459 }
460 #endif
461 }
462 return __kmalloc(size, flags);
463 }
464
465 /*
466 * Determine size used for the nth kmalloc cache.
467 * return size or 0 if a kmalloc cache for that
468 * size does not exist
469 */
470 static __always_inline int kmalloc_size(int n)
471 {
472 #ifndef CONFIG_SLOB
473 if (n > 2)
474 return 1 << n;
475
476 if (n == 1 && KMALLOC_MIN_SIZE <= 32)
477 return 96;
478
479 if (n == 2 && KMALLOC_MIN_SIZE <= 64)
480 return 192;
481 #endif
482 return 0;
483 }
484
485 static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
486 {
487 #ifndef CONFIG_SLOB
488 if (__builtin_constant_p(size) &&
489 size <= KMALLOC_MAX_CACHE_SIZE && !(flags & GFP_DMA)) {
490 int i = kmalloc_index(size);
491
492 if (!i)
493 return ZERO_SIZE_PTR;
494
495 return kmem_cache_alloc_node_trace(kmalloc_caches[i],
496 flags, node, size);
497 }
498 #endif
499 return __kmalloc_node(size, flags, node);
500 }
501
502 /*
503 * Setting ARCH_SLAB_MINALIGN in arch headers allows a different alignment.
504 * Intended for arches that get misalignment faults even for 64 bit integer
505 * aligned buffers.
506 */
507 #ifndef ARCH_SLAB_MINALIGN
508 #define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
509 #endif
510 /*
511 * This is the main placeholder for memcg-related information in kmem caches.
512 * struct kmem_cache will hold a pointer to it, so the memory cost while
513 * disabled is 1 pointer. The runtime cost while enabled, gets bigger than it
514 * would otherwise be if that would be bundled in kmem_cache: we'll need an
515 * extra pointer chase. But the trade off clearly lays in favor of not
516 * penalizing non-users.
517 *
518 * Both the root cache and the child caches will have it. For the root cache,
519 * this will hold a dynamically allocated array large enough to hold
520 * information about the currently limited memcgs in the system. To allow the
521 * array to be accessed without taking any locks, on relocation we free the old
522 * version only after a grace period.
523 *
524 * Child caches will hold extra metadata needed for its operation. Fields are:
525 *
526 * @memcg: pointer to the memcg this cache belongs to
527 * @list: list_head for the list of all caches in this memcg
528 * @root_cache: pointer to the global, root cache, this cache was derived from
529 * @nr_pages: number of pages that belongs to this cache.
530 */
531 struct memcg_cache_params {
532 bool is_root_cache;
533 union {
534 struct {
535 struct rcu_head rcu_head;
536 struct kmem_cache *memcg_caches[0];
537 };
538 struct {
539 struct mem_cgroup *memcg;
540 struct list_head list;
541 struct kmem_cache *root_cache;
542 atomic_t nr_pages;
543 };
544 };
545 };
546
547 int memcg_update_all_caches(int num_memcgs);
548
549 struct seq_file;
550 int cache_show(struct kmem_cache *s, struct seq_file *m);
551 void print_slabinfo_header(struct seq_file *m);
552
553 /**
554 * kmalloc_array - allocate memory for an array.
555 * @n: number of elements.
556 * @size: element size.
557 * @flags: the type of memory to allocate (see kmalloc).
558 */
559 static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags)
560 {
561 if (size != 0 && n > SIZE_MAX / size)
562 return NULL;
563 return __kmalloc(n * size, flags);
564 }
565
566 /**
567 * kcalloc - allocate memory for an array. The memory is set to zero.
568 * @n: number of elements.
569 * @size: element size.
570 * @flags: the type of memory to allocate (see kmalloc).
571 */
572 static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
573 {
574 return kmalloc_array(n, size, flags | __GFP_ZERO);
575 }
576
577 /*
578 * kmalloc_track_caller is a special version of kmalloc that records the
579 * calling function of the routine calling it for slab leak tracking instead
580 * of just the calling function (confusing, eh?).
581 * It's useful when the call to kmalloc comes from a widely-used standard
582 * allocator where we care about the real place the memory allocation
583 * request comes from.
584 */
585 #if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB) || \
586 (defined(CONFIG_SLAB) && defined(CONFIG_TRACING)) || \
587 (defined(CONFIG_SLOB) && defined(CONFIG_TRACING))
588 extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
589 #define kmalloc_track_caller(size, flags) \
590 __kmalloc_track_caller(size, flags, _RET_IP_)
591 #else
592 #define kmalloc_track_caller(size, flags) \
593 __kmalloc(size, flags)
594 #endif /* DEBUG_SLAB */
595
596 #ifdef CONFIG_NUMA
597 /*
598 * kmalloc_node_track_caller is a special version of kmalloc_node that
599 * records the calling function of the routine calling it for slab leak
600 * tracking instead of just the calling function (confusing, eh?).
601 * It's useful when the call to kmalloc_node comes from a widely-used
602 * standard allocator where we care about the real place the memory
603 * allocation request comes from.
604 */
605 #if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB) || \
606 (defined(CONFIG_SLAB) && defined(CONFIG_TRACING)) || \
607 (defined(CONFIG_SLOB) && defined(CONFIG_TRACING))
608 extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
609 #define kmalloc_node_track_caller(size, flags, node) \
610 __kmalloc_node_track_caller(size, flags, node, \
611 _RET_IP_)
612 #else
613 #define kmalloc_node_track_caller(size, flags, node) \
614 __kmalloc_node(size, flags, node)
615 #endif
616
617 #else /* CONFIG_NUMA */
618
619 #define kmalloc_node_track_caller(size, flags, node) \
620 kmalloc_track_caller(size, flags)
621
622 #endif /* CONFIG_NUMA */
623
624 /*
625 * Shortcuts
626 */
627 static inline void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
628 {
629 return kmem_cache_alloc(k, flags | __GFP_ZERO);
630 }
631
632 /**
633 * kzalloc - allocate memory. The memory is set to zero.
634 * @size: how many bytes of memory are required.
635 * @flags: the type of memory to allocate (see kmalloc).
636 */
637 static inline void *kzalloc(size_t size, gfp_t flags)
638 {
639 return kmalloc(size, flags | __GFP_ZERO);
640 }
641
642 /**
643 * kzalloc_node - allocate zeroed memory from a particular memory node.
644 * @size: how many bytes of memory are required.
645 * @flags: the type of memory to allocate (see kmalloc).
646 * @node: memory node from which to allocate
647 */
648 static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
649 {
650 return kmalloc_node(size, flags | __GFP_ZERO, node);
651 }
652
653 /*
654 * Determine the size of a slab object
655 */
656 static inline unsigned int kmem_cache_size(struct kmem_cache *s)
657 {
658 return s->object_size;
659 }
660
661 void __init kmem_cache_init_late(void);
662
663 #endif /* _LINUX_SLAB_H */ 1 #ifndef __LINUX_USB_H
2 #define __LINUX_USB_H
3
4 #include <linux/mod_devicetable.h>
5 #include <linux/usb/ch9.h>
6
7 #define USB_MAJOR 180
8 #define USB_DEVICE_MAJOR 189
9
10
11 #ifdef __KERNEL__
12
13 #include <linux/errno.h> /* for -ENODEV */
14 #include <linux/delay.h> /* for mdelay() */
15 #include <linux/interrupt.h> /* for in_interrupt() */
16 #include <linux/list.h> /* for struct list_head */
17 #include <linux/kref.h> /* for struct kref */
18 #include <linux/device.h> /* for struct device */
19 #include <linux/fs.h> /* for struct file_operations */
20 #include <linux/completion.h> /* for struct completion */
21 #include <linux/sched.h> /* for current && schedule_timeout */
22 #include <linux/mutex.h> /* for struct mutex */
23 #include <linux/pm_runtime.h> /* for runtime PM */
24
25 struct usb_device;
26 struct usb_driver;
27 struct wusb_dev;
28
29 /*-------------------------------------------------------------------------*/
30
31 /*
32 * Host-side wrappers for standard USB descriptors ... these are parsed
33 * from the data provided by devices. Parsing turns them from a flat
34 * sequence of descriptors into a hierarchy:
35 *
36 * - devices have one (usually) or more configs;
37 * - configs have one (often) or more interfaces;
38 * - interfaces have one (usually) or more settings;
39 * - each interface setting has zero or (usually) more endpoints.
40 * - a SuperSpeed endpoint has a companion descriptor
41 *
42 * And there might be other descriptors mixed in with those.
43 *
44 * Devices may also have class-specific or vendor-specific descriptors.
45 */
46
47 struct ep_device;
48
49 /**
50 * struct usb_host_endpoint - host-side endpoint descriptor and queue
51 * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder
52 * @ss_ep_comp: SuperSpeed companion descriptor for this endpoint
53 * @urb_list: urbs queued to this endpoint; maintained by usbcore
54 * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
55 * with one or more transfer descriptors (TDs) per urb
56 * @ep_dev: ep_device for sysfs info
57 * @extra: descriptors following this endpoint in the configuration
58 * @extralen: how many bytes of "extra" are valid
59 * @enabled: URBs may be submitted to this endpoint
60 * @streams: number of USB-3 streams allocated on the endpoint
61 *
62 * USB requests are always queued to a given endpoint, identified by a
63 * descriptor within an active interface in a given USB configuration.
64 */
65 struct usb_host_endpoint {
66 struct usb_endpoint_descriptor desc;
67 struct usb_ss_ep_comp_descriptor ss_ep_comp;
68 struct list_head urb_list;
69 void *hcpriv;
70 struct ep_device *ep_dev; /* For sysfs info */
71
72 unsigned char *extra; /* Extra descriptors */
73 int extralen;
74 int enabled;
75 int streams;
76 };
77
78 /* host-side wrapper for one interface setting's parsed descriptors */
79 struct usb_host_interface {
80 struct usb_interface_descriptor desc;
81
82 int extralen;
83 unsigned char *extra; /* Extra descriptors */
84
85 /* array of desc.bNumEndpoint endpoints associated with this
86 * interface setting. these will be in no particular order.
87 */
88 struct usb_host_endpoint *endpoint;
89
90 char *string; /* iInterface string, if present */
91 };
92
93 enum usb_interface_condition {
94 USB_INTERFACE_UNBOUND = 0,
95 USB_INTERFACE_BINDING,
96 USB_INTERFACE_BOUND,
97 USB_INTERFACE_UNBINDING,
98 };
99
100 /**
101 * struct usb_interface - what usb device drivers talk to
102 * @altsetting: array of interface structures, one for each alternate
103 * setting that may be selected. Each one includes a set of
104 * endpoint configurations. They will be in no particular order.
105 * @cur_altsetting: the current altsetting.
106 * @num_altsetting: number of altsettings defined.
107 * @intf_assoc: interface association descriptor
108 * @minor: the minor number assigned to this interface, if this
109 * interface is bound to a driver that uses the USB major number.
110 * If this interface does not use the USB major, this field should
111 * be unused. The driver should set this value in the probe()
112 * function of the driver, after it has been assigned a minor
113 * number from the USB core by calling usb_register_dev().
114 * @condition: binding state of the interface: not bound, binding
115 * (in probe()), bound to a driver, or unbinding (in disconnect())
116 * @sysfs_files_created: sysfs attributes exist
117 * @ep_devs_created: endpoint child pseudo-devices exist
118 * @unregistering: flag set when the interface is being unregistered
119 * @needs_remote_wakeup: flag set when the driver requires remote-wakeup
120 * capability during autosuspend.
121 * @needs_altsetting0: flag set when a set-interface request for altsetting 0
122 * has been deferred.
123 * @needs_binding: flag set when the driver should be re-probed or unbound
124 * following a reset or suspend operation it doesn't support.
125 * @dev: driver model's view of this device
126 * @usb_dev: if an interface is bound to the USB major, this will point
127 * to the sysfs representation for that device.
128 * @pm_usage_cnt: PM usage counter for this interface
129 * @reset_ws: Used for scheduling resets from atomic context.
130 * @reset_running: set to 1 if the interface is currently running a
131 * queued reset so that usb_cancel_queued_reset() doesn't try to
132 * remove from the workqueue when running inside the worker
133 * thread. See __usb_queue_reset_device().
134 * @resetting_device: USB core reset the device, so use alt setting 0 as
135 * current; needs bandwidth alloc after reset.
136 *
137 * USB device drivers attach to interfaces on a physical device. Each
138 * interface encapsulates a single high level function, such as feeding
139 * an audio stream to a speaker or reporting a change in a volume control.
140 * Many USB devices only have one interface. The protocol used to talk to
141 * an interface's endpoints can be defined in a usb "class" specification,
142 * or by a product's vendor. The (default) control endpoint is part of
143 * every interface, but is never listed among the interface's descriptors.
144 *
145 * The driver that is bound to the interface can use standard driver model
146 * calls such as dev_get_drvdata() on the dev member of this structure.
147 *
148 * Each interface may have alternate settings. The initial configuration
149 * of a device sets altsetting 0, but the device driver can change
150 * that setting using usb_set_interface(). Alternate settings are often
151 * used to control the use of periodic endpoints, such as by having
152 * different endpoints use different amounts of reserved USB bandwidth.
153 * All standards-conformant USB devices that use isochronous endpoints
154 * will use them in non-default settings.
155 *
156 * The USB specification says that alternate setting numbers must run from
157 * 0 to one less than the total number of alternate settings. But some
158 * devices manage to mess this up, and the structures aren't necessarily
159 * stored in numerical order anyhow. Use usb_altnum_to_altsetting() to
160 * look up an alternate setting in the altsetting array based on its number.
161 */
162 struct usb_interface {
163 /* array of alternate settings for this interface,
164 * stored in no particular order */
165 struct usb_host_interface *altsetting;
166
167 struct usb_host_interface *cur_altsetting; /* the currently
168 * active alternate setting */
169 unsigned num_altsetting; /* number of alternate settings */
170
171 /* If there is an interface association descriptor then it will list
172 * the associated interfaces */
173 struct usb_interface_assoc_descriptor *intf_assoc;
174
175 int minor; /* minor number this interface is
176 * bound to */
177 enum usb_interface_condition condition; /* state of binding */
178 unsigned sysfs_files_created:1; /* the sysfs attributes exist */
179 unsigned ep_devs_created:1; /* endpoint "devices" exist */
180 unsigned unregistering:1; /* unregistration is in progress */
181 unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */
182 unsigned needs_altsetting0:1; /* switch to altsetting 0 is pending */
183 unsigned needs_binding:1; /* needs delayed unbind/rebind */
184 unsigned reset_running:1;
185 unsigned resetting_device:1; /* true: bandwidth alloc after reset */
186
187 struct device dev; /* interface specific device info */
188 struct device *usb_dev;
189 atomic_t pm_usage_cnt; /* usage counter for autosuspend */
190 struct work_struct reset_ws; /* for resets in atomic context */
191 };
192 #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
193
194 static inline void *usb_get_intfdata(struct usb_interface *intf)
195 {
196 return dev_get_drvdata(&intf->dev);
197 }
198
199 static inline void usb_set_intfdata(struct usb_interface *intf, void *data)
200 {
201 dev_set_drvdata(&intf->dev, data);
202 }
203
204 struct usb_interface *usb_get_intf(struct usb_interface *intf);
205 void usb_put_intf(struct usb_interface *intf);
206
207 /* Hard limit */
208 #define USB_MAXENDPOINTS 30
209 /* this maximum is arbitrary */
210 #define USB_MAXINTERFACES 32
211 #define USB_MAXIADS (USB_MAXINTERFACES/2)
212
213 /**
214 * struct usb_interface_cache - long-term representation of a device interface
215 * @num_altsetting: number of altsettings defined.
216 * @ref: reference counter.
217 * @altsetting: variable-length array of interface structures, one for
218 * each alternate setting that may be selected. Each one includes a
219 * set of endpoint configurations. They will be in no particular order.
220 *
221 * These structures persist for the lifetime of a usb_device, unlike
222 * struct usb_interface (which persists only as long as its configuration
223 * is installed). The altsetting arrays can be accessed through these
224 * structures at any time, permitting comparison of configurations and
225 * providing support for the /proc/bus/usb/devices pseudo-file.
226 */
227 struct usb_interface_cache {
228 unsigned num_altsetting; /* number of alternate settings */
229 struct kref ref; /* reference counter */
230
231 /* variable-length array of alternate settings for this interface,
232 * stored in no particular order */
233 struct usb_host_interface altsetting[0];
234 };
235 #define ref_to_usb_interface_cache(r) \
236 container_of(r, struct usb_interface_cache, ref)
237 #define altsetting_to_usb_interface_cache(a) \
238 container_of(a, struct usb_interface_cache, altsetting[0])
239
240 /**
241 * struct usb_host_config - representation of a device's configuration
242 * @desc: the device's configuration descriptor.
243 * @string: pointer to the cached version of the iConfiguration string, if
244 * present for this configuration.
245 * @intf_assoc: list of any interface association descriptors in this config
246 * @interface: array of pointers to usb_interface structures, one for each
247 * interface in the configuration. The number of interfaces is stored
248 * in desc.bNumInterfaces. These pointers are valid only while the
249 * the configuration is active.
250 * @intf_cache: array of pointers to usb_interface_cache structures, one
251 * for each interface in the configuration. These structures exist
252 * for the entire life of the device.
253 * @extra: pointer to buffer containing all extra descriptors associated
254 * with this configuration (those preceding the first interface
255 * descriptor).
256 * @extralen: length of the extra descriptors buffer.
257 *
258 * USB devices may have multiple configurations, but only one can be active
259 * at any time. Each encapsulates a different operational environment;
260 * for example, a dual-speed device would have separate configurations for
261 * full-speed and high-speed operation. The number of configurations
262 * available is stored in the device descriptor as bNumConfigurations.
263 *
264 * A configuration can contain multiple interfaces. Each corresponds to
265 * a different function of the USB device, and all are available whenever
266 * the configuration is active. The USB standard says that interfaces
267 * are supposed to be numbered from 0 to desc.bNumInterfaces-1, but a lot
268 * of devices get this wrong. In addition, the interface array is not
269 * guaranteed to be sorted in numerical order. Use usb_ifnum_to_if() to
270 * look up an interface entry based on its number.
271 *
272 * Device drivers should not attempt to activate configurations. The choice
273 * of which configuration to install is a policy decision based on such
274 * considerations as available power, functionality provided, and the user's
275 * desires (expressed through userspace tools). However, drivers can call
276 * usb_reset_configuration() to reinitialize the current configuration and
277 * all its interfaces.
278 */
279 struct usb_host_config {
280 struct usb_config_descriptor desc;
281
282 char *string; /* iConfiguration string, if present */
283
284 /* List of any Interface Association Descriptors in this
285 * configuration. */
286 struct usb_interface_assoc_descriptor *intf_assoc[USB_MAXIADS];
287
288 /* the interfaces associated with this configuration,
289 * stored in no particular order */
290 struct usb_interface *interface[USB_MAXINTERFACES];
291
292 /* Interface information available even when this is not the
293 * active configuration */
294 struct usb_interface_cache *intf_cache[USB_MAXINTERFACES];
295
296 unsigned char *extra; /* Extra descriptors */
297 int extralen;
298 };
299
300 /* USB2.0 and USB3.0 device BOS descriptor set */
301 struct usb_host_bos {
302 struct usb_bos_descriptor *desc;
303
304 /* wireless cap descriptor is handled by wusb */
305 struct usb_ext_cap_descriptor *ext_cap;
306 struct usb_ss_cap_descriptor *ss_cap;
307 struct usb_ss_container_id_descriptor *ss_id;
308 };
309
310 int __usb_get_extra_descriptor(char *buffer, unsigned size,
311 unsigned char type, void **ptr);
312 #define usb_get_extra_descriptor(ifpoint, type, ptr) \
313 __usb_get_extra_descriptor((ifpoint)->extra, \
314 (ifpoint)->extralen, \
315 type, (void **)ptr)
316
317 /* ----------------------------------------------------------------------- */
318
319 /* USB device number allocation bitmap */
320 struct usb_devmap {
321 unsigned long devicemap[128 / (8*sizeof(unsigned long))];
322 };
323
324 /*
325 * Allocated per bus (tree of devices) we have:
326 */
327 struct usb_bus {
328 struct device *controller; /* host/master side hardware */
329 int busnum; /* Bus number (in order of reg) */
330 const char *bus_name; /* stable id (PCI slot_name etc) */
331 u8 uses_dma; /* Does the host controller use DMA? */
332 u8 uses_pio_for_control; /*
333 * Does the host controller use PIO
334 * for control transfers?
335 */
336 u8 otg_port; /* 0, or number of OTG/HNP port */
337 unsigned is_b_host:1; /* true during some HNP roleswitches */
338 unsigned b_hnp_enable:1; /* OTG: did A-Host enable HNP? */
339 unsigned no_stop_on_short:1; /*
340 * Quirk: some controllers don't stop
341 * the ep queue on a short transfer
342 * with the URB_SHORT_NOT_OK flag set.
343 */
344 unsigned no_sg_constraint:1; /* no sg constraint */
345 unsigned sg_tablesize; /* 0 or largest number of sg list entries */
346
347 int devnum_next; /* Next open device number in
348 * round-robin allocation */
349
350 struct usb_devmap devmap; /* device address allocation map */
351 struct usb_device *root_hub; /* Root hub */
352 struct usb_bus *hs_companion; /* Companion EHCI bus, if any */
353 struct list_head bus_list; /* list of busses */
354
355 struct mutex usb_address0_mutex; /* unaddressed device mutex */
356
357 int bandwidth_allocated; /* on this bus: how much of the time
358 * reserved for periodic (intr/iso)
359 * requests is used, on average?
360 * Units: microseconds/frame.
361 * Limits: Full/low speed reserve 90%,
362 * while high speed reserves 80%.
363 */
364 int bandwidth_int_reqs; /* number of Interrupt requests */
365 int bandwidth_isoc_reqs; /* number of Isoc. requests */
366
367 unsigned resuming_ports; /* bit array: resuming root-hub ports */
368
369 #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
370 struct mon_bus *mon_bus; /* non-null when associated */
371 int monitored; /* non-zero when monitored */
372 #endif
373 };
374
375 struct usb_dev_state;
376
377 /* ----------------------------------------------------------------------- */
378
379 struct usb_tt;
380
381 enum usb_device_removable {
382 USB_DEVICE_REMOVABLE_UNKNOWN = 0,
383 USB_DEVICE_REMOVABLE,
384 USB_DEVICE_FIXED,
385 };
386
387 enum usb_port_connect_type {
388 USB_PORT_CONNECT_TYPE_UNKNOWN = 0,
389 USB_PORT_CONNECT_TYPE_HOT_PLUG,
390 USB_PORT_CONNECT_TYPE_HARD_WIRED,
391 USB_PORT_NOT_USED,
392 };
393
394 /*
395 * USB 2.0 Link Power Management (LPM) parameters.
396 */
397 struct usb2_lpm_parameters {
398 /* Best effort service latency indicate how long the host will drive
399 * resume on an exit from L1.
400 */
401 unsigned int besl;
402
403 /* Timeout value in microseconds for the L1 inactivity (LPM) timer.
404 * When the timer counts to zero, the parent hub will initiate a LPM
405 * transition to L1.
406 */
407 int timeout;
408 };
409
410 /*
411 * USB 3.0 Link Power Management (LPM) parameters.
412 *
413 * PEL and SEL are USB 3.0 Link PM latencies for device-initiated LPM exit.
414 * MEL is the USB 3.0 Link PM latency for host-initiated LPM exit.
415 * All three are stored in nanoseconds.
416 */
417 struct usb3_lpm_parameters {
418 /*
419 * Maximum exit latency (MEL) for the host to send a packet to the
420 * device (either a Ping for isoc endpoints, or a data packet for
421 * interrupt endpoints), the hubs to decode the packet, and for all hubs
422 * in the path to transition the links to U0.
423 */
424 unsigned int mel;
425 /*
426 * Maximum exit latency for a device-initiated LPM transition to bring
427 * all links into U0. Abbreviated as "PEL" in section 9.4.12 of the USB
428 * 3.0 spec, with no explanation of what "P" stands for. "Path"?
429 */
430 unsigned int pel;
431
432 /*
433 * The System Exit Latency (SEL) includes PEL, and three other
434 * latencies. After a device initiates a U0 transition, it will take
435 * some time from when the device sends the ERDY to when it will finally
436 * receive the data packet. Basically, SEL should be the worse-case
437 * latency from when a device starts initiating a U0 transition to when
438 * it will get data.
439 */
440 unsigned int sel;
441 /*
442 * The idle timeout value that is currently programmed into the parent
443 * hub for this device. When the timer counts to zero, the parent hub
444 * will initiate an LPM transition to either U1 or U2.
445 */
446 int timeout;
447 };
448
449 /**
450 * struct usb_device - kernel's representation of a USB device
451 * @devnum: device number; address on a USB bus
452 * @devpath: device ID string for use in messages (e.g., /port/...)
453 * @route: tree topology hex string for use with xHCI
454 * @state: device state: configured, not attached, etc.
455 * @speed: device speed: high/full/low (or error)
456 * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub
457 * @ttport: device port on that tt hub
458 * @toggle: one bit for each endpoint, with ([0] = IN, [1] = OUT) endpoints
459 * @parent: our hub, unless we're the root
460 * @bus: bus we're part of
461 * @ep0: endpoint 0 data (default control pipe)
462 * @dev: generic device interface
463 * @descriptor: USB device descriptor
464 * @bos: USB device BOS descriptor set
465 * @config: all of the device's configs
466 * @actconfig: the active configuration
467 * @ep_in: array of IN endpoints
468 * @ep_out: array of OUT endpoints
469 * @rawdescriptors: raw descriptors for each config
470 * @bus_mA: Current available from the bus
471 * @portnum: parent port number (origin 1)
472 * @level: number of USB hub ancestors
473 * @can_submit: URBs may be submitted
474 * @persist_enabled: USB_PERSIST enabled for this device
475 * @have_langid: whether string_langid is valid
476 * @authorized: policy has said we can use it;
477 * (user space) policy determines if we authorize this device to be
478 * used or not. By default, wired USB devices are authorized.
479 * WUSB devices are not, until we authorize them from user space.
480 * FIXME -- complete doc
481 * @authenticated: Crypto authentication passed
482 * @wusb: device is Wireless USB
483 * @lpm_capable: device supports LPM
484 * @usb2_hw_lpm_capable: device can perform USB2 hardware LPM
485 * @usb2_hw_lpm_besl_capable: device can perform USB2 hardware BESL LPM
486 * @usb2_hw_lpm_enabled: USB2 hardware LPM is enabled
487 * @usb2_hw_lpm_allowed: Userspace allows USB 2.0 LPM to be enabled
488 * @usb3_lpm_enabled: USB3 hardware LPM enabled
489 * @string_langid: language ID for strings
490 * @product: iProduct string, if present (static)
491 * @manufacturer: iManufacturer string, if present (static)
492 * @serial: iSerialNumber string, if present (static)
493 * @filelist: usbfs files that are open to this device
494 * @maxchild: number of ports if hub
495 * @quirks: quirks of the whole device
496 * @urbnum: number of URBs submitted for the whole device
497 * @active_duration: total time device is not suspended
498 * @connect_time: time device was first connected
499 * @do_remote_wakeup: remote wakeup should be enabled
500 * @reset_resume: needs reset instead of resume
501 * @port_is_suspended: the upstream port is suspended (L2 or U3)
502 * @wusb_dev: if this is a Wireless USB device, link to the WUSB
503 * specific data for the device.
504 * @slot_id: Slot ID assigned by xHCI
505 * @removable: Device can be physically removed from this port
506 * @l1_params: best effor service latency for USB2 L1 LPM state, and L1 timeout.
507 * @u1_params: exit latencies for USB3 U1 LPM state, and hub-initiated timeout.
508 * @u2_params: exit latencies for USB3 U2 LPM state, and hub-initiated timeout.
509 * @lpm_disable_count: Ref count used by usb_disable_lpm() and usb_enable_lpm()
510 * to keep track of the number of functions that require USB 3.0 Link Power
511 * Management to be disabled for this usb_device. This count should only
512 * be manipulated by those functions, with the bandwidth_mutex is held.
513 *
514 * Notes:
515 * Usbcore drivers should not set usbdev->state directly. Instead use
516 * usb_set_device_state().
517 */
518 struct usb_device {
519 int devnum;
520 char devpath[16];
521 u32 route;
522 enum usb_device_state state;
523 enum usb_device_speed speed;
524
525 struct usb_tt *tt;
526 int ttport;
527
528 unsigned int toggle[2];
529
530 struct usb_device *parent;
531 struct usb_bus *bus;
532 struct usb_host_endpoint ep0;
533
534 struct device dev;
535
536 struct usb_device_descriptor descriptor;
537 struct usb_host_bos *bos;
538 struct usb_host_config *config;
539
540 struct usb_host_config *actconfig;
541 struct usb_host_endpoint *ep_in[16];
542 struct usb_host_endpoint *ep_out[16];
543
544 char **rawdescriptors;
545
546 unsigned short bus_mA;
547 u8 portnum;
548 u8 level;
549
550 unsigned can_submit:1;
551 unsigned persist_enabled:1;
552 unsigned have_langid:1;
553 unsigned authorized:1;
554 unsigned authenticated:1;
555 unsigned wusb:1;
556 unsigned lpm_capable:1;
557 unsigned usb2_hw_lpm_capable:1;
558 unsigned usb2_hw_lpm_besl_capable:1;
559 unsigned usb2_hw_lpm_enabled:1;
560 unsigned usb2_hw_lpm_allowed:1;
561 unsigned usb3_lpm_enabled:1;
562 int string_langid;
563
564 /* static strings from the device */
565 char *product;
566 char *manufacturer;
567 char *serial;
568
569 struct list_head filelist;
570
571 int maxchild;
572
573 u32 quirks;
574 atomic_t urbnum;
575
576 unsigned long active_duration;
577
578 #ifdef CONFIG_PM
579 unsigned long connect_time;
580
581 unsigned do_remote_wakeup:1;
582 unsigned reset_resume:1;
583 unsigned port_is_suspended:1;
584 #endif
585 struct wusb_dev *wusb_dev;
586 int slot_id;
587 enum usb_device_removable removable;
588 struct usb2_lpm_parameters l1_params;
589 struct usb3_lpm_parameters u1_params;
590 struct usb3_lpm_parameters u2_params;
591 unsigned lpm_disable_count;
592 };
593 #define to_usb_device(d) container_of(d, struct usb_device, dev)
594
595 static inline struct usb_device *interface_to_usbdev(struct usb_interface *intf)
596 {
597 return to_usb_device(intf->dev.parent);
598 }
599
600 extern struct usb_device *usb_get_dev(struct usb_device *dev);
601 extern void usb_put_dev(struct usb_device *dev);
602 extern struct usb_device *usb_hub_find_child(struct usb_device *hdev,
603 int port1);
604
605 /**
606 * usb_hub_for_each_child - iterate over all child devices on the hub
607 * @hdev: USB device belonging to the usb hub
608 * @port1: portnum associated with child device
609 * @child: child device pointer
610 */
611 #define usb_hub_for_each_child(hdev, port1, child) \
612 for (port1 = 1, child = usb_hub_find_child(hdev, port1); \
613 port1 <= hdev->maxchild; \
614 child = usb_hub_find_child(hdev, ++port1)) \
615 if (!child) continue; else
616
617 /* USB device locking */
618 #define usb_lock_device(udev) device_lock(&(udev)->dev)
619 #define usb_unlock_device(udev) device_unlock(&(udev)->dev)
620 #define usb_trylock_device(udev) device_trylock(&(udev)->dev)
621 extern int usb_lock_device_for_reset(struct usb_device *udev,
622 const struct usb_interface *iface);
623
624 /* USB port reset for device reinitialization */
625 extern int usb_reset_device(struct usb_device *dev);
626 extern void usb_queue_reset_device(struct usb_interface *dev);
627
628 #ifdef CONFIG_ACPI
629 extern int usb_acpi_set_power_state(struct usb_device *hdev, int index,
630 bool enable);
631 extern bool usb_acpi_power_manageable(struct usb_device *hdev, int index);
632 #else
633 static inline int usb_acpi_set_power_state(struct usb_device *hdev, int index,
634 bool enable) { return 0; }
635 static inline bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
636 { return true; }
637 #endif
638
639 /* USB autosuspend and autoresume */
640 #ifdef CONFIG_PM_RUNTIME
641 extern void usb_enable_autosuspend(struct usb_device *udev);
642 extern void usb_disable_autosuspend(struct usb_device *udev);
643
644 extern int usb_autopm_get_interface(struct usb_interface *intf);
645 extern void usb_autopm_put_interface(struct usb_interface *intf);
646 extern int usb_autopm_get_interface_async(struct usb_interface *intf);
647 extern void usb_autopm_put_interface_async(struct usb_interface *intf);
648 extern void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
649 extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
650
651 static inline void usb_mark_last_busy(struct usb_device *udev)
652 {
653 pm_runtime_mark_last_busy(&udev->dev);
654 }
655
656 #else
657
658 static inline int usb_enable_autosuspend(struct usb_device *udev)
659 { return 0; }
660 static inline int usb_disable_autosuspend(struct usb_device *udev)
661 { return 0; }
662
663 static inline int usb_autopm_get_interface(struct usb_interface *intf)
664 { return 0; }
665 static inline int usb_autopm_get_interface_async(struct usb_interface *intf)
666 { return 0; }
667
668 static inline void usb_autopm_put_interface(struct usb_interface *intf)
669 { }
670 static inline void usb_autopm_put_interface_async(struct usb_interface *intf)
671 { }
672 static inline void usb_autopm_get_interface_no_resume(
673 struct usb_interface *intf)
674 { }
675 static inline void usb_autopm_put_interface_no_suspend(
676 struct usb_interface *intf)
677 { }
678 static inline void usb_mark_last_busy(struct usb_device *udev)
679 { }
680 #endif
681
682 extern int usb_disable_lpm(struct usb_device *udev);
683 extern void usb_enable_lpm(struct usb_device *udev);
684 /* Same as above, but these functions lock/unlock the bandwidth_mutex. */
685 extern int usb_unlocked_disable_lpm(struct usb_device *udev);
686 extern void usb_unlocked_enable_lpm(struct usb_device *udev);
687
688 extern int usb_disable_ltm(struct usb_device *udev);
689 extern void usb_enable_ltm(struct usb_device *udev);
690
691 static inline bool usb_device_supports_ltm(struct usb_device *udev)
692 {
693 if (udev->speed != USB_SPEED_SUPER || !udev->bos || !udev->bos->ss_cap)
694 return false;
695 return udev->bos->ss_cap->bmAttributes & USB_LTM_SUPPORT;
696 }
697
698 static inline bool usb_device_no_sg_constraint(struct usb_device *udev)
699 {
700 return udev && udev->bus && udev->bus->no_sg_constraint;
701 }
702
703
704 /*-------------------------------------------------------------------------*/
705
706 /* for drivers using iso endpoints */
707 extern int usb_get_current_frame_number(struct usb_device *usb_dev);
708
709 /* Sets up a group of bulk endpoints to support multiple stream IDs. */
710 extern int usb_alloc_streams(struct usb_interface *interface,
711 struct usb_host_endpoint **eps, unsigned int num_eps,
712 unsigned int num_streams, gfp_t mem_flags);
713
714 /* Reverts a group of bulk endpoints back to not using stream IDs. */
715 extern int usb_free_streams(struct usb_interface *interface,
716 struct usb_host_endpoint **eps, unsigned int num_eps,
717 gfp_t mem_flags);
718
719 /* used these for multi-interface device registration */
720 extern int usb_driver_claim_interface(struct usb_driver *driver,
721 struct usb_interface *iface, void *priv);
722
723 /**
724 * usb_interface_claimed - returns true iff an interface is claimed
725 * @iface: the interface being checked
726 *
727 * Return: %true (nonzero) iff the interface is claimed, else %false
728 * (zero).
729 *
730 * Note:
731 * Callers must own the driver model's usb bus readlock. So driver
732 * probe() entries don't need extra locking, but other call contexts
733 * may need to explicitly claim that lock.
734 *
735 */
736 static inline int usb_interface_claimed(struct usb_interface *iface)
737 {
738 return (iface->dev.driver != NULL);
739 }
740
741 extern void usb_driver_release_interface(struct usb_driver *driver,
742 struct usb_interface *iface);
743 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
744 const struct usb_device_id *id);
745 extern int usb_match_one_id(struct usb_interface *interface,
746 const struct usb_device_id *id);
747
748 extern int usb_for_each_dev(void *data, int (*fn)(struct usb_device *, void *));
749 extern struct usb_interface *usb_find_interface(struct usb_driver *drv,
750 int minor);
751 extern struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
752 unsigned ifnum);
753 extern struct usb_host_interface *usb_altnum_to_altsetting(
754 const struct usb_interface *intf, unsigned int altnum);
755 extern struct usb_host_interface *usb_find_alt_setting(
756 struct usb_host_config *config,
757 unsigned int iface_num,
758 unsigned int alt_num);
759
760 /* port claiming functions */
761 int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
762 struct usb_dev_state *owner);
763 int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
764 struct usb_dev_state *owner);
765
766 /**
767 * usb_make_path - returns stable device path in the usb tree
768 * @dev: the device whose path is being constructed
769 * @buf: where to put the string
770 * @size: how big is "buf"?
771 *
772 * Return: Length of the string (> 0) or negative if size was too small.
773 *
774 * Note:
775 * This identifier is intended to be "stable", reflecting physical paths in
776 * hardware such as physical bus addresses for host controllers or ports on
777 * USB hubs. That makes it stay the same until systems are physically
778 * reconfigured, by re-cabling a tree of USB devices or by moving USB host
779 * controllers. Adding and removing devices, including virtual root hubs
780 * in host controller driver modules, does not change these path identifiers;
781 * neither does rebooting or re-enumerating. These are more useful identifiers
782 * than changeable ("unstable") ones like bus numbers or device addresses.
783 *
784 * With a partial exception for devices connected to USB 2.0 root hubs, these
785 * identifiers are also predictable. So long as the device tree isn't changed,
786 * plugging any USB device into a given hub port always gives it the same path.
787 * Because of the use of "companion" controllers, devices connected to ports on
788 * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
789 * high speed, and a different one if they are full or low speed.
790 */
791 static inline int usb_make_path(struct usb_device *dev, char *buf, size_t size)
792 {
793 int actual;
794 actual = snprintf(buf, size, "usb-%s-%s", dev->bus->bus_name,
795 dev->devpath);
796 return (actual >= (int)size) ? -1 : actual;
797 }
798
799 /*-------------------------------------------------------------------------*/
800
801 #define USB_DEVICE_ID_MATCH_DEVICE \
802 (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
803 #define USB_DEVICE_ID_MATCH_DEV_RANGE \
804 (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
805 #define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
806 (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
807 #define USB_DEVICE_ID_MATCH_DEV_INFO \
808 (USB_DEVICE_ID_MATCH_DEV_CLASS | \
809 USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \
810 USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
811 #define USB_DEVICE_ID_MATCH_INT_INFO \
812 (USB_DEVICE_ID_MATCH_INT_CLASS | \
813 USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
814 USB_DEVICE_ID_MATCH_INT_PROTOCOL)
815
816 /**
817 * USB_DEVICE - macro used to describe a specific usb device
818 * @vend: the 16 bit USB Vendor ID
819 * @prod: the 16 bit USB Product ID
820 *
821 * This macro is used to create a struct usb_device_id that matches a
822 * specific device.
823 */
824 #define USB_DEVICE(vend, prod) \
825 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, \
826 .idVendor = (vend), \
827 .idProduct = (prod)
828 /**
829 * USB_DEVICE_VER - describe a specific usb device with a version range
830 * @vend: the 16 bit USB Vendor ID
831 * @prod: the 16 bit USB Product ID
832 * @lo: the bcdDevice_lo value
833 * @hi: the bcdDevice_hi value
834 *
835 * This macro is used to create a struct usb_device_id that matches a
836 * specific device, with a version range.
837 */
838 #define USB_DEVICE_VER(vend, prod, lo, hi) \
839 .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, \
840 .idVendor = (vend), \
841 .idProduct = (prod), \
842 .bcdDevice_lo = (lo), \
843 .bcdDevice_hi = (hi)
844
845 /**
846 * USB_DEVICE_INTERFACE_CLASS - describe a usb device with a specific interface class
847 * @vend: the 16 bit USB Vendor ID
848 * @prod: the 16 bit USB Product ID
849 * @cl: bInterfaceClass value
850 *
851 * This macro is used to create a struct usb_device_id that matches a
852 * specific interface class of devices.
853 */
854 #define USB_DEVICE_INTERFACE_CLASS(vend, prod, cl) \
855 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
856 USB_DEVICE_ID_MATCH_INT_CLASS, \
857 .idVendor = (vend), \
858 .idProduct = (prod), \
859 .bInterfaceClass = (cl)
860
861 /**
862 * USB_DEVICE_INTERFACE_PROTOCOL - describe a usb device with a specific interface protocol
863 * @vend: the 16 bit USB Vendor ID
864 * @prod: the 16 bit USB Product ID
865 * @pr: bInterfaceProtocol value
866 *
867 * This macro is used to create a struct usb_device_id that matches a
868 * specific interface protocol of devices.
869 */
870 #define USB_DEVICE_INTERFACE_PROTOCOL(vend, prod, pr) \
871 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
872 USB_DEVICE_ID_MATCH_INT_PROTOCOL, \
873 .idVendor = (vend), \
874 .idProduct = (prod), \
875 .bInterfaceProtocol = (pr)
876
877 /**
878 * USB_DEVICE_INTERFACE_NUMBER - describe a usb device with a specific interface number
879 * @vend: the 16 bit USB Vendor ID
880 * @prod: the 16 bit USB Product ID
881 * @num: bInterfaceNumber value
882 *
883 * This macro is used to create a struct usb_device_id that matches a
884 * specific interface number of devices.
885 */
886 #define USB_DEVICE_INTERFACE_NUMBER(vend, prod, num) \
887 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
888 USB_DEVICE_ID_MATCH_INT_NUMBER, \
889 .idVendor = (vend), \
890 .idProduct = (prod), \
891 .bInterfaceNumber = (num)
892
893 /**
894 * USB_DEVICE_INFO - macro used to describe a class of usb devices
895 * @cl: bDeviceClass value
896 * @sc: bDeviceSubClass value
897 * @pr: bDeviceProtocol value
898 *
899 * This macro is used to create a struct usb_device_id that matches a
900 * specific class of devices.
901 */
902 #define USB_DEVICE_INFO(cl, sc, pr) \
903 .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, \
904 .bDeviceClass = (cl), \
905 .bDeviceSubClass = (sc), \
906 .bDeviceProtocol = (pr)
907
908 /**
909 * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces
910 * @cl: bInterfaceClass value
911 * @sc: bInterfaceSubClass value
912 * @pr: bInterfaceProtocol value
913 *
914 * This macro is used to create a struct usb_device_id that matches a
915 * specific class of interfaces.
916 */
917 #define USB_INTERFACE_INFO(cl, sc, pr) \
918 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \
919 .bInterfaceClass = (cl), \
920 .bInterfaceSubClass = (sc), \
921 .bInterfaceProtocol = (pr)
922
923 /**
924 * USB_DEVICE_AND_INTERFACE_INFO - describe a specific usb device with a class of usb interfaces
925 * @vend: the 16 bit USB Vendor ID
926 * @prod: the 16 bit USB Product ID
927 * @cl: bInterfaceClass value
928 * @sc: bInterfaceSubClass value
929 * @pr: bInterfaceProtocol value
930 *
931 * This macro is used to create a struct usb_device_id that matches a
932 * specific device with a specific class of interfaces.
933 *
934 * This is especially useful when explicitly matching devices that have
935 * vendor specific bDeviceClass values, but standards-compliant interfaces.
936 */
937 #define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, cl, sc, pr) \
938 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
939 | USB_DEVICE_ID_MATCH_DEVICE, \
940 .idVendor = (vend), \
941 .idProduct = (prod), \
942 .bInterfaceClass = (cl), \
943 .bInterfaceSubClass = (sc), \
944 .bInterfaceProtocol = (pr)
945
946 /**
947 * USB_VENDOR_AND_INTERFACE_INFO - describe a specific usb vendor with a class of usb interfaces
948 * @vend: the 16 bit USB Vendor ID
949 * @cl: bInterfaceClass value
950 * @sc: bInterfaceSubClass value
951 * @pr: bInterfaceProtocol value
952 *
953 * This macro is used to create a struct usb_device_id that matches a
954 * specific vendor with a specific class of interfaces.
955 *
956 * This is especially useful when explicitly matching devices that have
957 * vendor specific bDeviceClass values, but standards-compliant interfaces.
958 */
959 #define USB_VENDOR_AND_INTERFACE_INFO(vend, cl, sc, pr) \
960 .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
961 | USB_DEVICE_ID_MATCH_VENDOR, \
962 .idVendor = (vend), \
963 .bInterfaceClass = (cl), \
964 .bInterfaceSubClass = (sc), \
965 .bInterfaceProtocol = (pr)
966
967 /* ----------------------------------------------------------------------- */
968
969 /* Stuff for dynamic usb ids */
970 struct usb_dynids {
971 spinlock_t lock;
972 struct list_head list;
973 };
974
975 struct usb_dynid {
976 struct list_head node;
977 struct usb_device_id id;
978 };
979
980 extern ssize_t usb_store_new_id(struct usb_dynids *dynids,
981 const struct usb_device_id *id_table,
982 struct device_driver *driver,
983 const char *buf, size_t count);
984
985 extern ssize_t usb_show_dynids(struct usb_dynids *dynids, char *buf);
986
987 /**
988 * struct usbdrv_wrap - wrapper for driver-model structure
989 * @driver: The driver-model core driver structure.
990 * @for_devices: Non-zero for device drivers, 0 for interface drivers.
991 */
992 struct usbdrv_wrap {
993 struct device_driver driver;
994 int for_devices;
995 };
996
997 /**
998 * struct usb_driver - identifies USB interface driver to usbcore
999 * @name: The driver name should be unique among USB drivers,
1000 * and should normally be the same as the module name.
1001 * @probe: Called to see if the driver is willing to manage a particular
1002 * interface on a device. If it is, probe returns zero and uses
1003 * usb_set_intfdata() to associate driver-specific data with the
1004 * interface. It may also use usb_set_interface() to specify the
1005 * appropriate altsetting. If unwilling to manage the interface,
1006 * return -ENODEV, if genuine IO errors occurred, an appropriate
1007 * negative errno value.
1008 * @disconnect: Called when the interface is no longer accessible, usually
1009 * because its device has been (or is being) disconnected or the
1010 * driver module is being unloaded.
1011 * @unlocked_ioctl: Used for drivers that want to talk to userspace through
1012 * the "usbfs" filesystem. This lets devices provide ways to
1013 * expose information to user space regardless of where they
1014 * do (or don't) show up otherwise in the filesystem.
1015 * @suspend: Called when the device is going to be suspended by the
1016 * system either from system sleep or runtime suspend context. The
1017 * return value will be ignored in system sleep context, so do NOT
1018 * try to continue using the device if suspend fails in this case.
1019 * Instead, let the resume or reset-resume routine recover from
1020 * the failure.
1021 * @resume: Called when the device is being resumed by the system.
1022 * @reset_resume: Called when the suspended device has been reset instead
1023 * of being resumed.
1024 * @pre_reset: Called by usb_reset_device() when the device is about to be
1025 * reset. This routine must not return until the driver has no active
1026 * URBs for the device, and no more URBs may be submitted until the
1027 * post_reset method is called.
1028 * @post_reset: Called by usb_reset_device() after the device
1029 * has been reset
1030 * @id_table: USB drivers use ID table to support hotplugging.
1031 * Export this with MODULE_DEVICE_TABLE(usb,...). This must be set
1032 * or your driver's probe function will never get called.
1033 * @dynids: used internally to hold the list of dynamically added device
1034 * ids for this driver.
1035 * @drvwrap: Driver-model core structure wrapper.
1036 * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
1037 * added to this driver by preventing the sysfs file from being created.
1038 * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
1039 * for interfaces bound to this driver.
1040 * @soft_unbind: if set to 1, the USB core will not kill URBs and disable
1041 * endpoints before calling the driver's disconnect method.
1042 * @disable_hub_initiated_lpm: if set to 0, the USB core will not allow hubs
1043 * to initiate lower power link state transitions when an idle timeout
1044 * occurs. Device-initiated USB 3.0 link PM will still be allowed.
1045 *
1046 * USB interface drivers must provide a name, probe() and disconnect()
1047 * methods, and an id_table. Other driver fields are optional.
1048 *
1049 * The id_table is used in hotplugging. It holds a set of descriptors,
1050 * and specialized data may be associated with each entry. That table
1051 * is used by both user and kernel mode hotplugging support.
1052 *
1053 * The probe() and disconnect() methods are called in a context where
1054 * they can sleep, but they should avoid abusing the privilege. Most
1055 * work to connect to a device should be done when the device is opened,
1056 * and undone at the last close. The disconnect code needs to address
1057 * concurrency issues with respect to open() and close() methods, as
1058 * well as forcing all pending I/O requests to complete (by unlinking
1059 * them as necessary, and blocking until the unlinks complete).
1060 */
1061 struct usb_driver {
1062 const char *name;
1063
1064 int (*probe) (struct usb_interface *intf,
1065 const struct usb_device_id *id);
1066
1067 void (*disconnect) (struct usb_interface *intf);
1068
1069 int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
1070 void *buf);
1071
1072 int (*suspend) (struct usb_interface *intf, pm_message_t message);
1073 int (*resume) (struct usb_interface *intf);
1074 int (*reset_resume)(struct usb_interface *intf);
1075
1076 int (*pre_reset)(struct usb_interface *intf);
1077 int (*post_reset)(struct usb_interface *intf);
1078
1079 const struct usb_device_id *id_table;
1080
1081 struct usb_dynids dynids;
1082 struct usbdrv_wrap drvwrap;
1083 unsigned int no_dynamic_id:1;
1084 unsigned int supports_autosuspend:1;
1085 unsigned int disable_hub_initiated_lpm:1;
1086 unsigned int soft_unbind:1;
1087 };
1088 #define to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)
1089
1090 /**
1091 * struct usb_device_driver - identifies USB device driver to usbcore
1092 * @name: The driver name should be unique among USB drivers,
1093 * and should normally be the same as the module name.
1094 * @probe: Called to see if the driver is willing to manage a particular
1095 * device. If it is, probe returns zero and uses dev_set_drvdata()
1096 * to associate driver-specific data with the device. If unwilling
1097 * to manage the device, return a negative errno value.
1098 * @disconnect: Called when the device is no longer accessible, usually
1099 * because it has been (or is being) disconnected or the driver's
1100 * module is being unloaded.
1101 * @suspend: Called when the device is going to be suspended by the system.
1102 * @resume: Called when the device is being resumed by the system.
1103 * @drvwrap: Driver-model core structure wrapper.
1104 * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
1105 * for devices bound to this driver.
1106 *
1107 * USB drivers must provide all the fields listed above except drvwrap.
1108 */
1109 struct usb_device_driver {
1110 const char *name;
1111
1112 int (*probe) (struct usb_device *udev);
1113 void (*disconnect) (struct usb_device *udev);
1114
1115 int (*suspend) (struct usb_device *udev, pm_message_t message);
1116 int (*resume) (struct usb_device *udev, pm_message_t message);
1117 struct usbdrv_wrap drvwrap;
1118 unsigned int supports_autosuspend:1;
1119 };
1120 #define to_usb_device_driver(d) container_of(d, struct usb_device_driver, \
1121 drvwrap.driver)
1122
1123 extern struct bus_type usb_bus_type;
1124
1125 /**
1126 * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
1127 * @name: the usb class device name for this driver. Will show up in sysfs.
1128 * @devnode: Callback to provide a naming hint for a possible
1129 * device node to create.
1130 * @fops: pointer to the struct file_operations of this driver.
1131 * @minor_base: the start of the minor range for this driver.
1132 *
1133 * This structure is used for the usb_register_dev() and
1134 * usb_unregister_dev() functions, to consolidate a number of the
1135 * parameters used for them.
1136 */
1137 struct usb_class_driver {
1138 char *name;
1139 char *(*devnode)(struct device *dev, umode_t *mode);
1140 const struct file_operations *fops;
1141 int minor_base;
1142 };
1143
1144 /*
1145 * use these in module_init()/module_exit()
1146 * and don't forget MODULE_DEVICE_TABLE(usb, ...)
1147 */
1148 extern int usb_register_driver(struct usb_driver *, struct module *,
1149 const char *);
1150
1151 /* use a define to avoid include chaining to get THIS_MODULE & friends */
1152 #define usb_register(driver) \
1153 usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
1154
1155 extern void usb_deregister(struct usb_driver *);
1156
1157 /**
1158 * module_usb_driver() - Helper macro for registering a USB driver
1159 * @__usb_driver: usb_driver struct
1160 *
1161 * Helper macro for USB drivers which do not do anything special in module
1162 * init/exit. This eliminates a lot of boilerplate. Each module may only
1163 * use this macro once, and calling it replaces module_init() and module_exit()
1164 */
1165 #define module_usb_driver(__usb_driver) \
1166 module_driver(__usb_driver, usb_register, \
1167 usb_deregister)
1168
1169 extern int usb_register_device_driver(struct usb_device_driver *,
1170 struct module *);
1171 extern void usb_deregister_device_driver(struct usb_device_driver *);
1172
1173 extern int usb_register_dev(struct usb_interface *intf,
1174 struct usb_class_driver *class_driver);
1175 extern void usb_deregister_dev(struct usb_interface *intf,
1176 struct usb_class_driver *class_driver);
1177
1178 extern int usb_disabled(void);
1179
1180 /* ----------------------------------------------------------------------- */
1181
1182 /*
1183 * URB support, for asynchronous request completions
1184 */
1185
1186 /*
1187 * urb->transfer_flags:
1188 *
1189 * Note: URB_DIR_IN/OUT is automatically set in usb_submit_urb().
1190 */
1191 #define URB_SHORT_NOT_OK 0x0001 /* report short reads as errors */
1192 #define URB_ISO_ASAP 0x0002 /* iso-only; use the first unexpired
1193 * slot in the schedule */
1194 #define URB_NO_TRANSFER_DMA_MAP 0x0004 /* urb->transfer_dma valid on submit */
1195 #define URB_NO_FSBR 0x0020 /* UHCI-specific */
1196 #define URB_ZERO_PACKET 0x0040 /* Finish bulk OUT with short packet */
1197 #define URB_NO_INTERRUPT 0x0080 /* HINT: no non-error interrupt
1198 * needed */
1199 #define URB_FREE_BUFFER 0x0100 /* Free transfer buffer with the URB */
1200
1201 /* The following flags are used internally by usbcore and HCDs */
1202 #define URB_DIR_IN 0x0200 /* Transfer from device to host */
1203 #define URB_DIR_OUT 0
1204 #define URB_DIR_MASK URB_DIR_IN
1205
1206 #define URB_DMA_MAP_SINGLE 0x00010000 /* Non-scatter-gather mapping */
1207 #define URB_DMA_MAP_PAGE 0x00020000 /* HCD-unsupported S-G */
1208 #define URB_DMA_MAP_SG 0x00040000 /* HCD-supported S-G */
1209 #define URB_MAP_LOCAL 0x00080000 /* HCD-local-memory mapping */
1210 #define URB_SETUP_MAP_SINGLE 0x00100000 /* Setup packet DMA mapped */
1211 #define URB_SETUP_MAP_LOCAL 0x00200000 /* HCD-local setup packet */
1212 #define URB_DMA_SG_COMBINED 0x00400000 /* S-G entries were combined */
1213 #define URB_ALIGNED_TEMP_BUFFER 0x00800000 /* Temp buffer was alloc'd */
1214
1215 struct usb_iso_packet_descriptor {
1216 unsigned int offset;
1217 unsigned int length; /* expected length */
1218 unsigned int actual_length;
1219 int status;
1220 };
1221
1222 struct urb;
1223
1224 struct usb_anchor {
1225 struct list_head urb_list;
1226 wait_queue_head_t wait;
1227 spinlock_t lock;
1228 atomic_t suspend_wakeups;
1229 unsigned int poisoned:1;
1230 };
1231
1232 static inline void init_usb_anchor(struct usb_anchor *anchor)
1233 {
1234 memset(anchor, 0, sizeof(*anchor));
1235 INIT_LIST_HEAD(&anchor->urb_list);
1236 init_waitqueue_head(&anchor->wait);
1237 spin_lock_init(&anchor->lock);
1238 }
1239
1240 typedef void (*usb_complete_t)(struct urb *);
1241
1242 /**
1243 * struct urb - USB Request Block
1244 * @urb_list: For use by current owner of the URB.
1245 * @anchor_list: membership in the list of an anchor
1246 * @anchor: to anchor URBs to a common mooring
1247 * @ep: Points to the endpoint's data structure. Will eventually
1248 * replace @pipe.
1249 * @pipe: Holds endpoint number, direction, type, and more.
1250 * Create these values with the eight macros available;
1251 * usb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"
1252 * (control), "bulk", "int" (interrupt), or "iso" (isochronous).
1253 * For example usb_sndbulkpipe() or usb_rcvintpipe(). Endpoint
1254 * numbers range from zero to fifteen. Note that "in" endpoint two
1255 * is a different endpoint (and pipe) from "out" endpoint two.
1256 * The current configuration controls the existence, type, and
1257 * maximum packet size of any given endpoint.
1258 * @stream_id: the endpoint's stream ID for bulk streams
1259 * @dev: Identifies the USB device to perform the request.
1260 * @status: This is read in non-iso completion functions to get the
1261 * status of the particular request. ISO requests only use it
1262 * to tell whether the URB was unlinked; detailed status for
1263 * each frame is in the fields of the iso_frame-desc.
1264 * @transfer_flags: A variety of flags may be used to affect how URB
1265 * submission, unlinking, or operation are handled. Different
1266 * kinds of URB can use different flags.
1267 * @transfer_buffer: This identifies the buffer to (or from) which the I/O
1268 * request will be performed unless URB_NO_TRANSFER_DMA_MAP is set
1269 * (however, do not leave garbage in transfer_buffer even then).
1270 * This buffer must be suitable for DMA; allocate it with
1271 * kmalloc() or equivalent. For transfers to "in" endpoints, contents
1272 * of this buffer will be modified. This buffer is used for the data
1273 * stage of control transfers.
1274 * @transfer_dma: When transfer_flags includes URB_NO_TRANSFER_DMA_MAP,
1275 * the device driver is saying that it provided this DMA address,
1276 * which the host controller driver should use in preference to the
1277 * transfer_buffer.
1278 * @sg: scatter gather buffer list, the buffer size of each element in
1279 * the list (except the last) must be divisible by the endpoint's
1280 * max packet size if no_sg_constraint isn't set in 'struct usb_bus'
1281 * @num_mapped_sgs: (internal) number of mapped sg entries
1282 * @num_sgs: number of entries in the sg list
1283 * @transfer_buffer_length: How big is transfer_buffer. The transfer may
1284 * be broken up into chunks according to the current maximum packet
1285 * size for the endpoint, which is a function of the configuration
1286 * and is encoded in the pipe. When the length is zero, neither
1287 * transfer_buffer nor transfer_dma is used.
1288 * @actual_length: This is read in non-iso completion functions, and
1289 * it tells how many bytes (out of transfer_buffer_length) were
1290 * transferred. It will normally be the same as requested, unless
1291 * either an error was reported or a short read was performed.
1292 * The URB_SHORT_NOT_OK transfer flag may be used to make such
1293 * short reads be reported as errors.
1294 * @setup_packet: Only used for control transfers, this points to eight bytes
1295 * of setup data. Control transfers always start by sending this data
1296 * to the device. Then transfer_buffer is read or written, if needed.
1297 * @setup_dma: DMA pointer for the setup packet. The caller must not use
1298 * this field; setup_packet must point to a valid buffer.
1299 * @start_frame: Returns the initial frame for isochronous transfers.
1300 * @number_of_packets: Lists the number of ISO transfer buffers.
1301 * @interval: Specifies the polling interval for interrupt or isochronous
1302 * transfers. The units are frames (milliseconds) for full and low
1303 * speed devices, and microframes (1/8 millisecond) for highspeed
1304 * and SuperSpeed devices.
1305 * @error_count: Returns the number of ISO transfers that reported errors.
1306 * @context: For use in completion functions. This normally points to
1307 * request-specific driver context.
1308 * @complete: Completion handler. This URB is passed as the parameter to the
1309 * completion function. The completion function may then do what
1310 * it likes with the URB, including resubmitting or freeing it.
1311 * @iso_frame_desc: Used to provide arrays of ISO transfer buffers and to
1312 * collect the transfer status for each buffer.
1313 *
1314 * This structure identifies USB transfer requests. URBs must be allocated by
1315 * calling usb_alloc_urb() and freed with a call to usb_free_urb().
1316 * Initialization may be done using various usb_fill_*_urb() functions. URBs
1317 * are submitted using usb_submit_urb(), and pending requests may be canceled
1318 * using usb_unlink_urb() or usb_kill_urb().
1319 *
1320 * Data Transfer Buffers:
1321 *
1322 * Normally drivers provide I/O buffers allocated with kmalloc() or otherwise
1323 * taken from the general page pool. That is provided by transfer_buffer
1324 * (control requests also use setup_packet), and host controller drivers
1325 * perform a dma mapping (and unmapping) for each buffer transferred. Those
1326 * mapping operations can be expensive on some platforms (perhaps using a dma
1327 * bounce buffer or talking to an IOMMU),
1328 * although they're cheap on commodity x86 and ppc hardware.
1329 *
1330 * Alternatively, drivers may pass the URB_NO_TRANSFER_DMA_MAP transfer flag,
1331 * which tells the host controller driver that no such mapping is needed for
1332 * the transfer_buffer since
1333 * the device driver is DMA-aware. For example, a device driver might
1334 * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map().
1335 * When this transfer flag is provided, host controller drivers will
1336 * attempt to use the dma address found in the transfer_dma
1337 * field rather than determining a dma address themselves.
1338 *
1339 * Note that transfer_buffer must still be set if the controller
1340 * does not support DMA (as indicated by bus.uses_dma) and when talking
1341 * to root hub. If you have to trasfer between highmem zone and the device
1342 * on such controller, create a bounce buffer or bail out with an error.
1343 * If transfer_buffer cannot be set (is in highmem) and the controller is DMA
1344 * capable, assign NULL to it, so that usbmon knows not to use the value.
1345 * The setup_packet must always be set, so it cannot be located in highmem.
1346 *
1347 * Initialization:
1348 *
1349 * All URBs submitted must initialize the dev, pipe, transfer_flags (may be
1350 * zero), and complete fields. All URBs must also initialize
1351 * transfer_buffer and transfer_buffer_length. They may provide the
1352 * URB_SHORT_NOT_OK transfer flag, indicating that short reads are
1353 * to be treated as errors; that flag is invalid for write requests.
1354 *
1355 * Bulk URBs may
1356 * use the URB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
1357 * should always terminate with a short packet, even if it means adding an
1358 * extra zero length packet.
1359 *
1360 * Control URBs must provide a valid pointer in the setup_packet field.
1361 * Unlike the transfer_buffer, the setup_packet may not be mapped for DMA
1362 * beforehand.
1363 *
1364 * Interrupt URBs must provide an interval, saying how often (in milliseconds
1365 * or, for highspeed devices, 125 microsecond units)
1366 * to poll for transfers. After the URB has been submitted, the interval
1367 * field reflects how the transfer was actually scheduled.
1368 * The polling interval may be more frequent than requested.
1369 * For example, some controllers have a maximum interval of 32 milliseconds,
1370 * while others support intervals of up to 1024 milliseconds.
1371 * Isochronous URBs also have transfer intervals. (Note that for isochronous
1372 * endpoints, as well as high speed interrupt endpoints, the encoding of
1373 * the transfer interval in the endpoint descriptor is logarithmic.
1374 * Device drivers must convert that value to linear units themselves.)
1375 *
1376 * If an isochronous endpoint queue isn't already running, the host
1377 * controller will schedule a new URB to start as soon as bandwidth
1378 * utilization allows. If the queue is running then a new URB will be
1379 * scheduled to start in the first transfer slot following the end of the
1380 * preceding URB, if that slot has not already expired. If the slot has
1381 * expired (which can happen when IRQ delivery is delayed for a long time),
1382 * the scheduling behavior depends on the URB_ISO_ASAP flag. If the flag
1383 * is clear then the URB will be scheduled to start in the expired slot,
1384 * implying that some of its packets will not be transferred; if the flag
1385 * is set then the URB will be scheduled in the first unexpired slot,
1386 * breaking the queue's synchronization. Upon URB completion, the
1387 * start_frame field will be set to the (micro)frame number in which the
1388 * transfer was scheduled. Ranges for frame counter values are HC-specific
1389 * and can go from as low as 256 to as high as 65536 frames.
1390 *
1391 * Isochronous URBs have a different data transfer model, in part because
1392 * the quality of service is only "best effort". Callers provide specially
1393 * allocated URBs, with number_of_packets worth of iso_frame_desc structures
1394 * at the end. Each such packet is an individual ISO transfer. Isochronous
1395 * URBs are normally queued, submitted by drivers to arrange that
1396 * transfers are at least double buffered, and then explicitly resubmitted
1397 * in completion handlers, so
1398 * that data (such as audio or video) streams at as constant a rate as the
1399 * host controller scheduler can support.
1400 *
1401 * Completion Callbacks:
1402 *
1403 * The completion callback is made in_interrupt(), and one of the first
1404 * things that a completion handler should do is check the status field.
1405 * The status field is provided for all URBs. It is used to report
1406 * unlinked URBs, and status for all non-ISO transfers. It should not
1407 * be examined before the URB is returned to the completion handler.
1408 *
1409 * The context field is normally used to link URBs back to the relevant
1410 * driver or request state.
1411 *
1412 * When the completion callback is invoked for non-isochronous URBs, the
1413 * actual_length field tells how many bytes were transferred. This field
1414 * is updated even when the URB terminated with an error or was unlinked.
1415 *
1416 * ISO transfer status is reported in the status and actual_length fields
1417 * of the iso_frame_desc array, and the number of errors is reported in
1418 * error_count. Completion callbacks for ISO transfers will normally
1419 * (re)submit URBs to ensure a constant transfer rate.
1420 *
1421 * Note that even fields marked "public" should not be touched by the driver
1422 * when the urb is owned by the hcd, that is, since the call to
1423 * usb_submit_urb() till the entry into the completion routine.
1424 */
1425 struct urb {
1426 /* private: usb core and host controller only fields in the urb */
1427 struct kref kref; /* reference count of the URB */
1428 void *hcpriv; /* private data for host controller */
1429 atomic_t use_count; /* concurrent submissions counter */
1430 atomic_t reject; /* submissions will fail */
1431 int unlinked; /* unlink error code */
1432
1433 /* public: documented fields in the urb that can be used by drivers */
1434 struct list_head urb_list; /* list head for use by the urb's
1435 * current owner */
1436 struct list_head anchor_list; /* the URB may be anchored */
1437 struct usb_anchor *anchor;
1438 struct usb_device *dev; /* (in) pointer to associated device */
1439 struct usb_host_endpoint *ep; /* (internal) pointer to endpoint */
1440 unsigned int pipe; /* (in) pipe information */
1441 unsigned int stream_id; /* (in) stream ID */
1442 int status; /* (return) non-ISO status */
1443 unsigned int transfer_flags; /* (in) URB_SHORT_NOT_OK | ...*/
1444 void *transfer_buffer; /* (in) associated data buffer */
1445 dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */
1446 struct scatterlist *sg; /* (in) scatter gather buffer list */
1447 int num_mapped_sgs; /* (internal) mapped sg entries */
1448 int num_sgs; /* (in) number of entries in the sg list */
1449 u32 transfer_buffer_length; /* (in) data buffer length */
1450 u32 actual_length; /* (return) actual transfer length */
1451 unsigned char *setup_packet; /* (in) setup packet (control only) */
1452 dma_addr_t setup_dma; /* (in) dma addr for setup_packet */
1453 int start_frame; /* (modify) start frame (ISO) */
1454 int number_of_packets; /* (in) number of ISO packets */
1455 int interval; /* (modify) transfer interval
1456 * (INT/ISO) */
1457 int error_count; /* (return) number of ISO errors */
1458 void *context; /* (in) context for completion */
1459 usb_complete_t complete; /* (in) completion routine */
1460 struct usb_iso_packet_descriptor iso_frame_desc[0];
1461 /* (in) ISO ONLY */
1462 };
1463
1464 /* ----------------------------------------------------------------------- */
1465
1466 /**
1467 * usb_fill_control_urb - initializes a control urb
1468 * @urb: pointer to the urb to initialize.
1469 * @dev: pointer to the struct usb_device for this urb.
1470 * @pipe: the endpoint pipe
1471 * @setup_packet: pointer to the setup_packet buffer
1472 * @transfer_buffer: pointer to the transfer buffer
1473 * @buffer_length: length of the transfer buffer
1474 * @complete_fn: pointer to the usb_complete_t function
1475 * @context: what to set the urb context to.
1476 *
1477 * Initializes a control urb with the proper information needed to submit
1478 * it to a device.
1479 */
1480 static inline void usb_fill_control_urb(struct urb *urb,
1481 struct usb_device *dev,
1482 unsigned int pipe,
1483 unsigned char *setup_packet,
1484 void *transfer_buffer,
1485 int buffer_length,
1486 usb_complete_t complete_fn,
1487 void *context)
1488 {
1489 urb->dev = dev;
1490 urb->pipe = pipe;
1491 urb->setup_packet = setup_packet;
1492 urb->transfer_buffer = transfer_buffer;
1493 urb->transfer_buffer_length = buffer_length;
1494 urb->complete = complete_fn;
1495 urb->context = context;
1496 }
1497
1498 /**
1499 * usb_fill_bulk_urb - macro to help initialize a bulk urb
1500 * @urb: pointer to the urb to initialize.
1501 * @dev: pointer to the struct usb_device for this urb.
1502 * @pipe: the endpoint pipe
1503 * @transfer_buffer: pointer to the transfer buffer
1504 * @buffer_length: length of the transfer buffer
1505 * @complete_fn: pointer to the usb_complete_t function
1506 * @context: what to set the urb context to.
1507 *
1508 * Initializes a bulk urb with the proper information needed to submit it
1509 * to a device.
1510 */
1511 static inline void usb_fill_bulk_urb(struct urb *urb,
1512 struct usb_device *dev,
1513 unsigned int pipe,
1514 void *transfer_buffer,
1515 int buffer_length,
1516 usb_complete_t complete_fn,
1517 void *context)
1518 {
1519 urb->dev = dev;
1520 urb->pipe = pipe;
1521 urb->transfer_buffer = transfer_buffer;
1522 urb->transfer_buffer_length = buffer_length;
1523 urb->complete = complete_fn;
1524 urb->context = context;
1525 }
1526
1527 /**
1528 * usb_fill_int_urb - macro to help initialize a interrupt urb
1529 * @urb: pointer to the urb to initialize.
1530 * @dev: pointer to the struct usb_device for this urb.
1531 * @pipe: the endpoint pipe
1532 * @transfer_buffer: pointer to the transfer buffer
1533 * @buffer_length: length of the transfer buffer
1534 * @complete_fn: pointer to the usb_complete_t function
1535 * @context: what to set the urb context to.
1536 * @interval: what to set the urb interval to, encoded like
1537 * the endpoint descriptor's bInterval value.
1538 *
1539 * Initializes a interrupt urb with the proper information needed to submit
1540 * it to a device.
1541 *
1542 * Note that High Speed and SuperSpeed interrupt endpoints use a logarithmic
1543 * encoding of the endpoint interval, and express polling intervals in
1544 * microframes (eight per millisecond) rather than in frames (one per
1545 * millisecond).
1546 *
1547 * Wireless USB also uses the logarithmic encoding, but specifies it in units of
1548 * 128us instead of 125us. For Wireless USB devices, the interval is passed
1549 * through to the host controller, rather than being translated into microframe
1550 * units.
1551 */
1552 static inline void usb_fill_int_urb(struct urb *urb,
1553 struct usb_device *dev,
1554 unsigned int pipe,
1555 void *transfer_buffer,
1556 int buffer_length,
1557 usb_complete_t complete_fn,
1558 void *context,
1559 int interval)
1560 {
1561 urb->dev = dev;
1562 urb->pipe = pipe;
1563 urb->transfer_buffer = transfer_buffer;
1564 urb->transfer_buffer_length = buffer_length;
1565 urb->complete = complete_fn;
1566 urb->context = context;
1567
1568 if (dev->speed == USB_SPEED_HIGH || dev->speed == USB_SPEED_SUPER) {
1569 /* make sure interval is within allowed range */
1570 interval = clamp(interval, 1, 16);
1571
1572 urb->interval = 1 << (interval - 1);
1573 } else {
1574 urb->interval = interval;
1575 }
1576
1577 urb->start_frame = -1;
1578 }
1579
1580 extern void usb_init_urb(struct urb *urb);
1581 extern struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags);
1582 extern void usb_free_urb(struct urb *urb);
1583 #define usb_put_urb usb_free_urb
1584 extern struct urb *usb_get_urb(struct urb *urb);
1585 extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);
1586 extern int usb_unlink_urb(struct urb *urb);
1587 extern void usb_kill_urb(struct urb *urb);
1588 extern void usb_poison_urb(struct urb *urb);
1589 extern void usb_unpoison_urb(struct urb *urb);
1590 extern void usb_block_urb(struct urb *urb);
1591 extern void usb_kill_anchored_urbs(struct usb_anchor *anchor);
1592 extern void usb_poison_anchored_urbs(struct usb_anchor *anchor);
1593 extern void usb_unpoison_anchored_urbs(struct usb_anchor *anchor);
1594 extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor);
1595 extern void usb_anchor_suspend_wakeups(struct usb_anchor *anchor);
1596 extern void usb_anchor_resume_wakeups(struct usb_anchor *anchor);
1597 extern void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor);
1598 extern void usb_unanchor_urb(struct urb *urb);
1599 extern int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,
1600 unsigned int timeout);
1601 extern struct urb *usb_get_from_anchor(struct usb_anchor *anchor);
1602 extern void usb_scuttle_anchored_urbs(struct usb_anchor *anchor);
1603 extern int usb_anchor_empty(struct usb_anchor *anchor);
1604
1605 #define usb_unblock_urb usb_unpoison_urb
1606
1607 /**
1608 * usb_urb_dir_in - check if an URB describes an IN transfer
1609 * @urb: URB to be checked
1610 *
1611 * Return: 1 if @urb describes an IN transfer (device-to-host),
1612 * otherwise 0.
1613 */
1614 static inline int usb_urb_dir_in(struct urb *urb)
1615 {
1616 return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_IN;
1617 }
1618
1619 /**
1620 * usb_urb_dir_out - check if an URB describes an OUT transfer
1621 * @urb: URB to be checked
1622 *
1623 * Return: 1 if @urb describes an OUT transfer (host-to-device),
1624 * otherwise 0.
1625 */
1626 static inline int usb_urb_dir_out(struct urb *urb)
1627 {
1628 return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_OUT;
1629 }
1630
1631 void *usb_alloc_coherent(struct usb_device *dev, size_t size,
1632 gfp_t mem_flags, dma_addr_t *dma);
1633 void usb_free_coherent(struct usb_device *dev, size_t size,
1634 void *addr, dma_addr_t dma);
1635
1636 #if 0
1637 struct urb *usb_buffer_map(struct urb *urb);
1638 void usb_buffer_dmasync(struct urb *urb);
1639 void usb_buffer_unmap(struct urb *urb);
1640 #endif
1641
1642 struct scatterlist;
1643 int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
1644 struct scatterlist *sg, int nents);
1645 #if 0
1646 void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
1647 struct scatterlist *sg, int n_hw_ents);
1648 #endif
1649 void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
1650 struct scatterlist *sg, int n_hw_ents);
1651
1652 /*-------------------------------------------------------------------*
1653 * SYNCHRONOUS CALL SUPPORT *
1654 *-------------------------------------------------------------------*/
1655
1656 extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,
1657 __u8 request, __u8 requesttype, __u16 value, __u16 index,
1658 void *data, __u16 size, int timeout);
1659 extern int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe,
1660 void *data, int len, int *actual_length, int timeout);
1661 extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
1662 void *data, int len, int *actual_length,
1663 int timeout);
1664
1665 /* wrappers around usb_control_msg() for the most common standard requests */
1666 extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
1667 unsigned char descindex, void *buf, int size);
1668 extern int usb_get_status(struct usb_device *dev,
1669 int type, int target, void *data);
1670 extern int usb_string(struct usb_device *dev, int index,
1671 char *buf, size_t size);
1672
1673 /* wrappers that also update important state inside usbcore */
1674 extern int usb_clear_halt(struct usb_device *dev, int pipe);
1675 extern int usb_reset_configuration(struct usb_device *dev);
1676 extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
1677 extern void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr);
1678
1679 /* this request isn't really synchronous, but it belongs with the others */
1680 extern int usb_driver_set_configuration(struct usb_device *udev, int config);
1681
1682 /* choose and set configuration for device */
1683 extern int usb_choose_configuration(struct usb_device *udev);
1684 extern int usb_set_configuration(struct usb_device *dev, int configuration);
1685
1686 /*
1687 * timeouts, in milliseconds, used for sending/receiving control messages
1688 * they typically complete within a few frames (msec) after they're issued
1689 * USB identifies 5 second timeouts, maybe more in a few cases, and a few
1690 * slow devices (like some MGE Ellipse UPSes) actually push that limit.
1691 */
1692 #define USB_CTRL_GET_TIMEOUT 5000
1693 #define USB_CTRL_SET_TIMEOUT 5000
1694
1695
1696 /**
1697 * struct usb_sg_request - support for scatter/gather I/O
1698 * @status: zero indicates success, else negative errno
1699 * @bytes: counts bytes transferred.
1700 *
1701 * These requests are initialized using usb_sg_init(), and then are used
1702 * as request handles passed to usb_sg_wait() or usb_sg_cancel(). Most
1703 * members of the request object aren't for driver access.
1704 *
1705 * The status and bytecount values are valid only after usb_sg_wait()
1706 * returns. If the status is zero, then the bytecount matches the total
1707 * from the request.
1708 *
1709 * After an error completion, drivers may need to clear a halt condition
1710 * on the endpoint.
1711 */
1712 struct usb_sg_request {
1713 int status;
1714 size_t bytes;
1715
1716 /* private:
1717 * members below are private to usbcore,
1718 * and are not provided for driver access!
1719 */
1720 spinlock_t lock;
1721
1722 struct usb_device *dev;
1723 int pipe;
1724
1725 int entries;
1726 struct urb **urbs;
1727
1728 int count;
1729 struct completion complete;
1730 };
1731
1732 int usb_sg_init(
1733 struct usb_sg_request *io,
1734 struct usb_device *dev,
1735 unsigned pipe,
1736 unsigned period,
1737 struct scatterlist *sg,
1738 int nents,
1739 size_t length,
1740 gfp_t mem_flags
1741 );
1742 void usb_sg_cancel(struct usb_sg_request *io);
1743 void usb_sg_wait(struct usb_sg_request *io);
1744
1745
1746 /* ----------------------------------------------------------------------- */
1747
1748 /*
1749 * For various legacy reasons, Linux has a small cookie that's paired with
1750 * a struct usb_device to identify an endpoint queue. Queue characteristics
1751 * are defined by the endpoint's descriptor. This cookie is called a "pipe",
1752 * an unsigned int encoded as:
1753 *
1754 * - direction: bit 7 (0 = Host-to-Device [Out],
1755 * 1 = Device-to-Host [In] ...
1756 * like endpoint bEndpointAddress)
1757 * - device address: bits 8-14 ... bit positions known to uhci-hcd
1758 * - endpoint: bits 15-18 ... bit positions known to uhci-hcd
1759 * - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,
1760 * 10 = control, 11 = bulk)
1761 *
1762 * Given the device address and endpoint descriptor, pipes are redundant.
1763 */
1764
1765 /* NOTE: these are not the standard USB_ENDPOINT_XFER_* values!! */
1766 /* (yet ... they're the values used by usbfs) */
1767 #define PIPE_ISOCHRONOUS 0
1768 #define PIPE_INTERRUPT 1
1769 #define PIPE_CONTROL 2
1770 #define PIPE_BULK 3
1771
1772 #define usb_pipein(pipe) ((pipe) & USB_DIR_IN)
1773 #define usb_pipeout(pipe) (!usb_pipein(pipe))
1774
1775 #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f)
1776 #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf)
1777
1778 #define usb_pipetype(pipe) (((pipe) >> 30) & 3)
1779 #define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
1780 #define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT)
1781 #define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL)
1782 #define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK)
1783
1784 static inline unsigned int __create_pipe(struct usb_device *dev,
1785 unsigned int endpoint)
1786 {
1787 return (dev->devnum << 8) | (endpoint << 15);
1788 }
1789
1790 /* Create various pipes... */
1791 #define usb_sndctrlpipe(dev, endpoint) \
1792 ((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint))
1793 #define usb_rcvctrlpipe(dev, endpoint) \
1794 ((PIPE_CONTROL << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
1795 #define usb_sndisocpipe(dev, endpoint) \
1796 ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint))
1797 #define usb_rcvisocpipe(dev, endpoint) \
1798 ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
1799 #define usb_sndbulkpipe(dev, endpoint) \
1800 ((PIPE_BULK << 30) | __create_pipe(dev, endpoint))
1801 #define usb_rcvbulkpipe(dev, endpoint) \
1802 ((PIPE_BULK << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
1803 #define usb_sndintpipe(dev, endpoint) \
1804 ((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint))
1805 #define usb_rcvintpipe(dev, endpoint) \
1806 ((PIPE_INTERRUPT << 30) | __create_pipe(dev, endpoint) | USB_DIR_IN)
1807
1808 static inline struct usb_host_endpoint *
1809 usb_pipe_endpoint(struct usb_device *dev, unsigned int pipe)
1810 {
1811 struct usb_host_endpoint **eps;
1812 eps = usb_pipein(pipe) ? dev->ep_in : dev->ep_out;
1813 return eps[usb_pipeendpoint(pipe)];
1814 }
1815
1816 /*-------------------------------------------------------------------------*/
1817
1818 static inline __u16
1819 usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
1820 {
1821 struct usb_host_endpoint *ep;
1822 unsigned epnum = usb_pipeendpoint(pipe);
1823
1824 if (is_out) {
1825 WARN_ON(usb_pipein(pipe));
1826 ep = udev->ep_out[epnum];
1827 } else {
1828 WARN_ON(usb_pipeout(pipe));
1829 ep = udev->ep_in[epnum];
1830 }
1831 if (!ep)
1832 return 0;
1833
1834 /* NOTE: only 0x07ff bits are for packet size... */
1835 return usb_endpoint_maxp(&ep->desc);
1836 }
1837
1838 /* ----------------------------------------------------------------------- */
1839
1840 /* translate USB error codes to codes user space understands */
1841 static inline int usb_translate_errors(int error_code)
1842 {
1843 switch (error_code) {
1844 case 0:
1845 case -ENOMEM:
1846 case -ENODEV:
1847 case -EOPNOTSUPP:
1848 return error_code;
1849 default:
1850 return -EIO;
1851 }
1852 }
1853
1854 /* Events from the usb core */
1855 #define USB_DEVICE_ADD 0x0001
1856 #define USB_DEVICE_REMOVE 0x0002
1857 #define USB_BUS_ADD 0x0003
1858 #define USB_BUS_REMOVE 0x0004
1859 extern void usb_register_notify(struct notifier_block *nb);
1860 extern void usb_unregister_notify(struct notifier_block *nb);
1861
1862 /* debugfs stuff */
1863 extern struct dentry *usb_debug_root;
1864
1865 #endif /* __KERNEL__ */
1866
1867 #endif |
Here is an explanation of a rule violation arisen while checking your driver against a corresponding kernel.
Note that it may be false positive, i.e. there isn't a real error indeed. Please analyze a given error trace and related source code to understand whether there is an error in your driver.
Error trace column contains a path on which the given rule is violated. You can expand/collapse some entity classes by clicking on corresponding checkboxes in a main menu or in an advanced Others menu. Also you can expand/collapse each particular entity by clicking on +/-. In hovering on some entities you can see some tips. Also the error trace is bound with related source code. Line numbers may be shown as links on the left. You can click on them to open corresponding lines in source code.
Source code column contains a content of files related with the error trace. There is source code of your driver (note that there are some LDV modifications at the end), kernel headers and rule model. Tabs show a currently opened file and other available files. In hovering on them you can see full file names. On clicking a corresponding file content will be shown.
| Kernel | Module | Rule | Verifier | Verdict | Status | Timestamp | Bug report |
| linux-3.16-rc1.tar.xz | drivers/net/wireless/rsi/rsi_usb.ko | 68_1a | BLAST | Bug | Fixed | 2015-03-13 15:16:07 | L0159 |
Comment
L0159
[Home]
»