Error Trace

[Home]

Bug # 47

Show/hide error trace
Error trace
Function bodies
Blocks
  • Others...
    Function bodies without model function calls
    Initialization function calls
    Initialization function bodies
    Entry point
    Entry point body
    Function calls
    Skipped function calls
    Formal parameter names
    Declarations
    Assumes
    Assume conditions
    Returns
    Return values
    DEG initialization
    DEG function calls
    Model function calls
    Model function bodies
    Model asserts
    Model state changes
    Model function function calls
    Model function function bodies
    Model returns
    Model others
    Identation
    Line numbers
    Expand signs
-__BLAST_initialize_/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--134_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/7095/dscv_tempdir/dscv/rcv/134_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_/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--134_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/7095/dscv_tempdir/dscv/rcv/134_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/net/wireless/rsi/rsi_91x_usb_ops.o.i()
{
return ;
}
-__BLAST_initialize_/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--134_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/7095/dscv_tempdir/dscv/rcv/134_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp//work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--134_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/7095/dscv_tempdir/rule-instrumentor/134_1a/common-model/ldv_common_model.o.i()
{
13 ldv_probe_state = 0;
return ;
}
-entry_point
{
718 -ldv_s_rsi_driver_usb_driver = 0;
LDV_IN_INTERRUPT = 1;
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 */}
716 -tmp = rsi_module_init()
{
562 -ldv_usb_register()
{
21 assume(nondet < 0);
23 ldv_probe_state = 1;
25 __retres2 = nondet;
16 return __retres2;
}
563 rsi_dbg(4, "%s: Registering driver\n", "rsi_module_init") { /* Function call is skipped due to function is undefined */}
564 __retres1 = 0;
560 return __retres1;
}
716 assume(tmp == 0);
721 tmp___1 = nondet_int() { /* Function call is skipped due to function is undefined */}
721 assume(tmp___1 != 0);
725 tmp___0 = nondet_int() { /* Function call is skipped due to function is undefined */}
727 assume(tmp___0 == 0);
730 assume(ldv_s_rsi_driver_usb_driver == 0);
738 -res_rsi_probe_11 = rsi_probe(var_group1 /* pfunction */, var_rsi_probe_11_p1 /* id */)
{
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 */}
453 assume(adapter != 0);
459 -tmp = rsi_init_usb_interface(adapter /* adapter */, pfunction /* pfunction */)
{
378 common = *(adapter).priv;
381 -tmp = kzalloc(296 /* size */, 208 /* flags */)
{
639 -tmp = kmalloc(size /* size */, flags | 32768 /* flags */)
{
462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */}
462 return tmp___2;
}
639 return tmp;
}
381 rsi_dev = tmp;
382 assume(rsi_dev != 0);
385 *(adapter).rsi_dev = rsi_dev;
386 -*(rsi_dev).usbdev = interface_to_usbdev(pfunction /* intf */)
{
597 __mptr = *(intf).dev.parent;
597 __retres3 = __mptr + -144;
595 return __retres3;
}
388 -tmp___0 = rsi_find_bulk_in_and_out_endpoints(pfunction /* interface */, adapter /* adapter */)
{
101 -dev = *(adapter).rsi_dev;
bep_found = 0;
iface_desc = *(interface).altsetting;
ii = 0;
109 assume(*(iface_desc).desc.bNumEndpoints <= ii);
138 assume(*(dev).bulkin_endpoint_addr != 0);
142 __retres10 = 0;
98 return __retres10;
}
388 assume(tmp___0 == 0);
391 *(adapter).device = &(pfunction)->dev;
392 -usb_set_intfdata(pfunction /* intf */, adapter /* data */)
{
201 -dev_set_drvdata(&(intf)->dev /* dev */, data /* data */)
{
844 *(dev).driver_data = data;
842 return ;
}
199 return ;
}
394 -tmp___1 = kmalloc(2048 /* size */, 208 /* flags */)
{
462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */}
462 return tmp___2;
}
394 *(common).rx_data_pkt = tmp___1;
395 assume(*(common).rx_data_pkt != 0);
401 -tmp___2 = kmalloc(2048 /* size */, 32 /* flags */)
{
462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */}
462 return tmp___2;
}
401 *(rsi_dev).tx_buffer = tmp___2;
402 *(rsi_dev).rx_usb_urb[ 0 ] = usb_alloc_urb(0, 208) { /* Function call is skipped due to function is undefined */}
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);
412 -rsi_init_event(&(&(rsi_dev)->rx_thread)->event /* pevent */)
{
30 -atomic_set(&(pevent)->event_condition /* v */, 1 /* i */)
{
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 */)
{
65 -init_completion(&(thread)->completion /* x */)
{
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 -tmp___0 = IS_ERR(__k /* ptr */)
{
30 tmp = ldv_is_err(ptr) { /* Function call is skipped due to function is undefined */}
30 return tmp;
}
66 assume(tmp___0 != 0);
66 tmp___1 = 0;
66 assume(tmp___1 == 0);
66 *(thread).task = __k;
67 -tmp___3 = IS_ERR(*(thread).task /* ptr */)
{
30 tmp = ldv_is_err(ptr) { /* Function call is skipped due to function is undefined */}
30 return tmp;
}
67 assume(tmp___3 == 0);
70 __retres11 = 0;
60 return __retres11;
}
415 assume(status == 0);
422 *(adapter).num_debugfs_entries = 3;
425 rsi_dbg(4, "%s: Enabled the interface\n", "rsi_init_usb_interface") { /* Function call is skipped due to function is undefined */}
426 __retres12 = 0;
374 return __retres12;
}
459 assume(tmp == 0);
465 rsi_dbg(1, "%s: Initialized os intf ops\n", "rsi_probe") { /* Function call is skipped due to function is undefined */}
467 dev = *(adapter).rsi_dev;
469 -tmp___0 = rsi_usb_reg_read(*(dev).usbdev /* usbdev */, 1090846738 /* reg */, &(fw_status) /* value */, 2 /* len */)
{
159 status = -12;
161 -tmp = kmalloc(4 /* size */, 208 /* flags */)
{
462 tmp___2 = __kmalloc(size, flags) { /* Function call is skipped due to function is undefined */}
462 return tmp___2;
}
161 buf = tmp;
162 assume(buf != 0);
165 -tmp___0 = __create_pipe(usbdev /* dev */, 0 /* endpoint */)
{
1787 __retres3 = *(dev).devnum << 8 | endpoint << 15;
1784 return __retres3;
}
165 status = usb_control_msg(usbdev, tmp___0 | 2147483776, 21, 64, reg >> 16, reg, buf, len, 1250) { /* Function call is skipped due to function is undefined */}
174 *(value) = *(buf) | *(buf + 1) << 8;
175 assume(status >= 0);
180 kfree(buf) { /* Function call is skipped due to function is undefined */}
182 __retres10 = status;
153 return __retres10;
}
469 assume(tmp___0 >= 0);
472 fw_status = fw_status & 1;
474 assume(fw_status != 0);
488 -tmp___3 = rsi_rx_urb_submit(adapter /* adapter */)
{
257 -dev = *(adapter).rsi_dev;
urb = *(dev).rx_usb_urb[ 0 ];
261 -tmp = __create_pipe(*(dev).usbdev /* dev */, *(dev).bulkin_endpoint_addr /* endpoint */)
{
1787 __retres3 = *(dev).devnum << 8 | endpoint << 15;
1784 return __retres3;
}
261 -usb_fill_bulk_urb(urb /* urb */, *(dev).usbdev /* dev */, tmp | 3221225600 /* pipe */, *(urb).transfer_buffer /* transfer_buffer */, 3000 /* buffer_length */, &(rsi_rx_done_handler) /* complete_fn */, adapter /* context */)
{
1519 -*(urb).dev = dev;
*(urb).pipe = pipe;
*(urb).transfer_buffer = transfer_buffer;
*(urb).transfer_buffer_length = buffer_length;
*(urb).complete = complete_fn;
*(urb).context = context;
1511 return ;
}
270 status = usb_submit_urb(urb, 208) { /* Function call is skipped due to function is undefined */}
271 assume(status == 0);
274 return status;
}
488 assume(tmp___3 == 0);
491 __retres11 = 0;
443 return __retres11;
}
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 /* retval */)
{
52 assume(ldv_probe_state == 1);
53 assume(retval == 0);
53 -ldv_error()
{
}
}
}
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 bool ldv_is_err(const void *ptr); 4 bool ldv_is_err_or_null(const void *ptr); 5 void* ldv_err_ptr(long error); 6 long ldv_ptr_err(const void *ptr); 7 8 #include <linux/kernel.h> 9 #include <linux/module.h> 10 11 // Provide model function prototypes before their usage. 12 int ldv_usb_register(void); 13 int ldv_register_netdev(void); 14 #line 1 "/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--134_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/7095/dscv_tempdir/dscv/ri/134_1a/drivers/net/wireless/rsi/rsi_91x_usb.c" 15 16 /** 17 * Copyright (c) 2014 Redpine Signals Inc. 18 * 19 * Permission to use, copy, modify, and/or distribute this software for any 20 * purpose with or without fee is hereby granted, provided that the above 21 * copyright notice and this permission notice appear in all copies. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 24 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 25 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 26 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 27 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 28 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 29 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 30 * 31 */ 32 33 #include <linux/module.h> 34 #include "rsi_usb.h" 35 36 /** 37 * rsi_usb_card_write() - This function writes to the USB Card. 38 * @adapter: Pointer to the adapter structure. 39 * @buf: Pointer to the buffer from where the data has to be taken. 40 * @len: Length to be written. 41 * @endpoint: Type of endpoint. 42 * 43 * Return: status: 0 on success, -1 on failure. 44 */ 45 static int rsi_usb_card_write(struct rsi_hw *adapter, 46 void *buf, 47 u16 len, 48 u8 endpoint) 49 { 50 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 51 int status; 52 s32 transfer; 53 54 status = usb_bulk_msg(dev->usbdev, 55 usb_sndbulkpipe(dev->usbdev, 56 dev->bulkout_endpoint_addr[endpoint - 1]), 57 buf, 58 len, 59 &transfer, 60 HZ * 5); 61 62 if (status < 0) { 63 rsi_dbg(ERR_ZONE, 64 "Card write failed with error code :%10d\n", status); 65 dev->write_fail = 1; 66 } 67 return status; 68 } 69 70 /** 71 * rsi_write_multiple() - This function writes multiple bytes of information 72 * to the USB card. 73 * @adapter: Pointer to the adapter structure. 74 * @addr: Address of the register. 75 * @data: Pointer to the data that has to be written. 76 * @count: Number of multiple bytes to be written. 77 * 78 * Return: 0 on success, -1 on failure. 79 */ 80 static int rsi_write_multiple(struct rsi_hw *adapter, 81 u8 endpoint, 82 u8 *data, 83 u32 count) 84 { 85 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 86 u8 *seg = dev->tx_buffer; 87 88 if (dev->write_fail) 89 return 0; 90 91 if (endpoint == MGMT_EP) { 92 memset(seg, 0, RSI_USB_TX_HEAD_ROOM); 93 memcpy(seg + RSI_USB_TX_HEAD_ROOM, data, count); 94 } else { 95 seg = ((u8 *)data - RSI_USB_TX_HEAD_ROOM); 96 } 97 98 return rsi_usb_card_write(adapter, 99 seg, 100 count + RSI_USB_TX_HEAD_ROOM, 101 endpoint); 102 } 103 104 /** 105 * rsi_find_bulk_in_and_out_endpoints() - This function initializes the bulk 106 * endpoints to the device. 107 * @interface: Pointer to the USB interface structure. 108 * @adapter: Pointer to the adapter structure. 109 * 110 * Return: ret_val: 0 on success, -ENOMEM on failure. 111 */ 112 static int rsi_find_bulk_in_and_out_endpoints(struct usb_interface *interface, 113 struct rsi_hw *adapter) 114 { 115 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 116 struct usb_host_interface *iface_desc; 117 struct usb_endpoint_descriptor *endpoint; 118 __le16 buffer_size; 119 int ii, bep_found = 0; 120 121 iface_desc = &(interface->altsetting[0]); 122 123 for (ii = 0; ii < iface_desc->desc.bNumEndpoints; ++ii) { 124 endpoint = &(iface_desc->endpoint[ii].desc); 125 126 if ((!(dev->bulkin_endpoint_addr)) && 127 (endpoint->bEndpointAddress & USB_DIR_IN) && 128 ((endpoint->bmAttributes & 129 USB_ENDPOINT_XFERTYPE_MASK) == 130 USB_ENDPOINT_XFER_BULK)) { 131 buffer_size = endpoint->wMaxPacketSize; 132 dev->bulkin_size = buffer_size; 133 dev->bulkin_endpoint_addr = 134 endpoint->bEndpointAddress; 135 } 136 137 if (!dev->bulkout_endpoint_addr[bep_found] && 138 !(endpoint->bEndpointAddress & USB_DIR_IN) && 139 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 140 USB_ENDPOINT_XFER_BULK)) { 141 dev->bulkout_endpoint_addr[bep_found] = 142 endpoint->bEndpointAddress; 143 buffer_size = endpoint->wMaxPacketSize; 144 dev->bulkout_size[bep_found] = buffer_size; 145 bep_found++; 146 } 147 148 if (bep_found >= MAX_BULK_EP) 149 break; 150 } 151 152 if (!(dev->bulkin_endpoint_addr) && 153 (dev->bulkout_endpoint_addr[0])) 154 return -EINVAL; 155 156 return 0; 157 } 158 159 /* rsi_usb_reg_read() - This function reads data from given register address. 160 * @usbdev: Pointer to the usb_device structure. 161 * @reg: Address of the register to be read. 162 * @value: Value to be read. 163 * @len: length of data to be read. 164 * 165 * Return: status: 0 on success, -1 on failure. 166 */ 167 static int rsi_usb_reg_read(struct usb_device *usbdev, 168 u32 reg, 169 u16 *value, 170 u16 len) 171 { 172 u8 *buf; 173 int status = -ENOMEM; 174 175 buf = kmalloc(0x04, GFP_KERNEL); 176 if (!buf) 177 return status; 178 179 status = usb_control_msg(usbdev, 180 usb_rcvctrlpipe(usbdev, 0), 181 USB_VENDOR_REGISTER_READ, 182 USB_TYPE_VENDOR, 183 ((reg & 0xffff0000) >> 16), (reg & 0xffff), 184 (void *)buf, 185 len, 186 HZ * 5); 187 188 *value = (buf[0] | (buf[1] << 8)); 189 if (status < 0) { 190 rsi_dbg(ERR_ZONE, 191 "%s: Reg read failed with error code :%d\n", 192 __func__, status); 193 } 194 kfree(buf); 195 196 return status; 197 } 198 199 /** 200 * rsi_usb_reg_write() - This function writes the given data into the given 201 * register address. 202 * @usbdev: Pointer to the usb_device structure. 203 * @reg: Address of the register. 204 * @value: Value to write. 205 * @len: Length of data to be written. 206 * 207 * Return: status: 0 on success, -1 on failure. 208 */ 209 static int rsi_usb_reg_write(struct usb_device *usbdev, 210 u32 reg, 211 u16 value, 212 u16 len) 213 { 214 u8 *usb_reg_buf; 215 int status = -ENOMEM; 216 217 usb_reg_buf = kmalloc(0x04, GFP_KERNEL); 218 if (!usb_reg_buf) 219 return status; 220 221 usb_reg_buf[0] = (value & 0x00ff); 222 usb_reg_buf[1] = (value & 0xff00) >> 8; 223 usb_reg_buf[2] = 0x0; 224 usb_reg_buf[3] = 0x0; 225 226 status = usb_control_msg(usbdev, 227 usb_sndctrlpipe(usbdev, 0), 228 USB_VENDOR_REGISTER_WRITE, 229 USB_TYPE_VENDOR, 230 ((reg & 0xffff0000) >> 16), 231 (reg & 0xffff), 232 (void *)usb_reg_buf, 233 len, 234 HZ * 5); 235 if (status < 0) { 236 rsi_dbg(ERR_ZONE, 237 "%s: Reg write failed with error code :%d\n", 238 __func__, status); 239 } 240 kfree(usb_reg_buf); 241 242 return status; 243 } 244 245 /** 246 * rsi_rx_done_handler() - This function is called when a packet is received 247 * from USB stack. This is callback to recieve done. 248 * @urb: Received URB. 249 * 250 * Return: None. 251 */ 252 static void rsi_rx_done_handler(struct urb *urb) 253 { 254 struct rsi_hw *adapter = urb->context; 255 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 256 257 if (urb->status) 258 return; 259 260 rsi_set_event(&dev->rx_thread.event); 261 } 262 263 /** 264 * rsi_rx_urb_submit() - This function submits the given URB to the USB stack. 265 * @adapter: Pointer to the adapter structure. 266 * 267 * Return: 0 on success, -1 on failure. 268 */ 269 static int rsi_rx_urb_submit(struct rsi_hw *adapter) 270 { 271 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 272 struct urb *urb = dev->rx_usb_urb[0]; 273 int status; 274 275 usb_fill_bulk_urb(urb, 276 dev->usbdev, 277 usb_rcvbulkpipe(dev->usbdev, 278 dev->bulkin_endpoint_addr), 279 urb->transfer_buffer, 280 3000, 281 rsi_rx_done_handler, 282 adapter); 283 284 status = usb_submit_urb(urb, GFP_KERNEL); 285 if (status) 286 rsi_dbg(ERR_ZONE, "%s: Failed in urb submission\n", __func__); 287 288 return status; 289 } 290 291 /** 292 * rsi_usb_write_register_multiple() - This function writes multiple bytes of 293 * information to multiple registers. 294 * @adapter: Pointer to the adapter structure. 295 * @addr: Address of the register. 296 * @data: Pointer to the data that has to be written. 297 * @count: Number of multiple bytes to be written on to the registers. 298 * 299 * Return: status: 0 on success, -1 on failure. 300 */ 301 int rsi_usb_write_register_multiple(struct rsi_hw *adapter, 302 u32 addr, 303 u8 *data, 304 u32 count) 305 { 306 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 307 u8 *buf; 308 u8 transfer; 309 int status = 0; 310 311 buf = kzalloc(4096, GFP_KERNEL); 312 if (!buf) 313 return -ENOMEM; 314 315 while (count) { 316 transfer = (u8)(min_t(u32, count, 4096)); 317 memcpy(buf, data, transfer); 318 status = usb_control_msg(dev->usbdev, 319 usb_sndctrlpipe(dev->usbdev, 0), 320 USB_VENDOR_REGISTER_WRITE, 321 USB_TYPE_VENDOR, 322 ((addr & 0xffff0000) >> 16), 323 (addr & 0xffff), 324 (void *)buf, 325 transfer, 326 HZ * 5); 327 if (status < 0) { 328 rsi_dbg(ERR_ZONE, 329 "Reg write failed with error code :%d\n", 330 status); 331 } else { 332 count -= transfer; 333 data += transfer; 334 addr += transfer; 335 } 336 } 337 338 kfree(buf); 339 return 0; 340 } 341 342 /** 343 *rsi_usb_host_intf_write_pkt() - This function writes the packet to the 344 * USB card. 345 * @adapter: Pointer to the adapter structure. 346 * @pkt: Pointer to the data to be written on to the card. 347 * @len: Length of the data to be written on to the card. 348 * 349 * Return: 0 on success, -1 on failure. 350 */ 351 static int rsi_usb_host_intf_write_pkt(struct rsi_hw *adapter, 352 u8 *pkt, 353 u32 len) 354 { 355 u32 queueno = ((pkt[1] >> 4) & 0xf); 356 u8 endpoint; 357 358 endpoint = ((queueno == RSI_WIFI_MGMT_Q) ? MGMT_EP : DATA_EP); 359 360 return rsi_write_multiple(adapter, 361 endpoint, 362 (u8 *)pkt, 363 len); 364 } 365 366 /** 367 * rsi_deinit_usb_interface() - This function deinitializes the usb interface. 368 * @adapter: Pointer to the adapter structure. 369 * 370 * Return: None. 371 */ 372 static void rsi_deinit_usb_interface(struct rsi_hw *adapter) 373 { 374 struct rsi_91x_usbdev *dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 375 376 rsi_kill_thread(&dev->rx_thread); 377 kfree(adapter->priv->rx_data_pkt); 378 kfree(dev->tx_buffer); 379 } 380 381 /** 382 * rsi_init_usb_interface() - This function initializes the usb interface. 383 * @adapter: Pointer to the adapter structure. 384 * @pfunction: Pointer to USB interface structure. 385 * 386 * Return: 0 on success, -1 on failure. 387 */ 388 static int rsi_init_usb_interface(struct rsi_hw *adapter, 389 struct usb_interface *pfunction) 390 { 391 struct rsi_91x_usbdev *rsi_dev; 392 struct rsi_common *common = adapter->priv; 393 int status; 394 395 rsi_dev = kzalloc(sizeof(*rsi_dev), GFP_KERNEL); 396 if (!rsi_dev) 397 return -ENOMEM; 398 399 adapter->rsi_dev = rsi_dev; 400 rsi_dev->usbdev = interface_to_usbdev(pfunction); 401 402 if (rsi_find_bulk_in_and_out_endpoints(pfunction, adapter)) 403 return -EINVAL; 404 405 adapter->device = &pfunction->dev; 406 usb_set_intfdata(pfunction, adapter); 407 408 common->rx_data_pkt = kmalloc(2048, GFP_KERNEL); 409 if (!common->rx_data_pkt) { 410 rsi_dbg(ERR_ZONE, "%s: Failed to allocate memory\n", 411 __func__); 412 return -ENOMEM; 413 } 414 415 rsi_dev->tx_buffer = kmalloc(2048, GFP_ATOMIC); 416 rsi_dev->rx_usb_urb[0] = usb_alloc_urb(0, GFP_KERNEL); 417 rsi_dev->rx_usb_urb[0]->transfer_buffer = adapter->priv->rx_data_pkt; 418 rsi_dev->tx_blk_size = 252; 419 420 /* Initializing function callbacks */ 421 adapter->rx_urb_submit = rsi_rx_urb_submit; 422 adapter->host_intf_write_pkt = rsi_usb_host_intf_write_pkt; 423 adapter->check_hw_queue_status = rsi_usb_check_queue_status; 424 adapter->determine_event_timeout = rsi_usb_event_timeout; 425 426 rsi_init_event(&rsi_dev->rx_thread.event); 427 status = rsi_create_kthread(common, &rsi_dev->rx_thread, 428 rsi_usb_rx_thread, "RX-Thread"); 429 if (status) { 430 rsi_dbg(ERR_ZONE, "%s: Unable to init rx thrd\n", __func__); 431 goto fail; 432 } 433 434 #ifdef CONFIG_RSI_DEBUGFS 435 /* In USB, one less than the MAX_DEBUGFS_ENTRIES entries is required */ 436 adapter->num_debugfs_entries = (MAX_DEBUGFS_ENTRIES - 1); 437 #endif 438 439 rsi_dbg(INIT_ZONE, "%s: Enabled the interface\n", __func__); 440 return 0; 441 442 fail: 443 kfree(rsi_dev->tx_buffer); 444 kfree(common->rx_data_pkt); 445 return status; 446 } 447 448 /** 449 * rsi_probe() - This function is called by kernel when the driver provided 450 * Vendor and device IDs are matched. All the initialization 451 * work is done here. 452 * @pfunction: Pointer to the USB interface structure. 453 * @id: Pointer to the usb_device_id structure. 454 * 455 * Return: 0 on success, -1 on failure. 456 */ 457 static int rsi_probe(struct usb_interface *pfunction, 458 const struct usb_device_id *id) 459 { 460 struct rsi_hw *adapter; 461 struct rsi_91x_usbdev *dev; 462 u16 fw_status; 463 464 rsi_dbg(INIT_ZONE, "%s: Init function called\n", __func__); 465 466 adapter = rsi_91x_init(); 467 if (!adapter) { 468 rsi_dbg(ERR_ZONE, "%s: Failed to init os intf ops\n", 469 __func__); 470 return 1; 471 } 472 473 if (rsi_init_usb_interface(adapter, pfunction)) { 474 rsi_dbg(ERR_ZONE, "%s: Failed to init usb interface\n", 475 __func__); 476 goto err; 477 } 478 479 rsi_dbg(ERR_ZONE, "%s: Initialized os intf ops\n", __func__); 480 481 dev = (struct rsi_91x_usbdev *)adapter->rsi_dev; 482 483 if (rsi_usb_reg_read(dev->usbdev, FW_STATUS_REG, &fw_status, 2) < 0) 484 goto err1; 485 else 486 fw_status &= 1; 487 488 if (!fw_status) { 489 if (rsi_usb_device_init(adapter->priv)) { 490 rsi_dbg(ERR_ZONE, "%s: Failed in device init\n", 491 __func__); 492 goto err1; 493 } 494 495 if (rsi_usb_reg_write(dev->usbdev, 496 USB_INTERNAL_REG_1, 497 RSI_USB_READY_MAGIC_NUM, 1) < 0) 498 goto err1; 499 rsi_dbg(INIT_ZONE, "%s: Performed device init\n", __func__); 500 } 501 502 if (rsi_rx_urb_submit(adapter)) 503 goto err1; 504 505 return 0; 506 err1: 507 rsi_deinit_usb_interface(adapter); 508 err: 509 rsi_91x_deinit(adapter); 510 rsi_dbg(ERR_ZONE, "%s: Failed in probe...Exiting\n", __func__); 511 return 1; 512 } 513 514 /** 515 * rsi_disconnect() - This function performs the reverse of the probe function, 516 * it deintialize the driver structure. 517 * @pfunction: Pointer to the USB interface structure. 518 * 519 * Return: None. 520 */ 521 static void rsi_disconnect(struct usb_interface *pfunction) 522 { 523 struct rsi_hw *adapter = usb_get_intfdata(pfunction); 524 525 if (!adapter) 526 return; 527 528 rsi_mac80211_detach(adapter); 529 rsi_deinit_usb_interface(adapter); 530 rsi_91x_deinit(adapter); 531 532 rsi_dbg(INFO_ZONE, "%s: Deinitialization completed\n", __func__); 533 } 534 535 #ifdef CONFIG_PM 536 static int rsi_suspend(struct usb_interface *intf, pm_message_t message) 537 { 538 /* Not yet implemented */ 539 return -ENOSYS; 540 } 541 542 static int rsi_resume(struct usb_interface *intf) 543 { 544 /* Not yet implemented */ 545 return -ENOSYS; 546 } 547 #endif 548 549 static const struct usb_device_id rsi_dev_table[] = { 550 { USB_DEVICE(0x0303, 0x0100) }, 551 { USB_DEVICE(0x041B, 0x0301) }, 552 { USB_DEVICE(0x041B, 0x0201) }, 553 { USB_DEVICE(0x041B, 0x9330) }, 554 { /* Blank */}, 555 }; 556 557 static struct usb_driver rsi_driver = { 558 .name = "RSI-USB WLAN", 559 .probe = rsi_probe, 560 .disconnect = rsi_disconnect, 561 .id_table = rsi_dev_table, 562 #ifdef CONFIG_PM 563 .suspend = rsi_suspend, 564 .resume = rsi_resume, 565 #endif 566 }; 567 568 /** 569 * rsi_module_init() - This function registers the client driver. 570 * @void: Void. 571 * 572 * Return: 0 on success. 573 */ 574 static int rsi_module_init(void) 575 { 576 usb_register(&rsi_driver); 577 rsi_dbg(INIT_ZONE, "%s: Registering driver\n", __func__); 578 return 0; 579 } 580 581 /** 582 * rsi_module_exit() - This function unregisters the client driver. 583 * @void: Void. 584 * 585 * Return: None. 586 */ 587 static void rsi_module_exit(void) 588 { 589 usb_deregister(&rsi_driver); 590 rsi_dbg(INFO_ZONE, "%s: Unregistering driver\n", __func__); 591 } 592 593 module_init(rsi_module_init); 594 module_exit(rsi_module_exit); 595 596 MODULE_AUTHOR("Redpine Signals Inc"); 597 MODULE_DESCRIPTION("Common USB layer for RSI drivers"); 598 MODULE_SUPPORTED_DEVICE("RSI-91x"); 599 MODULE_DEVICE_TABLE(usb, rsi_dev_table); 600 MODULE_FIRMWARE(FIRMWARE_RSI9113); 601 MODULE_VERSION("0.1"); 602 MODULE_LICENSE("Dual BSD/GPL"); 603 604 605 606 607 608 /* LDV_COMMENT_BEGIN_MAIN */ 609 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 610 611 /*###########################################################################*/ 612 613 /*############## Driver Environment Generator 0.2 output ####################*/ 614 615 /*###########################################################################*/ 616 617 618 619 /* 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. */ 620 void ldv_check_final_state(void); 621 622 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 623 void ldv_check_return_value(int res); 624 625 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 626 void ldv_check_return_value_probe(int res); 627 628 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 629 void ldv_initialize(void); 630 631 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 632 void ldv_handler_precall(void); 633 634 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 635 int nondet_int(void); 636 637 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 638 int LDV_IN_INTERRUPT; 639 640 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 641 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 642 643 644 645 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 646 /*============================= VARIABLE DECLARATION PART =============================*/ 647 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/ 648 /* content: static int rsi_probe(struct usb_interface *pfunction, const struct usb_device_id *id)*/ 649 /* LDV_COMMENT_BEGIN_PREP */ 650 #ifdef CONFIG_RSI_DEBUGFS 651 #endif 652 /* LDV_COMMENT_END_PREP */ 653 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_probe" */ 654 struct usb_interface * var_group1; 655 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_probe" */ 656 const struct usb_device_id * var_rsi_probe_11_p1; 657 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "rsi_probe" */ 658 static int res_rsi_probe_11; 659 /* LDV_COMMENT_BEGIN_PREP */ 660 #ifdef CONFIG_PM 661 #endif 662 #ifdef CONFIG_PM 663 #endif 664 /* LDV_COMMENT_END_PREP */ 665 /* content: static void rsi_disconnect(struct usb_interface *pfunction)*/ 666 /* LDV_COMMENT_BEGIN_PREP */ 667 #ifdef CONFIG_RSI_DEBUGFS 668 #endif 669 /* LDV_COMMENT_END_PREP */ 670 /* LDV_COMMENT_BEGIN_PREP */ 671 #ifdef CONFIG_PM 672 #endif 673 #ifdef CONFIG_PM 674 #endif 675 /* LDV_COMMENT_END_PREP */ 676 /* content: static int rsi_suspend(struct usb_interface *intf, pm_message_t message)*/ 677 /* LDV_COMMENT_BEGIN_PREP */ 678 #ifdef CONFIG_RSI_DEBUGFS 679 #endif 680 #ifdef CONFIG_PM 681 /* LDV_COMMENT_END_PREP */ 682 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "rsi_suspend" */ 683 pm_message_t var_rsi_suspend_13_p1; 684 /* LDV_COMMENT_BEGIN_PREP */ 685 #endif 686 #ifdef CONFIG_PM 687 #endif 688 /* LDV_COMMENT_END_PREP */ 689 /* content: static int rsi_resume(struct usb_interface *intf)*/ 690 /* LDV_COMMENT_BEGIN_PREP */ 691 #ifdef CONFIG_RSI_DEBUGFS 692 #endif 693 #ifdef CONFIG_PM 694 /* LDV_COMMENT_END_PREP */ 695 /* LDV_COMMENT_BEGIN_PREP */ 696 #endif 697 #ifdef CONFIG_PM 698 #endif 699 /* LDV_COMMENT_END_PREP */ 700 701 702 703 704 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 705 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 706 /*============================= VARIABLE INITIALIZING PART =============================*/ 707 LDV_IN_INTERRUPT=1; 708 709 710 711 712 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 713 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 714 /*============================= FUNCTION CALL SECTION =============================*/ 715 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 716 ldv_initialize(); 717 718 /** INIT: init_type: ST_MODULE_INIT **/ 719 /* content: static int rsi_module_init(void)*/ 720 /* LDV_COMMENT_BEGIN_PREP */ 721 #ifdef CONFIG_RSI_DEBUGFS 722 #endif 723 #ifdef CONFIG_PM 724 #endif 725 #ifdef CONFIG_PM 726 #endif 727 /* LDV_COMMENT_END_PREP */ 728 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver init function after driver loading to kernel. This function declared as "MODULE_INIT(function name)". */ 729 ldv_handler_precall(); 730 if(rsi_module_init()) 731 goto ldv_final; 732 int ldv_s_rsi_driver_usb_driver = 0; 733 734 735 while( nondet_int() 736 || !(ldv_s_rsi_driver_usb_driver == 0) 737 ) { 738 739 switch(nondet_int()) { 740 741 case 0: { 742 743 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/ 744 if(ldv_s_rsi_driver_usb_driver==0) { 745 746 /* content: static int rsi_probe(struct usb_interface *pfunction, const struct usb_device_id *id)*/ 747 /* LDV_COMMENT_BEGIN_PREP */ 748 #ifdef CONFIG_RSI_DEBUGFS 749 #endif 750 /* LDV_COMMENT_END_PREP */ 751 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "rsi_driver". Standart function test for correct return result. */ 752 res_rsi_probe_11 = rsi_probe( var_group1, var_rsi_probe_11_p1); 753 ldv_check_return_value(res_rsi_probe_11); 754 ldv_check_return_value_probe(res_rsi_probe_11); 755 if(res_rsi_probe_11) 756 goto ldv_module_exit; 757 /* LDV_COMMENT_BEGIN_PREP */ 758 #ifdef CONFIG_PM 759 #endif 760 #ifdef CONFIG_PM 761 #endif 762 /* LDV_COMMENT_END_PREP */ 763 ldv_s_rsi_driver_usb_driver++; 764 765 } 766 767 } 768 769 break; 770 case 1: { 771 772 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/ 773 if(ldv_s_rsi_driver_usb_driver==1) { 774 775 /* content: static int rsi_suspend(struct usb_interface *intf, pm_message_t message)*/ 776 /* LDV_COMMENT_BEGIN_PREP */ 777 #ifdef CONFIG_RSI_DEBUGFS 778 #endif 779 #ifdef CONFIG_PM 780 /* LDV_COMMENT_END_PREP */ 781 /* LDV_COMMENT_FUNCTION_CALL Function from field "suspend" from driver structure with callbacks "rsi_driver" */ 782 ldv_handler_precall(); 783 rsi_suspend( var_group1, var_rsi_suspend_13_p1); 784 /* LDV_COMMENT_BEGIN_PREP */ 785 #endif 786 #ifdef CONFIG_PM 787 #endif 788 /* LDV_COMMENT_END_PREP */ 789 ldv_s_rsi_driver_usb_driver++; 790 791 } 792 793 } 794 795 break; 796 case 2: { 797 798 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/ 799 if(ldv_s_rsi_driver_usb_driver==2) { 800 801 /* content: static int rsi_resume(struct usb_interface *intf)*/ 802 /* LDV_COMMENT_BEGIN_PREP */ 803 #ifdef CONFIG_RSI_DEBUGFS 804 #endif 805 #ifdef CONFIG_PM 806 /* LDV_COMMENT_END_PREP */ 807 /* LDV_COMMENT_FUNCTION_CALL Function from field "resume" from driver structure with callbacks "rsi_driver" */ 808 ldv_handler_precall(); 809 rsi_resume( var_group1); 810 /* LDV_COMMENT_BEGIN_PREP */ 811 #endif 812 #ifdef CONFIG_PM 813 #endif 814 /* LDV_COMMENT_END_PREP */ 815 ldv_s_rsi_driver_usb_driver++; 816 817 } 818 819 } 820 821 break; 822 case 3: { 823 824 /** STRUCT: struct type: usb_driver, struct name: rsi_driver **/ 825 if(ldv_s_rsi_driver_usb_driver==3) { 826 827 /* content: static void rsi_disconnect(struct usb_interface *pfunction)*/ 828 /* LDV_COMMENT_BEGIN_PREP */ 829 #ifdef CONFIG_RSI_DEBUGFS 830 #endif 831 /* LDV_COMMENT_END_PREP */ 832 /* LDV_COMMENT_FUNCTION_CALL Function from field "disconnect" from driver structure with callbacks "rsi_driver" */ 833 ldv_handler_precall(); 834 rsi_disconnect( var_group1); 835 /* LDV_COMMENT_BEGIN_PREP */ 836 #ifdef CONFIG_PM 837 #endif 838 #ifdef CONFIG_PM 839 #endif 840 /* LDV_COMMENT_END_PREP */ 841 ldv_s_rsi_driver_usb_driver=0; 842 843 } 844 845 } 846 847 break; 848 default: break; 849 850 } 851 852 } 853 854 ldv_module_exit: 855 856 /** INIT: init_type: ST_MODULE_EXIT **/ 857 /* content: static void rsi_module_exit(void)*/ 858 /* LDV_COMMENT_BEGIN_PREP */ 859 #ifdef CONFIG_RSI_DEBUGFS 860 #endif 861 #ifdef CONFIG_PM 862 #endif 863 #ifdef CONFIG_PM 864 #endif 865 /* LDV_COMMENT_END_PREP */ 866 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver release function before driver will be uploaded from kernel. This function declared as "MODULE_EXIT(function name)". */ 867 ldv_handler_precall(); 868 rsi_module_exit(); 869 870 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 871 ldv_final: ldv_check_final_state(); 872 873 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 874 return; 875 876 } 877 #endif 878 879 /* LDV_COMMENT_END_MAIN */ 880 881 #line 14 "/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--134_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/7095/dscv_tempdir/dscv/ri/134_1a/drivers/net/wireless/rsi/rsi_91x_usb.o.c.prepared"
1 2 #include <linux/kernel.h> 3 #include <verifier/rcv.h> // For LDV auxiliary routines. 4 5 // There are 3 possible model states 6 enum 7 { 8 LDV_PROBE_ZERO_STATE = 0, // No error occured 9 LDV_PROBE_ERROR = 1, // Error occured. probe() should return error an code (or at least not zero) 10 }; 11 12 /* LDV_COMMENT_OTHER The model automaton state (one of thee possible ones). */ 13 int ldv_probe_state = LDV_PROBE_ZERO_STATE; 14 15 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_usb_register') Non-deterministically change state after call to usb_register. */ 16 int ldv_usb_register(void) 17 { 18 int nondet; 19 20 /* LDV_COMMENT_OTHER Nondeterministically report an error. */ 21 if (nondet < 0) { 22 /* LDV_COMMENT_CHANGE_STATE Error occured. */ 23 ldv_probe_state = LDV_PROBE_ERROR; 24 /* LDV_COMMENT_RETURN Return an error. */ 25 return nondet; 26 } else if (nondet >= 0) { 27 /* LDV_COMMENT_RETURN Assume no error occured. */ 28 return 0; 29 } 30 } 31 32 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='register_netdev') Non-deterministically change state after call to register_netdev. */ 33 int ldv_register_netdev(void) 34 { 35 int nondet; 36 37 /* LDV_COMMENT_OTHER Nondeterministically report an error. */ 38 if (nondet < 0) { 39 /* LDV_COMMENT_CHANGE_STATE Error occured. */ 40 ldv_probe_state = LDV_PROBE_ERROR; 41 /* LDV_COMMENT_RETURN Return an error. */ 42 return nondet; 43 } else if (nondet >= 0) { 44 /* LDV_COMMENT_RETURN Assume no error occured. */ 45 return 0; 46 } 47 } 48 49 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_check_return_value_probe') Check the error code was properly propagated in probe . */ 50 void ldv_check_return_value_probe(int retval) 51 { 52 if (ldv_probe_state == LDV_PROBE_ERROR) 53 ldv_assert(retval != 0); 54 }
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 /* 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 134_1a BLAST Bug Fixed 2015-03-13 15:13:34 L0156

Comment

L0156 https://lkml.org/lkml/2014/6/6/697

[Home]