Error Trace

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 */