Bug

1 2 /* 3 * Fushicai USBTV007 Video Grabber Driver 4 * 5 * Product web site: 6 * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html 7 * 8 * Following LWN articles were very useful in construction of this driver: 9 * Video4Linux2 API series: http://lwn.net/Articles/203924/ 10 * videobuf2 API explanation: http://lwn.net/Articles/447435/ 11 * Thanks go to Jonathan Corbet for providing this quality documentation. 12 * He is awesome. 13 * 14 * Copyright (c) 2013 Lubomir Rintel 15 * All rights reserved. 16 * No physical hardware was harmed running Windows during the 17 * reverse-engineering activity 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions, and the following disclaimer, 24 * without modification. 25 * 2. The name of the author may not be used to endorse or promote products 26 * derived from this software without specific prior written permission. 27 * 28 * Alternatively, this software may be distributed under the terms of the 29 * GNU General Public License ("GPL"). 30 */ 31 32 #include "usbtv.h" 33 34 int usbtv_set_regs(struct usbtv *usbtv, const u16 regs[][2], int size) 35 { 36 int ret; 37 int pipe = usb_rcvctrlpipe(usbtv->udev, 0); 38 int i; 39 40 for (i = 0; i < size; i++) { 41 u16 index = regs[i][0]; 42 u16 value = regs[i][1]; 43 44 ret = usb_control_msg(usbtv->udev, pipe, USBTV_REQUEST_REG, 45 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 46 value, index, NULL, 0, 0); 47 if (ret < 0) 48 return ret; 49 } 50 51 return 0; 52 } 53 54 static int usbtv_probe(struct usb_interface *intf, 55 const struct usb_device_id *id) 56 { 57 int ret; 58 int size; 59 struct device *dev = &intf->dev; 60 struct usbtv *usbtv; 61 62 /* Checks that the device is what we think it is. */ 63 if (intf->num_altsetting != 2) 64 return -ENODEV; 65 if (intf->altsetting[1].desc.bNumEndpoints != 4) 66 return -ENODEV; 67 68 /* Packet size is split into 11 bits of base size and count of 69 * extra multiplies of it.*/ 70 size = usb_endpoint_maxp(&intf->altsetting[1].endpoint[0].desc); 71 size = (size & 0x07ff) * (((size & 0x1800) >> 11) + 1); 72 73 /* Device structure */ 74 usbtv = kzalloc(sizeof(struct usbtv), GFP_KERNEL); 75 if (usbtv == NULL) 76 return -ENOMEM; 77 usbtv->dev = dev; 78 usbtv->udev = usb_get_dev(interface_to_usbdev(intf)); 79 80 usbtv->iso_size = size; 81 82 usb_set_intfdata(intf, usbtv); 83 84 ret = usbtv_video_init(usbtv); 85 if (ret < 0) 86 goto usbtv_video_fail; 87 88 /* for simplicity we exploit the v4l2_device reference counting */ 89 v4l2_device_get(&usbtv->v4l2_dev); 90 91 dev_info(dev, "Fushicai USBTV007 Video Grabber\n"); 92 return 0; 93 94 usbtv_video_fail: 95 kfree(usbtv); 96 97 return ret; 98 } 99 100 static void usbtv_disconnect(struct usb_interface *intf) 101 { 102 struct usbtv *usbtv = usb_get_intfdata(intf); 103 usb_set_intfdata(intf, NULL); 104 105 if (!usbtv) 106 return; 107 108 usbtv_video_free(usbtv); 109 110 usb_put_dev(usbtv->udev); 111 usbtv->udev = NULL; 112 113 /* the usbtv structure will be deallocated when v4l2 will be 114 done using it */ 115 v4l2_device_put(&usbtv->v4l2_dev); 116 } 117 118 static struct usb_device_id usbtv_id_table[] = { 119 { USB_DEVICE(0x1b71, 0x3002) }, 120 {} 121 }; 122 MODULE_DEVICE_TABLE(usb, usbtv_id_table); 123 124 MODULE_AUTHOR("Lubomir Rintel"); 125 MODULE_DESCRIPTION("Fushicai USBTV007 Video Grabber Driver"); 126 MODULE_LICENSE("Dual BSD/GPL"); 127 128 static struct usb_driver usbtv_usb_driver = { 129 .name = "usbtv", 130 .id_table = usbtv_id_table, 131 .probe = usbtv_probe, 132 .disconnect = usbtv_disconnect, 133 }; 134 135 module_usb_driver(usbtv_usb_driver); 136 137 138 139 140 141 /* LDV_COMMENT_BEGIN_MAIN */ 142 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 143 144 /*###########################################################################*/ 145 146 /*############## Driver Environment Generator 0.2 output ####################*/ 147 148 /*###########################################################################*/ 149 150 151 152 /* 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. */ 153 void ldv_check_final_state(void); 154 155 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 156 void ldv_check_return_value(int res); 157 158 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 159 void ldv_check_return_value_probe(int res); 160 161 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 162 void ldv_initialize(void); 163 164 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 165 void ldv_handler_precall(void); 166 167 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 168 int nondet_int(void); 169 170 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 171 int LDV_IN_INTERRUPT; 172 173 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 174 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 175 176 177 178 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 179 /*============================= VARIABLE DECLARATION PART =============================*/ 180 /** STRUCT: struct type: usb_driver, struct name: usbtv_usb_driver **/ 181 /* content: static int usbtv_probe(struct usb_interface *intf, const struct usb_device_id *id)*/ 182 /* LDV_COMMENT_END_PREP */ 183 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_probe" */ 184 struct usb_interface * var_group1; 185 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_probe" */ 186 const struct usb_device_id * var_usbtv_probe_0_p1; 187 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "usbtv_probe" */ 188 static int res_usbtv_probe_0; 189 /* content: static void usbtv_disconnect(struct usb_interface *intf)*/ 190 /* LDV_COMMENT_END_PREP */ 191 192 193 194 195 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 196 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 197 /*============================= VARIABLE INITIALIZING PART =============================*/ 198 LDV_IN_INTERRUPT=1; 199 200 201 202 203 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 204 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 205 /*============================= FUNCTION CALL SECTION =============================*/ 206 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 207 ldv_initialize(); 208 int ldv_s_usbtv_usb_driver_usb_driver = 0; 209 210 211 while( nondet_int() 212 || !(ldv_s_usbtv_usb_driver_usb_driver == 0) 213 ) { 214 215 switch(nondet_int()) { 216 217 case 0: { 218 219 /** STRUCT: struct type: usb_driver, struct name: usbtv_usb_driver **/ 220 if(ldv_s_usbtv_usb_driver_usb_driver==0) { 221 222 /* content: static int usbtv_probe(struct usb_interface *intf, const struct usb_device_id *id)*/ 223 /* LDV_COMMENT_END_PREP */ 224 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "usbtv_usb_driver". Standart function test for correct return result. */ 225 res_usbtv_probe_0 = usbtv_probe( var_group1, var_usbtv_probe_0_p1); 226 ldv_check_return_value(res_usbtv_probe_0); 227 ldv_check_return_value_probe(res_usbtv_probe_0); 228 if(res_usbtv_probe_0) 229 goto ldv_module_exit; 230 ldv_s_usbtv_usb_driver_usb_driver++; 231 232 } 233 234 } 235 236 break; 237 case 1: { 238 239 /** STRUCT: struct type: usb_driver, struct name: usbtv_usb_driver **/ 240 if(ldv_s_usbtv_usb_driver_usb_driver==1) { 241 242 /* content: static void usbtv_disconnect(struct usb_interface *intf)*/ 243 /* LDV_COMMENT_END_PREP */ 244 /* LDV_COMMENT_FUNCTION_CALL Function from field "disconnect" from driver structure with callbacks "usbtv_usb_driver" */ 245 ldv_handler_precall(); 246 usbtv_disconnect( var_group1); 247 ldv_s_usbtv_usb_driver_usb_driver=0; 248 249 } 250 251 } 252 253 break; 254 default: break; 255 256 } 257 258 } 259 260 ldv_module_exit: 261 262 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 263 ldv_final: ldv_check_final_state(); 264 265 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 266 return; 267 268 } 269 #endif 270 271 /* 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 #include <linux/usb.h> 12 13 // Provide model function prototypes before their usage. 14 void ldv_interface_to_usbdev(void); 15 void ldv_usb_get_dev(void); 16 void ldv_usb_put_dev(void); 17 #line 1 "/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--132_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8832/dscv_tempdir/dscv/ri/132_1a/drivers/media/usb/usbtv/usbtv-core.c" 18 19 /* 20 * Fushicai USBTV007 Video Grabber Driver 21 * 22 * Product web site: 23 * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html 24 * 25 * Following LWN articles were very useful in construction of this driver: 26 * Video4Linux2 API series: http://lwn.net/Articles/203924/ 27 * videobuf2 API explanation: http://lwn.net/Articles/447435/ 28 * Thanks go to Jonathan Corbet for providing this quality documentation. 29 * He is awesome. 30 * 31 * Copyright (c) 2013 Lubomir Rintel 32 * All rights reserved. 33 * No physical hardware was harmed running Windows during the 34 * reverse-engineering activity 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions, and the following disclaimer, 41 * without modification. 42 * 2. The name of the author may not be used to endorse or promote products 43 * derived from this software without specific prior written permission. 44 * 45 * Alternatively, this software may be distributed under the terms of the 46 * GNU General Public License ("GPL"). 47 */ 48 49 #include "usbtv.h" 50 51 int usbtv_set_regs(struct usbtv *usbtv, const u16 regs[][2], int size) 52 { 53 int ret; 54 int pipe = usb_rcvctrlpipe(usbtv->udev, 0); 55 int i; 56 57 for (i = 0; i < size; i++) { 58 u16 index = regs[i][0]; 59 u16 value = regs[i][1]; 60 61 ret = usb_control_msg(usbtv->udev, pipe, USBTV_REQUEST_REG, 62 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 63 value, index, NULL, 0, 0); 64 if (ret < 0) 65 return ret; 66 } 67 68 return 0; 69 } 70 71 static int usbtv_probe(struct usb_interface *intf, 72 const struct usb_device_id *id) 73 { 74 int ret; 75 int size; 76 struct device *dev = &intf->dev; 77 struct usbtv *usbtv; 78 79 /* Checks that the device is what we think it is. */ 80 if (intf->num_altsetting != 2) 81 return -ENODEV; 82 if (intf->altsetting[1].desc.bNumEndpoints != 4) 83 return -ENODEV; 84 85 /* Packet size is split into 11 bits of base size and count of 86 * extra multiplies of it.*/ 87 size = usb_endpoint_maxp(&intf->altsetting[1].endpoint[0].desc); 88 size = (size & 0x07ff) * (((size & 0x1800) >> 11) + 1); 89 90 /* Device structure */ 91 usbtv = kzalloc(sizeof(struct usbtv), GFP_KERNEL); 92 if (usbtv == NULL) 93 return -ENOMEM; 94 usbtv->dev = dev; 95 usbtv->udev = usb_get_dev(interface_to_usbdev(intf)); 96 97 usbtv->iso_size = size; 98 99 usb_set_intfdata(intf, usbtv); 100 101 ret = usbtv_video_init(usbtv); 102 if (ret < 0) 103 goto usbtv_video_fail; 104 105 /* for simplicity we exploit the v4l2_device reference counting */ 106 v4l2_device_get(&usbtv->v4l2_dev); 107 108 dev_info(dev, "Fushicai USBTV007 Video Grabber\n"); 109 return 0; 110 111 usbtv_video_fail: 112 kfree(usbtv); 113 114 return ret; 115 } 116 117 static void usbtv_disconnect(struct usb_interface *intf) 118 { 119 struct usbtv *usbtv = usb_get_intfdata(intf); 120 usb_set_intfdata(intf, NULL); 121 122 if (!usbtv) 123 return; 124 125 usbtv_video_free(usbtv); 126 127 usb_put_dev(usbtv->udev); 128 usbtv->udev = NULL; 129 130 /* the usbtv structure will be deallocated when v4l2 will be 131 done using it */ 132 v4l2_device_put(&usbtv->v4l2_dev); 133 } 134 135 static struct usb_device_id usbtv_id_table[] = { 136 { USB_DEVICE(0x1b71, 0x3002) }, 137 {} 138 }; 139 MODULE_DEVICE_TABLE(usb, usbtv_id_table); 140 141 MODULE_AUTHOR("Lubomir Rintel"); 142 MODULE_DESCRIPTION("Fushicai USBTV007 Video Grabber Driver"); 143 MODULE_LICENSE("Dual BSD/GPL"); 144 145 static struct usb_driver usbtv_usb_driver = { 146 .name = "usbtv", 147 .id_table = usbtv_id_table, 148 .probe = usbtv_probe, 149 .disconnect = usbtv_disconnect, 150 }; 151 152 module_usb_driver(usbtv_usb_driver); 153 154 155 156 157 158 /* LDV_COMMENT_BEGIN_MAIN */ 159 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 160 161 /*###########################################################################*/ 162 163 /*############## Driver Environment Generator 0.2 output ####################*/ 164 165 /*###########################################################################*/ 166 167 168 169 /* 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. */ 170 void ldv_check_final_state(void); 171 172 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 173 void ldv_check_return_value(int res); 174 175 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 176 void ldv_check_return_value_probe(int res); 177 178 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 179 void ldv_initialize(void); 180 181 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 182 void ldv_handler_precall(void); 183 184 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 185 int nondet_int(void); 186 187 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 188 int LDV_IN_INTERRUPT; 189 190 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 191 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 192 193 194 195 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 196 /*============================= VARIABLE DECLARATION PART =============================*/ 197 /** STRUCT: struct type: usb_driver, struct name: usbtv_usb_driver **/ 198 /* content: static int usbtv_probe(struct usb_interface *intf, const struct usb_device_id *id)*/ 199 /* LDV_COMMENT_END_PREP */ 200 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_probe" */ 201 struct usb_interface * var_group1; 202 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_probe" */ 203 const struct usb_device_id * var_usbtv_probe_0_p1; 204 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "usbtv_probe" */ 205 static int res_usbtv_probe_0; 206 /* content: static void usbtv_disconnect(struct usb_interface *intf)*/ 207 /* LDV_COMMENT_END_PREP */ 208 209 210 211 212 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 213 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 214 /*============================= VARIABLE INITIALIZING PART =============================*/ 215 LDV_IN_INTERRUPT=1; 216 217 218 219 220 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 221 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 222 /*============================= FUNCTION CALL SECTION =============================*/ 223 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 224 ldv_initialize(); 225 int ldv_s_usbtv_usb_driver_usb_driver = 0; 226 227 228 while( nondet_int() 229 || !(ldv_s_usbtv_usb_driver_usb_driver == 0) 230 ) { 231 232 switch(nondet_int()) { 233 234 case 0: { 235 236 /** STRUCT: struct type: usb_driver, struct name: usbtv_usb_driver **/ 237 if(ldv_s_usbtv_usb_driver_usb_driver==0) { 238 239 /* content: static int usbtv_probe(struct usb_interface *intf, const struct usb_device_id *id)*/ 240 /* LDV_COMMENT_END_PREP */ 241 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "usbtv_usb_driver". Standart function test for correct return result. */ 242 res_usbtv_probe_0 = usbtv_probe( var_group1, var_usbtv_probe_0_p1); 243 ldv_check_return_value(res_usbtv_probe_0); 244 ldv_check_return_value_probe(res_usbtv_probe_0); 245 if(res_usbtv_probe_0) 246 goto ldv_module_exit; 247 ldv_s_usbtv_usb_driver_usb_driver++; 248 249 } 250 251 } 252 253 break; 254 case 1: { 255 256 /** STRUCT: struct type: usb_driver, struct name: usbtv_usb_driver **/ 257 if(ldv_s_usbtv_usb_driver_usb_driver==1) { 258 259 /* content: static void usbtv_disconnect(struct usb_interface *intf)*/ 260 /* LDV_COMMENT_END_PREP */ 261 /* LDV_COMMENT_FUNCTION_CALL Function from field "disconnect" from driver structure with callbacks "usbtv_usb_driver" */ 262 ldv_handler_precall(); 263 usbtv_disconnect( var_group1); 264 ldv_s_usbtv_usb_driver_usb_driver=0; 265 266 } 267 268 } 269 270 break; 271 default: break; 272 273 } 274 275 } 276 277 ldv_module_exit: 278 279 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 280 ldv_final: ldv_check_final_state(); 281 282 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 283 return; 284 285 } 286 #endif 287 288 /* LDV_COMMENT_END_MAIN */ 289 290 #line 17 "/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-3.16-rc1.tar.xz--X--132_1a/linux-3.16-rc1.tar.xz/csd_deg_dscv/8832/dscv_tempdir/dscv/ri/132_1a/drivers/media/usb/usbtv/usbtv-core.o.c.prepared"

1 2 /* 3 * Fushicai USBTV007 Video Grabber Driver 4 * 5 * Product web site: 6 * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html 7 * 8 * Following LWN articles were very useful in construction of this driver: 9 * Video4Linux2 API series: http://lwn.net/Articles/203924/ 10 * videobuf2 API explanation: http://lwn.net/Articles/447435/ 11 * Thanks go to Jonathan Corbet for providing this quality documentation. 12 * He is awesome. 13 * 14 * Copyright (c) 2013 Lubomir Rintel 15 * All rights reserved. 16 * No physical hardware was harmed running Windows during the 17 * reverse-engineering activity 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions, and the following disclaimer, 24 * without modification. 25 * 2. The name of the author may not be used to endorse or promote products 26 * derived from this software without specific prior written permission. 27 * 28 * Alternatively, this software may be distributed under the terms of the 29 * GNU General Public License ("GPL"). 30 */ 31 32 #include <media/v4l2-ioctl.h> 33 #include <media/videobuf2-core.h> 34 35 #include "usbtv.h" 36 37 static struct usbtv_norm_params norm_params[] = { 38 { 39 .norm = V4L2_STD_525_60, 40 .cap_width = 720, 41 .cap_height = 480, 42 }, 43 { 44 .norm = V4L2_STD_PAL, 45 .cap_width = 720, 46 .cap_height = 576, 47 } 48 }; 49 50 static int usbtv_configure_for_norm(struct usbtv *usbtv, v4l2_std_id norm) 51 { 52 int i, ret = 0; 53 struct usbtv_norm_params *params = NULL; 54 55 for (i = 0; i < ARRAY_SIZE(norm_params); i++) { 56 if (norm_params[i].norm & norm) { 57 params = &norm_params[i]; 58 break; 59 } 60 } 61 62 if (params) { 63 usbtv->width = params->cap_width; 64 usbtv->height = params->cap_height; 65 usbtv->n_chunks = usbtv->width * usbtv->height 66 / 4 / USBTV_CHUNK; 67 usbtv->norm = params->norm; 68 } else 69 ret = -EINVAL; 70 71 return ret; 72 } 73 74 static int usbtv_select_input(struct usbtv *usbtv, int input) 75 { 76 int ret; 77 78 static const u16 composite[][2] = { 79 { USBTV_BASE + 0x0105, 0x0060 }, 80 { USBTV_BASE + 0x011f, 0x00f2 }, 81 { USBTV_BASE + 0x0127, 0x0060 }, 82 { USBTV_BASE + 0x00ae, 0x0010 }, 83 { USBTV_BASE + 0x0284, 0x00aa }, 84 { USBTV_BASE + 0x0239, 0x0060 }, 85 }; 86 87 static const u16 svideo[][2] = { 88 { USBTV_BASE + 0x0105, 0x0010 }, 89 { USBTV_BASE + 0x011f, 0x00ff }, 90 { USBTV_BASE + 0x0127, 0x0060 }, 91 { USBTV_BASE + 0x00ae, 0x0030 }, 92 { USBTV_BASE + 0x0284, 0x0088 }, 93 { USBTV_BASE + 0x0239, 0x0060 }, 94 }; 95 96 switch (input) { 97 case USBTV_COMPOSITE_INPUT: 98 ret = usbtv_set_regs(usbtv, composite, ARRAY_SIZE(composite)); 99 break; 100 case USBTV_SVIDEO_INPUT: 101 ret = usbtv_set_regs(usbtv, svideo, ARRAY_SIZE(svideo)); 102 break; 103 default: 104 ret = -EINVAL; 105 } 106 107 if (!ret) 108 usbtv->input = input; 109 110 return ret; 111 } 112 113 static int usbtv_select_norm(struct usbtv *usbtv, v4l2_std_id norm) 114 { 115 int ret; 116 static const u16 pal[][2] = { 117 { USBTV_BASE + 0x001a, 0x0068 }, 118 { USBTV_BASE + 0x010e, 0x0072 }, 119 { USBTV_BASE + 0x010f, 0x00a2 }, 120 { USBTV_BASE + 0x0112, 0x00b0 }, 121 { USBTV_BASE + 0x0117, 0x0001 }, 122 { USBTV_BASE + 0x0118, 0x002c }, 123 { USBTV_BASE + 0x012d, 0x0010 }, 124 { USBTV_BASE + 0x012f, 0x0020 }, 125 { USBTV_BASE + 0x024f, 0x0002 }, 126 { USBTV_BASE + 0x0254, 0x0059 }, 127 { USBTV_BASE + 0x025a, 0x0016 }, 128 { USBTV_BASE + 0x025b, 0x0035 }, 129 { USBTV_BASE + 0x0263, 0x0017 }, 130 { USBTV_BASE + 0x0266, 0x0016 }, 131 { USBTV_BASE + 0x0267, 0x0036 } 132 }; 133 134 static const u16 ntsc[][2] = { 135 { USBTV_BASE + 0x001a, 0x0079 }, 136 { USBTV_BASE + 0x010e, 0x0068 }, 137 { USBTV_BASE + 0x010f, 0x009c }, 138 { USBTV_BASE + 0x0112, 0x00f0 }, 139 { USBTV_BASE + 0x0117, 0x0000 }, 140 { USBTV_BASE + 0x0118, 0x00fc }, 141 { USBTV_BASE + 0x012d, 0x0004 }, 142 { USBTV_BASE + 0x012f, 0x0008 }, 143 { USBTV_BASE + 0x024f, 0x0001 }, 144 { USBTV_BASE + 0x0254, 0x005f }, 145 { USBTV_BASE + 0x025a, 0x0012 }, 146 { USBTV_BASE + 0x025b, 0x0001 }, 147 { USBTV_BASE + 0x0263, 0x001c }, 148 { USBTV_BASE + 0x0266, 0x0011 }, 149 { USBTV_BASE + 0x0267, 0x0005 } 150 }; 151 152 ret = usbtv_configure_for_norm(usbtv, norm); 153 154 if (!ret) { 155 if (norm & V4L2_STD_525_60) 156 ret = usbtv_set_regs(usbtv, ntsc, ARRAY_SIZE(ntsc)); 157 else if (norm & V4L2_STD_PAL) 158 ret = usbtv_set_regs(usbtv, pal, ARRAY_SIZE(pal)); 159 } 160 161 return ret; 162 } 163 164 static int usbtv_setup_capture(struct usbtv *usbtv) 165 { 166 int ret; 167 static const u16 setup[][2] = { 168 /* These seem to enable the device. */ 169 { USBTV_BASE + 0x0008, 0x0001 }, 170 { USBTV_BASE + 0x01d0, 0x00ff }, 171 { USBTV_BASE + 0x01d9, 0x0002 }, 172 173 /* These seem to influence color parameters, such as 174 * brightness, etc. */ 175 { USBTV_BASE + 0x0239, 0x0040 }, 176 { USBTV_BASE + 0x0240, 0x0000 }, 177 { USBTV_BASE + 0x0241, 0x0000 }, 178 { USBTV_BASE + 0x0242, 0x0002 }, 179 { USBTV_BASE + 0x0243, 0x0080 }, 180 { USBTV_BASE + 0x0244, 0x0012 }, 181 { USBTV_BASE + 0x0245, 0x0090 }, 182 { USBTV_BASE + 0x0246, 0x0000 }, 183 184 { USBTV_BASE + 0x0278, 0x002d }, 185 { USBTV_BASE + 0x0279, 0x000a }, 186 { USBTV_BASE + 0x027a, 0x0032 }, 187 { 0xf890, 0x000c }, 188 { 0xf894, 0x0086 }, 189 190 { USBTV_BASE + 0x00ac, 0x00c0 }, 191 { USBTV_BASE + 0x00ad, 0x0000 }, 192 { USBTV_BASE + 0x00a2, 0x0012 }, 193 { USBTV_BASE + 0x00a3, 0x00e0 }, 194 { USBTV_BASE + 0x00a4, 0x0028 }, 195 { USBTV_BASE + 0x00a5, 0x0082 }, 196 { USBTV_BASE + 0x00a7, 0x0080 }, 197 { USBTV_BASE + 0x0000, 0x0014 }, 198 { USBTV_BASE + 0x0006, 0x0003 }, 199 { USBTV_BASE + 0x0090, 0x0099 }, 200 { USBTV_BASE + 0x0091, 0x0090 }, 201 { USBTV_BASE + 0x0094, 0x0068 }, 202 { USBTV_BASE + 0x0095, 0x0070 }, 203 { USBTV_BASE + 0x009c, 0x0030 }, 204 { USBTV_BASE + 0x009d, 0x00c0 }, 205 { USBTV_BASE + 0x009e, 0x00e0 }, 206 { USBTV_BASE + 0x0019, 0x0006 }, 207 { USBTV_BASE + 0x008c, 0x00ba }, 208 { USBTV_BASE + 0x0101, 0x00ff }, 209 { USBTV_BASE + 0x010c, 0x00b3 }, 210 { USBTV_BASE + 0x01b2, 0x0080 }, 211 { USBTV_BASE + 0x01b4, 0x00a0 }, 212 { USBTV_BASE + 0x014c, 0x00ff }, 213 { USBTV_BASE + 0x014d, 0x00ca }, 214 { USBTV_BASE + 0x0113, 0x0053 }, 215 { USBTV_BASE + 0x0119, 0x008a }, 216 { USBTV_BASE + 0x013c, 0x0003 }, 217 { USBTV_BASE + 0x0150, 0x009c }, 218 { USBTV_BASE + 0x0151, 0x0071 }, 219 { USBTV_BASE + 0x0152, 0x00c6 }, 220 { USBTV_BASE + 0x0153, 0x0084 }, 221 { USBTV_BASE + 0x0154, 0x00bc }, 222 { USBTV_BASE + 0x0155, 0x00a0 }, 223 { USBTV_BASE + 0x0156, 0x00a0 }, 224 { USBTV_BASE + 0x0157, 0x009c }, 225 { USBTV_BASE + 0x0158, 0x001f }, 226 { USBTV_BASE + 0x0159, 0x0006 }, 227 { USBTV_BASE + 0x015d, 0x0000 }, 228 229 { USBTV_BASE + 0x0284, 0x0088 }, 230 { USBTV_BASE + 0x0003, 0x0004 }, 231 { USBTV_BASE + 0x0100, 0x00d3 }, 232 { USBTV_BASE + 0x0115, 0x0015 }, 233 { USBTV_BASE + 0x0220, 0x002e }, 234 { USBTV_BASE + 0x0225, 0x0008 }, 235 { USBTV_BASE + 0x024e, 0x0002 }, 236 { USBTV_BASE + 0x024e, 0x0002 }, 237 { USBTV_BASE + 0x024f, 0x0002 }, 238 }; 239 240 ret = usbtv_set_regs(usbtv, setup, ARRAY_SIZE(setup)); 241 if (ret) 242 return ret; 243 244 ret = usbtv_select_norm(usbtv, usbtv->norm); 245 if (ret) 246 return ret; 247 248 ret = usbtv_select_input(usbtv, usbtv->input); 249 if (ret) 250 return ret; 251 252 return 0; 253 } 254 255 /* Copy data from chunk into a frame buffer, deinterlacing the data 256 * into every second line. Unfortunately, they don't align nicely into 257 * 720 pixel lines, as the chunk is 240 words long, which is 480 pixels. 258 * Therefore, we break down the chunk into two halves before copyting, 259 * so that we can interleave a line if needed. */ 260 static void usbtv_chunk_to_vbuf(u32 *frame, u32 *src, int chunk_no, int odd) 261 { 262 int half; 263 264 for (half = 0; half < 2; half++) { 265 int part_no = chunk_no * 2 + half; 266 int line = part_no / 3; 267 int part_index = (line * 2 + !odd) * 3 + (part_no % 3); 268 269 u32 *dst = &frame[part_index * USBTV_CHUNK/2]; 270 memcpy(dst, src, USBTV_CHUNK/2 * sizeof(*src)); 271 src += USBTV_CHUNK/2; 272 } 273 } 274 275 /* Called for each 256-byte image chunk. 276 * First word identifies the chunk, followed by 240 words of image 277 * data and padding. */ 278 static void usbtv_image_chunk(struct usbtv *usbtv, u32 *chunk) 279 { 280 int frame_id, odd, chunk_no; 281 u32 *frame; 282 struct usbtv_buf *buf; 283 unsigned long flags; 284 285 /* Ignore corrupted lines. */ 286 if (!USBTV_MAGIC_OK(chunk)) 287 return; 288 frame_id = USBTV_FRAME_ID(chunk); 289 odd = USBTV_ODD(chunk); 290 chunk_no = USBTV_CHUNK_NO(chunk); 291 if (chunk_no >= usbtv->n_chunks) 292 return; 293 294 /* Beginning of a frame. */ 295 if (chunk_no == 0) { 296 usbtv->frame_id = frame_id; 297 usbtv->chunks_done = 0; 298 } 299 300 if (usbtv->frame_id != frame_id) 301 return; 302 303 spin_lock_irqsave(&usbtv->buflock, flags); 304 if (list_empty(&usbtv->bufs)) { 305 /* No free buffers. Userspace likely too slow. */ 306 spin_unlock_irqrestore(&usbtv->buflock, flags); 307 return; 308 } 309 310 /* First available buffer. */ 311 buf = list_first_entry(&usbtv->bufs, struct usbtv_buf, list); 312 frame = vb2_plane_vaddr(&buf->vb, 0); 313 314 /* Copy the chunk data. */ 315 usbtv_chunk_to_vbuf(frame, &chunk[1], chunk_no, odd); 316 usbtv->chunks_done++; 317 318 /* Last chunk in a frame, signalling an end */ 319 if (odd && chunk_no == usbtv->n_chunks-1) { 320 int size = vb2_plane_size(&buf->vb, 0); 321 enum vb2_buffer_state state = usbtv->chunks_done == 322 usbtv->n_chunks ? 323 VB2_BUF_STATE_DONE : 324 VB2_BUF_STATE_ERROR; 325 326 buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED; 327 buf->vb.v4l2_buf.sequence = usbtv->sequence++; 328 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp); 329 vb2_set_plane_payload(&buf->vb, 0, size); 330 vb2_buffer_done(&buf->vb, state); 331 list_del(&buf->list); 332 } 333 334 spin_unlock_irqrestore(&usbtv->buflock, flags); 335 } 336 337 /* Got image data. Each packet contains a number of 256-word chunks we 338 * compose the image from. */ 339 static void usbtv_iso_cb(struct urb *ip) 340 { 341 int ret; 342 int i; 343 struct usbtv *usbtv = (struct usbtv *)ip->context; 344 345 switch (ip->status) { 346 /* All fine. */ 347 case 0: 348 break; 349 /* Device disconnected or capture stopped? */ 350 case -ENODEV: 351 case -ENOENT: 352 case -ECONNRESET: 353 case -ESHUTDOWN: 354 return; 355 /* Unknown error. Retry. */ 356 default: 357 dev_warn(usbtv->dev, "Bad response for ISO request.\n"); 358 goto resubmit; 359 } 360 361 for (i = 0; i < ip->number_of_packets; i++) { 362 int size = ip->iso_frame_desc[i].actual_length; 363 unsigned char *data = ip->transfer_buffer + 364 ip->iso_frame_desc[i].offset; 365 int offset; 366 367 for (offset = 0; USBTV_CHUNK_SIZE * offset < size; offset++) 368 usbtv_image_chunk(usbtv, 369 (u32 *)&data[USBTV_CHUNK_SIZE * offset]); 370 } 371 372 resubmit: 373 ret = usb_submit_urb(ip, GFP_ATOMIC); 374 if (ret < 0) 375 dev_warn(usbtv->dev, "Could not resubmit ISO URB\n"); 376 } 377 378 static struct urb *usbtv_setup_iso_transfer(struct usbtv *usbtv) 379 { 380 struct urb *ip; 381 int size = usbtv->iso_size; 382 int i; 383 384 ip = usb_alloc_urb(USBTV_ISOC_PACKETS, GFP_KERNEL); 385 if (ip == NULL) 386 return NULL; 387 388 ip->dev = usbtv->udev; 389 ip->context = usbtv; 390 ip->pipe = usb_rcvisocpipe(usbtv->udev, USBTV_VIDEO_ENDP); 391 ip->interval = 1; 392 ip->transfer_flags = URB_ISO_ASAP; 393 ip->transfer_buffer = kzalloc(size * USBTV_ISOC_PACKETS, 394 GFP_KERNEL); 395 ip->complete = usbtv_iso_cb; 396 ip->number_of_packets = USBTV_ISOC_PACKETS; 397 ip->transfer_buffer_length = size * USBTV_ISOC_PACKETS; 398 for (i = 0; i < USBTV_ISOC_PACKETS; i++) { 399 ip->iso_frame_desc[i].offset = size * i; 400 ip->iso_frame_desc[i].length = size; 401 } 402 403 return ip; 404 } 405 406 static void usbtv_stop(struct usbtv *usbtv) 407 { 408 int i; 409 unsigned long flags; 410 411 /* Cancel running transfers. */ 412 for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) { 413 struct urb *ip = usbtv->isoc_urbs[i]; 414 if (ip == NULL) 415 continue; 416 usb_kill_urb(ip); 417 kfree(ip->transfer_buffer); 418 usb_free_urb(ip); 419 usbtv->isoc_urbs[i] = NULL; 420 } 421 422 /* Return buffers to userspace. */ 423 spin_lock_irqsave(&usbtv->buflock, flags); 424 while (!list_empty(&usbtv->bufs)) { 425 struct usbtv_buf *buf = list_first_entry(&usbtv->bufs, 426 struct usbtv_buf, list); 427 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR); 428 list_del(&buf->list); 429 } 430 spin_unlock_irqrestore(&usbtv->buflock, flags); 431 } 432 433 static int usbtv_start(struct usbtv *usbtv) 434 { 435 int i; 436 int ret; 437 438 ret = usb_set_interface(usbtv->udev, 0, 0); 439 if (ret < 0) 440 return ret; 441 442 ret = usbtv_setup_capture(usbtv); 443 if (ret < 0) 444 return ret; 445 446 ret = usb_set_interface(usbtv->udev, 0, 1); 447 if (ret < 0) 448 return ret; 449 450 for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) { 451 struct urb *ip; 452 453 ip = usbtv_setup_iso_transfer(usbtv); 454 if (ip == NULL) { 455 ret = -ENOMEM; 456 goto start_fail; 457 } 458 usbtv->isoc_urbs[i] = ip; 459 460 ret = usb_submit_urb(ip, GFP_KERNEL); 461 if (ret < 0) 462 goto start_fail; 463 } 464 465 return 0; 466 467 start_fail: 468 usbtv_stop(usbtv); 469 return ret; 470 } 471 472 static int usbtv_querycap(struct file *file, void *priv, 473 struct v4l2_capability *cap) 474 { 475 struct usbtv *dev = video_drvdata(file); 476 477 strlcpy(cap->driver, "usbtv", sizeof(cap->driver)); 478 strlcpy(cap->card, "usbtv", sizeof(cap->card)); 479 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)); 480 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE; 481 cap->device_caps |= V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 482 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 483 return 0; 484 } 485 486 static int usbtv_enum_input(struct file *file, void *priv, 487 struct v4l2_input *i) 488 { 489 struct usbtv *dev = video_drvdata(file); 490 491 switch (i->index) { 492 case USBTV_COMPOSITE_INPUT: 493 strlcpy(i->name, "Composite", sizeof(i->name)); 494 break; 495 case USBTV_SVIDEO_INPUT: 496 strlcpy(i->name, "S-Video", sizeof(i->name)); 497 break; 498 default: 499 return -EINVAL; 500 } 501 502 i->type = V4L2_INPUT_TYPE_CAMERA; 503 i->std = dev->vdev.tvnorms; 504 return 0; 505 } 506 507 static int usbtv_enum_fmt_vid_cap(struct file *file, void *priv, 508 struct v4l2_fmtdesc *f) 509 { 510 if (f->index > 0) 511 return -EINVAL; 512 513 strlcpy(f->description, "16 bpp YUY2, 4:2:2, packed", 514 sizeof(f->description)); 515 f->pixelformat = V4L2_PIX_FMT_YUYV; 516 return 0; 517 } 518 519 static int usbtv_fmt_vid_cap(struct file *file, void *priv, 520 struct v4l2_format *f) 521 { 522 struct usbtv *usbtv = video_drvdata(file); 523 524 f->fmt.pix.width = usbtv->width; 525 f->fmt.pix.height = usbtv->height; 526 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 527 f->fmt.pix.field = V4L2_FIELD_INTERLACED; 528 f->fmt.pix.bytesperline = usbtv->width * 2; 529 f->fmt.pix.sizeimage = (f->fmt.pix.bytesperline * f->fmt.pix.height); 530 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 531 532 return 0; 533 } 534 535 static int usbtv_g_std(struct file *file, void *priv, v4l2_std_id *norm) 536 { 537 struct usbtv *usbtv = video_drvdata(file); 538 *norm = usbtv->norm; 539 return 0; 540 } 541 542 static int usbtv_s_std(struct file *file, void *priv, v4l2_std_id norm) 543 { 544 int ret = -EINVAL; 545 struct usbtv *usbtv = video_drvdata(file); 546 547 if ((norm & V4L2_STD_525_60) || (norm & V4L2_STD_PAL)) 548 ret = usbtv_select_norm(usbtv, norm); 549 550 return ret; 551 } 552 553 static int usbtv_g_input(struct file *file, void *priv, unsigned int *i) 554 { 555 struct usbtv *usbtv = video_drvdata(file); 556 *i = usbtv->input; 557 return 0; 558 } 559 560 static int usbtv_s_input(struct file *file, void *priv, unsigned int i) 561 { 562 struct usbtv *usbtv = video_drvdata(file); 563 return usbtv_select_input(usbtv, i); 564 } 565 566 static struct v4l2_ioctl_ops usbtv_ioctl_ops = { 567 .vidioc_querycap = usbtv_querycap, 568 .vidioc_enum_input = usbtv_enum_input, 569 .vidioc_enum_fmt_vid_cap = usbtv_enum_fmt_vid_cap, 570 .vidioc_g_fmt_vid_cap = usbtv_fmt_vid_cap, 571 .vidioc_try_fmt_vid_cap = usbtv_fmt_vid_cap, 572 .vidioc_s_fmt_vid_cap = usbtv_fmt_vid_cap, 573 .vidioc_g_std = usbtv_g_std, 574 .vidioc_s_std = usbtv_s_std, 575 .vidioc_g_input = usbtv_g_input, 576 .vidioc_s_input = usbtv_s_input, 577 578 .vidioc_reqbufs = vb2_ioctl_reqbufs, 579 .vidioc_prepare_buf = vb2_ioctl_prepare_buf, 580 .vidioc_querybuf = vb2_ioctl_querybuf, 581 .vidioc_create_bufs = vb2_ioctl_create_bufs, 582 .vidioc_qbuf = vb2_ioctl_qbuf, 583 .vidioc_dqbuf = vb2_ioctl_dqbuf, 584 .vidioc_streamon = vb2_ioctl_streamon, 585 .vidioc_streamoff = vb2_ioctl_streamoff, 586 }; 587 588 static struct v4l2_file_operations usbtv_fops = { 589 .owner = THIS_MODULE, 590 .unlocked_ioctl = video_ioctl2, 591 .mmap = vb2_fop_mmap, 592 .open = v4l2_fh_open, 593 .release = vb2_fop_release, 594 .read = vb2_fop_read, 595 .poll = vb2_fop_poll, 596 }; 597 598 static int usbtv_queue_setup(struct vb2_queue *vq, 599 const struct v4l2_format *v4l_fmt, unsigned int *nbuffers, 600 unsigned int *nplanes, unsigned int sizes[], void *alloc_ctxs[]) 601 { 602 struct usbtv *usbtv = vb2_get_drv_priv(vq); 603 604 if (*nbuffers < 2) 605 *nbuffers = 2; 606 *nplanes = 1; 607 sizes[0] = USBTV_CHUNK * usbtv->n_chunks * 2 * sizeof(u32); 608 609 return 0; 610 } 611 612 static void usbtv_buf_queue(struct vb2_buffer *vb) 613 { 614 struct usbtv *usbtv = vb2_get_drv_priv(vb->vb2_queue); 615 struct usbtv_buf *buf = container_of(vb, struct usbtv_buf, vb); 616 unsigned long flags; 617 618 if (usbtv->udev == NULL) { 619 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); 620 return; 621 } 622 623 spin_lock_irqsave(&usbtv->buflock, flags); 624 list_add_tail(&buf->list, &usbtv->bufs); 625 spin_unlock_irqrestore(&usbtv->buflock, flags); 626 } 627 628 static int usbtv_start_streaming(struct vb2_queue *vq, unsigned int count) 629 { 630 struct usbtv *usbtv = vb2_get_drv_priv(vq); 631 632 if (usbtv->udev == NULL) 633 return -ENODEV; 634 635 return usbtv_start(usbtv); 636 } 637 638 static void usbtv_stop_streaming(struct vb2_queue *vq) 639 { 640 struct usbtv *usbtv = vb2_get_drv_priv(vq); 641 642 if (usbtv->udev) 643 usbtv_stop(usbtv); 644 } 645 646 static struct vb2_ops usbtv_vb2_ops = { 647 .queue_setup = usbtv_queue_setup, 648 .buf_queue = usbtv_buf_queue, 649 .start_streaming = usbtv_start_streaming, 650 .stop_streaming = usbtv_stop_streaming, 651 }; 652 653 static void usbtv_release(struct v4l2_device *v4l2_dev) 654 { 655 struct usbtv *usbtv = container_of(v4l2_dev, struct usbtv, v4l2_dev); 656 657 v4l2_device_unregister(&usbtv->v4l2_dev); 658 vb2_queue_release(&usbtv->vb2q); 659 kfree(usbtv); 660 } 661 662 int usbtv_video_init(struct usbtv *usbtv) 663 { 664 int ret; 665 666 (void)usbtv_configure_for_norm(usbtv, V4L2_STD_525_60); 667 668 spin_lock_init(&usbtv->buflock); 669 mutex_init(&usbtv->v4l2_lock); 670 mutex_init(&usbtv->vb2q_lock); 671 INIT_LIST_HEAD(&usbtv->bufs); 672 673 /* videobuf2 structure */ 674 usbtv->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 675 usbtv->vb2q.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ; 676 usbtv->vb2q.drv_priv = usbtv; 677 usbtv->vb2q.buf_struct_size = sizeof(struct usbtv_buf); 678 usbtv->vb2q.ops = &usbtv_vb2_ops; 679 usbtv->vb2q.mem_ops = &vb2_vmalloc_memops; 680 usbtv->vb2q.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 681 usbtv->vb2q.lock = &usbtv->vb2q_lock; 682 ret = vb2_queue_init(&usbtv->vb2q); 683 if (ret < 0) { 684 dev_warn(usbtv->dev, "Could not initialize videobuf2 queue\n"); 685 return ret; 686 } 687 688 /* v4l2 structure */ 689 usbtv->v4l2_dev.release = usbtv_release; 690 ret = v4l2_device_register(usbtv->dev, &usbtv->v4l2_dev); 691 if (ret < 0) { 692 dev_warn(usbtv->dev, "Could not register v4l2 device\n"); 693 goto v4l2_fail; 694 } 695 696 /* Video structure */ 697 strlcpy(usbtv->vdev.name, "usbtv", sizeof(usbtv->vdev.name)); 698 usbtv->vdev.v4l2_dev = &usbtv->v4l2_dev; 699 usbtv->vdev.release = video_device_release_empty; 700 usbtv->vdev.fops = &usbtv_fops; 701 usbtv->vdev.ioctl_ops = &usbtv_ioctl_ops; 702 usbtv->vdev.tvnorms = USBTV_TV_STD; 703 usbtv->vdev.queue = &usbtv->vb2q; 704 usbtv->vdev.lock = &usbtv->v4l2_lock; 705 set_bit(V4L2_FL_USE_FH_PRIO, &usbtv->vdev.flags); 706 video_set_drvdata(&usbtv->vdev, usbtv); 707 ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1); 708 if (ret < 0) { 709 dev_warn(usbtv->dev, "Could not register video device\n"); 710 goto vdev_fail; 711 } 712 713 return 0; 714 715 vdev_fail: 716 v4l2_device_unregister(&usbtv->v4l2_dev); 717 v4l2_fail: 718 vb2_queue_release(&usbtv->vb2q); 719 720 return ret; 721 } 722 723 void usbtv_video_free(struct usbtv *usbtv) 724 { 725 mutex_lock(&usbtv->vb2q_lock); 726 mutex_lock(&usbtv->v4l2_lock); 727 728 usbtv_stop(usbtv); 729 video_unregister_device(&usbtv->vdev); 730 v4l2_device_disconnect(&usbtv->v4l2_dev); 731 732 mutex_unlock(&usbtv->v4l2_lock); 733 mutex_unlock(&usbtv->vb2q_lock); 734 735 v4l2_device_put(&usbtv->v4l2_dev); 736 } 737 738 739 740 741 742 /* LDV_COMMENT_BEGIN_MAIN */ 743 #ifdef LDV_MAIN1_sequence_infinite_withcheck_stateful 744 745 /*###########################################################################*/ 746 747 /*############## Driver Environment Generator 0.2 output ####################*/ 748 749 /*###########################################################################*/ 750 751 752 753 /* 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. */ 754 void ldv_check_final_state(void); 755 756 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 757 void ldv_check_return_value(int res); 758 759 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 760 void ldv_check_return_value_probe(int res); 761 762 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 763 void ldv_initialize(void); 764 765 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 766 void ldv_handler_precall(void); 767 768 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 769 int nondet_int(void); 770 771 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 772 int LDV_IN_INTERRUPT; 773 774 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 775 void ldv_main1_sequence_infinite_withcheck_stateful(void) { 776 777 778 779 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 780 /*============================= VARIABLE DECLARATION PART =============================*/ 781 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 782 /* content: static int usbtv_querycap(struct file *file, void *priv, struct v4l2_capability *cap)*/ 783 /* LDV_COMMENT_END_PREP */ 784 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_querycap" */ 785 struct file * var_group1; 786 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_querycap" */ 787 void * var_usbtv_querycap_10_p1; 788 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_querycap" */ 789 struct v4l2_capability * var_usbtv_querycap_10_p2; 790 /* content: static int usbtv_enum_input(struct file *file, void *priv, struct v4l2_input *i)*/ 791 /* LDV_COMMENT_END_PREP */ 792 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_enum_input" */ 793 void * var_usbtv_enum_input_11_p1; 794 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_enum_input" */ 795 struct v4l2_input * var_usbtv_enum_input_11_p2; 796 /* content: static int usbtv_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f)*/ 797 /* LDV_COMMENT_END_PREP */ 798 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_enum_fmt_vid_cap" */ 799 void * var_usbtv_enum_fmt_vid_cap_12_p1; 800 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_enum_fmt_vid_cap" */ 801 struct v4l2_fmtdesc * var_usbtv_enum_fmt_vid_cap_12_p2; 802 /* content: static int usbtv_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *f)*/ 803 /* LDV_COMMENT_END_PREP */ 804 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_fmt_vid_cap" */ 805 void * var_usbtv_fmt_vid_cap_13_p1; 806 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_fmt_vid_cap" */ 807 struct v4l2_format * var_usbtv_fmt_vid_cap_13_p2; 808 /* content: static int usbtv_g_std(struct file *file, void *priv, v4l2_std_id *norm)*/ 809 /* LDV_COMMENT_END_PREP */ 810 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_g_std" */ 811 void * var_usbtv_g_std_14_p1; 812 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_g_std" */ 813 v4l2_std_id * var_usbtv_g_std_14_p2; 814 /* content: static int usbtv_s_std(struct file *file, void *priv, v4l2_std_id norm)*/ 815 /* LDV_COMMENT_END_PREP */ 816 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_s_std" */ 817 void * var_usbtv_s_std_15_p1; 818 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_s_std" */ 819 v4l2_std_id var_usbtv_s_std_15_p2; 820 /* content: static int usbtv_g_input(struct file *file, void *priv, unsigned int *i)*/ 821 /* LDV_COMMENT_END_PREP */ 822 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_g_input" */ 823 void * var_usbtv_g_input_16_p1; 824 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_g_input" */ 825 unsigned int * var_usbtv_g_input_16_p2; 826 /* content: static int usbtv_s_input(struct file *file, void *priv, unsigned int i)*/ 827 /* LDV_COMMENT_END_PREP */ 828 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_s_input" */ 829 void * var_usbtv_s_input_17_p1; 830 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_s_input" */ 831 unsigned int var_usbtv_s_input_17_p2; 832 833 /** STRUCT: struct type: vb2_ops, struct name: usbtv_vb2_ops **/ 834 /* content: static void usbtv_buf_queue(struct vb2_buffer *vb)*/ 835 /* LDV_COMMENT_END_PREP */ 836 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_buf_queue" */ 837 struct vb2_buffer * var_group2; 838 /* content: static int usbtv_start_streaming(struct vb2_queue *vq, unsigned int count)*/ 839 /* LDV_COMMENT_END_PREP */ 840 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_start_streaming" */ 841 struct vb2_queue * var_group3; 842 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "usbtv_start_streaming" */ 843 unsigned int var_usbtv_start_streaming_19_p1; 844 /* content: static void usbtv_stop_streaming(struct vb2_queue *vq)*/ 845 /* LDV_COMMENT_END_PREP */ 846 847 848 849 850 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 851 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 852 /*============================= VARIABLE INITIALIZING PART =============================*/ 853 LDV_IN_INTERRUPT=1; 854 855 856 857 858 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 859 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 860 /*============================= FUNCTION CALL SECTION =============================*/ 861 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 862 ldv_initialize(); 863 864 865 866 867 868 while( nondet_int() 869 ) { 870 871 switch(nondet_int()) { 872 873 case 0: { 874 875 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 876 877 878 /* content: static int usbtv_querycap(struct file *file, void *priv, struct v4l2_capability *cap)*/ 879 /* LDV_COMMENT_END_PREP */ 880 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_querycap" from driver structure with callbacks "usbtv_ioctl_ops" */ 881 ldv_handler_precall(); 882 usbtv_querycap( var_group1, var_usbtv_querycap_10_p1, var_usbtv_querycap_10_p2); 883 884 885 886 887 } 888 889 break; 890 case 1: { 891 892 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 893 894 895 /* content: static int usbtv_enum_input(struct file *file, void *priv, struct v4l2_input *i)*/ 896 /* LDV_COMMENT_END_PREP */ 897 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_enum_input" from driver structure with callbacks "usbtv_ioctl_ops" */ 898 ldv_handler_precall(); 899 usbtv_enum_input( var_group1, var_usbtv_enum_input_11_p1, var_usbtv_enum_input_11_p2); 900 901 902 903 904 } 905 906 break; 907 case 2: { 908 909 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 910 911 912 /* content: static int usbtv_enum_fmt_vid_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f)*/ 913 /* LDV_COMMENT_END_PREP */ 914 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_enum_fmt_vid_cap" from driver structure with callbacks "usbtv_ioctl_ops" */ 915 ldv_handler_precall(); 916 usbtv_enum_fmt_vid_cap( var_group1, var_usbtv_enum_fmt_vid_cap_12_p1, var_usbtv_enum_fmt_vid_cap_12_p2); 917 918 919 920 921 } 922 923 break; 924 case 3: { 925 926 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 927 928 929 /* content: static int usbtv_fmt_vid_cap(struct file *file, void *priv, struct v4l2_format *f)*/ 930 /* LDV_COMMENT_END_PREP */ 931 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_g_fmt_vid_cap" from driver structure with callbacks "usbtv_ioctl_ops" */ 932 ldv_handler_precall(); 933 usbtv_fmt_vid_cap( var_group1, var_usbtv_fmt_vid_cap_13_p1, var_usbtv_fmt_vid_cap_13_p2); 934 935 936 937 938 } 939 940 break; 941 case 4: { 942 943 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 944 945 946 /* content: static int usbtv_g_std(struct file *file, void *priv, v4l2_std_id *norm)*/ 947 /* LDV_COMMENT_END_PREP */ 948 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_g_std" from driver structure with callbacks "usbtv_ioctl_ops" */ 949 ldv_handler_precall(); 950 usbtv_g_std( var_group1, var_usbtv_g_std_14_p1, var_usbtv_g_std_14_p2); 951 952 953 954 955 } 956 957 break; 958 case 5: { 959 960 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 961 962 963 /* content: static int usbtv_s_std(struct file *file, void *priv, v4l2_std_id norm)*/ 964 /* LDV_COMMENT_END_PREP */ 965 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_s_std" from driver structure with callbacks "usbtv_ioctl_ops" */ 966 ldv_handler_precall(); 967 usbtv_s_std( var_group1, var_usbtv_s_std_15_p1, var_usbtv_s_std_15_p2); 968 969 970 971 972 } 973 974 break; 975 case 6: { 976 977 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 978 979 980 /* content: static int usbtv_g_input(struct file *file, void *priv, unsigned int *i)*/ 981 /* LDV_COMMENT_END_PREP */ 982 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_g_input" from driver structure with callbacks "usbtv_ioctl_ops" */ 983 ldv_handler_precall(); 984 usbtv_g_input( var_group1, var_usbtv_g_input_16_p1, var_usbtv_g_input_16_p2); 985 986 987 988 989 } 990 991 break; 992 case 7: { 993 994 /** STRUCT: struct type: v4l2_ioctl_ops, struct name: usbtv_ioctl_ops **/ 995 996 997 /* content: static int usbtv_s_input(struct file *file, void *priv, unsigned int i)*/ 998 /* LDV_COMMENT_END_PREP */ 999 /* LDV_COMMENT_FUNCTION_CALL Function from field "vidioc_s_input" from driver structure with callbacks "usbtv_ioctl_ops" */ 1000 ldv_handler_precall(); 1001 usbtv_s_input( var_group1, var_usbtv_s_input_17_p1, var_usbtv_s_input_17_p2); 1002 1003 1004 1005 1006 } 1007 1008 break; 1009 case 8: { 1010 1011 /** STRUCT: struct type: vb2_ops, struct name: usbtv_vb2_ops **/ 1012 1013 1014 /* content: static void usbtv_buf_queue(struct vb2_buffer *vb)*/ 1015 /* LDV_COMMENT_END_PREP */ 1016 /* LDV_COMMENT_FUNCTION_CALL Function from field "buf_queue" from driver structure with callbacks "usbtv_vb2_ops" */ 1017 ldv_handler_precall(); 1018 usbtv_buf_queue( var_group2); 1019 1020 1021 1022 1023 } 1024 1025 break; 1026 case 9: { 1027 1028 /** STRUCT: struct type: vb2_ops, struct name: usbtv_vb2_ops **/ 1029 1030 1031 /* content: static int usbtv_start_streaming(struct vb2_queue *vq, unsigned int count)*/ 1032 /* LDV_COMMENT_END_PREP */ 1033 /* LDV_COMMENT_FUNCTION_CALL Function from field "start_streaming" from driver structure with callbacks "usbtv_vb2_ops" */ 1034 ldv_handler_precall(); 1035 usbtv_start_streaming( var_group3, var_usbtv_start_streaming_19_p1); 1036 1037 1038 1039 1040 } 1041 1042 break; 1043 case 10: { 1044 1045 /** STRUCT: struct type: vb2_ops, struct name: usbtv_vb2_ops **/ 1046 1047 1048 /* content: static void usbtv_stop_streaming(struct vb2_queue *vq)*/ 1049 /* LDV_COMMENT_END_PREP */ 1050 /* LDV_COMMENT_FUNCTION_CALL Function from field "stop_streaming" from driver structure with callbacks "usbtv_vb2_ops" */ 1051 ldv_handler_precall(); 1052 usbtv_stop_streaming( var_group3); 1053 1054 1055 1056 1057 } 1058 1059 break; 1060 default: break; 1061 1062 } 1063 1064 } 1065 1066 ldv_module_exit: 1067 1068 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 1069 ldv_final: ldv_check_final_state(); 1070 1071 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 1072 return; 1073 1074 } 1075 #endif 1076 1077 /* LDV_COMMENT_END_MAIN */

1 2 #include <linux/kernel.h> 3 #include <linux/module.h> 4 5 #include <linux/usb.h> 6 7 #include <verifier/rcv.h> // For LDV auxiliary routines. 8 #include <kernel-model/ERR.inc> 9 10 // There are 3 possible states of usb device reference counter 11 enum 12 { 13 LDV_USB_DEV_ZERO_STATE = 0, // Usb device reference hasn't been acquired 14 LDV_USB_DEV_ACQUIRED = 1, // Usb device reference acquired 15 LDV_USB_DEV_INCREASED = 2 // Usb device reference counter increased 16 }; 17 18 /* LDV_COMMENT_OTHER The model automaton state (one of thee possible ones). */ 19 int ldv_usb_dev_state = LDV_USB_DEV_ZERO_STATE; 20 21 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_interface_to_usbdev') Change state state after acquiring a reference to usb_device. */ 22 void ldv_interface_to_usbdev(void) 23 { 24 /* LDV_COMMENT_OTHER Initially we suppose this function is used to acquire a reference to usb_device. */ 25 if (ldv_usb_dev_state == LDV_USB_DEV_ZERO_STATE) 26 /* LDV_COMMENT_CHANGE_STATE Usb device reference acquired. */ 27 ldv_usb_dev_state = LDV_USB_DEV_ACQUIRED; 28 } 29 30 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_usb_get_dev') Change state after increasing the reference counter with usb_get_dev. */ 31 void ldv_usb_get_dev(void) 32 { 33 /* LDV_COMMENT_OTHER Here the reference has surely been acquired somewhere. */ 34 if (ldv_usb_dev_state < LDV_USB_DEV_ACQUIRED) { 35 /* LDV_COMMENT_CHANGE_STATE The reference has already been acquired. */ 36 ldv_usb_dev_state = LDV_USB_DEV_ACQUIRED; 37 } 38 /* LDV_COMMENT_CHANGE_STATE Increase reference counter. */ 39 ldv_usb_dev_state++; 40 } 41 42 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_usb_put_dev') Change state after decreasing the reference counter with usb_put_dev. */ 43 void ldv_usb_put_dev(void) 44 { 45 /* LDV_COMMENT_ASSERT Check usb device reference counter has been increased. */ 46 ldv_assert(ldv_usb_dev_state >= LDV_USB_DEV_INCREASED); 47 /* LDV_COMMENT_CHANGE_STATE Decrease reference counter. */ 48 ldv_usb_dev_state--; 49 /* LDV_COMMENT_OTHER LDV_USB_DEV_ACQUIRED is special (for when the one has forgotten to increase the counter). Not intednded to be used here. */ 50 if (ldv_usb_dev_state == LDV_USB_DEV_ACQUIRED) { 51 /* LDV_COMMENT_CHANGE_STATE Re-zero the model variable. */ 52 ldv_usb_dev_state = LDV_USB_DEV_ZERO_STATE; 53 } 54 } 55 56 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_check_return_value_probe') Check the probe function leaved the model in the proper state. */ 57 void ldv_check_return_value_probe(int retval) 58 { 59 /* LDV_COMMENT_OTHER Probe finished unsuccessfully and returned an error. */ 60 if (retval) { 61 /* LDV_COMMENT_ASSERT Check usb device reference counter is not increased. */ 62 ldv_assert(ldv_usb_dev_state < LDV_USB_DEV_INCREASED); 63 /* LDV_COMMENT_OTHER LDV_USB_DEV_ACQUIRED is special (for when the one has forgotten to increase the counter). Not this case. */ 64 if (ldv_usb_dev_state == LDV_USB_DEV_ACQUIRED) 65 /* LDV_COMMENT_CHANGE_STATE Re-zero the model variable. */ 66 ldv_usb_dev_state = LDV_USB_DEV_ZERO_STATE; 67 } // else /* LDV_COMMENT_OTHER Probe finished successfully and returned 0. */ 68 // /* LDV_COMMENT_ASSERT Check usb device reference counter is not acquired or has been increased. */ 69 // ldv_assert(ldv_usb_dev_state != LDV_USB_DEV_ACQUIRED); 70 } 71 72 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_check_final_state') Check that usb device reference hasn't been acquired or the counter has been decreased. */ 73 void ldv_check_final_state(void) 74 { 75 /* LDV_COMMENT_ASSERT Check that usb device reference hasn't been acquired or the counter has been decreased. */ 76 ldv_assert(ldv_usb_dev_state < LDV_USB_DEV_INCREASED); 77 }

1 /* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org> 5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de> 6 * Copyright (c) 2008-2009 Novell Inc. 7 * 8 * This file is released under the GPLv2 9 * 10 * See Documentation/driver-model/ for more information. 11 */ 12 13 #ifndef _DEVICE_H_ 14 #define _DEVICE_H_ 15 16 #include <linux/ioport.h> 17 #include <linux/kobject.h> 18 #include <linux/klist.h> 19 #include <linux/list.h> 20 #include <linux/lockdep.h> 21 #include <linux/compiler.h> 22 #include <linux/types.h> 23 #include <linux/mutex.h> 24 #include <linux/pinctrl/devinfo.h> 25 #include <linux/pm.h> 26 #include <linux/atomic.h> 27 #include <linux/ratelimit.h> 28 #include <linux/uidgid.h> 29 #include <linux/gfp.h> 30 #include <asm/device.h> 31 32 struct device; 33 struct device_private; 34 struct device_driver; 35 struct driver_private; 36 struct module; 37 struct class; 38 struct subsys_private; 39 struct bus_type; 40 struct device_node; 41 struct iommu_ops; 42 struct iommu_group; 43 44 struct bus_attribute { 45 struct attribute attr; 46 ssize_t (*show)(struct bus_type *bus, char *buf); 47 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); 48 }; 49 50 #define BUS_ATTR(_name, _mode, _show, _store) \ 51 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) 52 #define BUS_ATTR_RW(_name) \ 53 struct bus_attribute bus_attr_##_name = __ATTR_RW(_name) 54 #define BUS_ATTR_RO(_name) \ 55 struct bus_attribute bus_attr_##_name = __ATTR_RO(_name) 56 57 extern int __must_check bus_create_file(struct bus_type *, 58 struct bus_attribute *); 59 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 60 61 /** 62 * struct bus_type - The bus type of the device 63 * 64 * @name: The name of the bus. 65 * @dev_name: Used for subsystems to enumerate devices like ("foo%u", dev->id). 66 * @dev_root: Default device to use as the parent. 67 * @dev_attrs: Default attributes of the devices on the bus. 68 * @bus_groups: Default attributes of the bus. 69 * @dev_groups: Default attributes of the devices on the bus. 70 * @drv_groups: Default attributes of the device drivers on the bus. 71 * @match: Called, perhaps multiple times, whenever a new device or driver 72 * is added for this bus. It should return a nonzero value if the 73 * given device can be handled by the given driver. 74 * @uevent: Called when a device is added, removed, or a few other things 75 * that generate uevents to add the environment variables. 76 * @probe: Called when a new device or driver add to this bus, and callback 77 * the specific driver's probe to initial the matched device. 78 * @remove: Called when a device removed from this bus. 79 * @shutdown: Called at shut-down time to quiesce the device. 80 * 81 * @online: Called to put the device back online (after offlining it). 82 * @offline: Called to put the device offline for hot-removal. May fail. 83 * 84 * @suspend: Called when a device on this bus wants to go to sleep mode. 85 * @resume: Called to bring a device on this bus out of sleep mode. 86 * @pm: Power management operations of this bus, callback the specific 87 * device driver's pm-ops. 88 * @iommu_ops: IOMMU specific operations for this bus, used to attach IOMMU 89 * driver implementations to a bus and allow the driver to do 90 * bus-specific setup 91 * @p: The private data of the driver core, only the driver core can 92 * touch this. 93 * @lock_key: Lock class key for use by the lock validator 94 * 95 * A bus is a channel between the processor and one or more devices. For the 96 * purposes of the device model, all devices are connected via a bus, even if 97 * it is an internal, virtual, "platform" bus. Buses can plug into each other. 98 * A USB controller is usually a PCI device, for example. The device model 99 * represents the actual connections between buses and the devices they control. 100 * A bus is represented by the bus_type structure. It contains the name, the 101 * default attributes, the bus' methods, PM operations, and the driver core's 102 * private data. 103 */ 104 struct bus_type { 105 const char *name; 106 const char *dev_name; 107 struct device *dev_root; 108 struct device_attribute *dev_attrs; /* use dev_groups instead */ 109 const struct attribute_group **bus_groups; 110 const struct attribute_group **dev_groups; 111 const struct attribute_group **drv_groups; 112 113 int (*match)(struct device *dev, struct device_driver *drv); 114 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 115 int (*probe)(struct device *dev); 116 int (*remove)(struct device *dev); 117 void (*shutdown)(struct device *dev); 118 119 int (*online)(struct device *dev); 120 int (*offline)(struct device *dev); 121 122 int (*suspend)(struct device *dev, pm_message_t state); 123 int (*resume)(struct device *dev); 124 125 const struct dev_pm_ops *pm; 126 127 struct iommu_ops *iommu_ops; 128 129 struct subsys_private *p; 130 struct lock_class_key lock_key; 131 }; 132 133 extern int __must_check bus_register(struct bus_type *bus); 134 135 extern void bus_unregister(struct bus_type *bus); 136 137 extern int __must_check bus_rescan_devices(struct bus_type *bus); 138 139 /* iterator helpers for buses */ 140 struct subsys_dev_iter { 141 struct klist_iter ki; 142 const struct device_type *type; 143 }; 144 void subsys_dev_iter_init(struct subsys_dev_iter *iter, 145 struct bus_type *subsys, 146 struct device *start, 147 const struct device_type *type); 148 struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter); 149 void subsys_dev_iter_exit(struct subsys_dev_iter *iter); 150 151 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, 152 int (*fn)(struct device *dev, void *data)); 153 struct device *bus_find_device(struct bus_type *bus, struct device *start, 154 void *data, 155 int (*match)(struct device *dev, void *data)); 156 struct device *bus_find_device_by_name(struct bus_type *bus, 157 struct device *start, 158 const char *name); 159 struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id, 160 struct device *hint); 161 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 162 void *data, int (*fn)(struct device_driver *, void *)); 163 void bus_sort_breadthfirst(struct bus_type *bus, 164 int (*compare)(const struct device *a, 165 const struct device *b)); 166 /* 167 * Bus notifiers: Get notified of addition/removal of devices 168 * and binding/unbinding of drivers to devices. 169 * In the long run, it should be a replacement for the platform 170 * notify hooks. 171 */ 172 struct notifier_block; 173 174 extern int bus_register_notifier(struct bus_type *bus, 175 struct notifier_block *nb); 176 extern int bus_unregister_notifier(struct bus_type *bus, 177 struct notifier_block *nb); 178 179 /* All 4 notifers below get called with the target struct device * 180 * as an argument. Note that those functions are likely to be called 181 * with the device lock held in the core, so be careful. 182 */ 183 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 184 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */ 185 #define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be 186 bound */ 187 #define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */ 188 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be 189 unbound */ 190 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound 191 from the device */ 192 193 extern struct kset *bus_get_kset(struct bus_type *bus); 194 extern struct klist *bus_get_device_klist(struct bus_type *bus); 195 196 /** 197 * struct device_driver - The basic device driver structure 198 * @name: Name of the device driver. 199 * @bus: The bus which the device of this driver belongs to. 200 * @owner: The module owner. 201 * @mod_name: Used for built-in modules. 202 * @suppress_bind_attrs: Disables bind/unbind via sysfs. 203 * @of_match_table: The open firmware table. 204 * @acpi_match_table: The ACPI match table. 205 * @probe: Called to query the existence of a specific device, 206 * whether this driver can work with it, and bind the driver 207 * to a specific device. 208 * @remove: Called when the device is removed from the system to 209 * unbind a device from this driver. 210 * @shutdown: Called at shut-down time to quiesce the device. 211 * @suspend: Called to put the device to sleep mode. Usually to a 212 * low power state. 213 * @resume: Called to bring a device from sleep mode. 214 * @groups: Default attributes that get created by the driver core 215 * automatically. 216 * @pm: Power management operations of the device which matched 217 * this driver. 218 * @p: Driver core's private data, no one other than the driver 219 * core can touch this. 220 * 221 * The device driver-model tracks all of the drivers known to the system. 222 * The main reason for this tracking is to enable the driver core to match 223 * up drivers with new devices. Once drivers are known objects within the 224 * system, however, a number of other things become possible. Device drivers 225 * can export information and configuration variables that are independent 226 * of any specific device. 227 */ 228 struct device_driver { 229 const char *name; 230 struct bus_type *bus; 231 232 struct module *owner; 233 const char *mod_name; /* used for built-in modules */ 234 235 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 236 237 const struct of_device_id *of_match_table; 238 const struct acpi_device_id *acpi_match_table; 239 240 int (*probe) (struct device *dev); 241 int (*remove) (struct device *dev); 242 void (*shutdown) (struct device *dev); 243 int (*suspend) (struct device *dev, pm_message_t state); 244 int (*resume) (struct device *dev); 245 const struct attribute_group **groups; 246 247 const struct dev_pm_ops *pm; 248 249 struct driver_private *p; 250 }; 251 252 253 extern int __must_check driver_register(struct device_driver *drv); 254 extern void driver_unregister(struct device_driver *drv); 255 256 extern struct device_driver *driver_find(const char *name, 257 struct bus_type *bus); 258 extern int driver_probe_done(void); 259 extern void wait_for_device_probe(void); 260 261 262 /* sysfs interface for exporting driver attributes */ 263 264 struct driver_attribute { 265 struct attribute attr; 266 ssize_t (*show)(struct device_driver *driver, char *buf); 267 ssize_t (*store)(struct device_driver *driver, const char *buf, 268 size_t count); 269 }; 270 271 #define DRIVER_ATTR(_name, _mode, _show, _store) \ 272 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store) 273 #define DRIVER_ATTR_RW(_name) \ 274 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name) 275 #define DRIVER_ATTR_RO(_name) \ 276 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name) 277 #define DRIVER_ATTR_WO(_name) \ 278 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name) 279 280 extern int __must_check driver_create_file(struct device_driver *driver, 281 const struct driver_attribute *attr); 282 extern void driver_remove_file(struct device_driver *driver, 283 const struct driver_attribute *attr); 284 285 extern int __must_check driver_for_each_device(struct device_driver *drv, 286 struct device *start, 287 void *data, 288 int (*fn)(struct device *dev, 289 void *)); 290 struct device *driver_find_device(struct device_driver *drv, 291 struct device *start, void *data, 292 int (*match)(struct device *dev, void *data)); 293 294 /** 295 * struct subsys_interface - interfaces to device functions 296 * @name: name of the device function 297 * @subsys: subsytem of the devices to attach to 298 * @node: the list of functions registered at the subsystem 299 * @add_dev: device hookup to device function handler 300 * @remove_dev: device hookup to device function handler 301 * 302 * Simple interfaces attached to a subsystem. Multiple interfaces can 303 * attach to a subsystem and its devices. Unlike drivers, they do not 304 * exclusively claim or control devices. Interfaces usually represent 305 * a specific functionality of a subsystem/class of devices. 306 */ 307 struct subsys_interface { 308 const char *name; 309 struct bus_type *subsys; 310 struct list_head node; 311 int (*add_dev)(struct device *dev, struct subsys_interface *sif); 312 int (*remove_dev)(struct device *dev, struct subsys_interface *sif); 313 }; 314 315 int subsys_interface_register(struct subsys_interface *sif); 316 void subsys_interface_unregister(struct subsys_interface *sif); 317 318 int subsys_system_register(struct bus_type *subsys, 319 const struct attribute_group **groups); 320 int subsys_virtual_register(struct bus_type *subsys, 321 const struct attribute_group **groups); 322 323 /** 324 * struct class - device classes 325 * @name: Name of the class. 326 * @owner: The module owner. 327 * @class_attrs: Default attributes of this class. 328 * @dev_groups: Default attributes of the devices that belong to the class. 329 * @dev_kobj: The kobject that represents this class and links it into the hierarchy. 330 * @dev_uevent: Called when a device is added, removed from this class, or a 331 * few other things that generate uevents to add the environment 332 * variables. 333 * @devnode: Callback to provide the devtmpfs. 334 * @class_release: Called to release this class. 335 * @dev_release: Called to release the device. 336 * @suspend: Used to put the device to sleep mode, usually to a low power 337 * state. 338 * @resume: Used to bring the device from the sleep mode. 339 * @ns_type: Callbacks so sysfs can detemine namespaces. 340 * @namespace: Namespace of the device belongs to this class. 341 * @pm: The default device power management operations of this class. 342 * @p: The private data of the driver core, no one other than the 343 * driver core can touch this. 344 * 345 * A class is a higher-level view of a device that abstracts out low-level 346 * implementation details. Drivers may see a SCSI disk or an ATA disk, but, 347 * at the class level, they are all simply disks. Classes allow user space 348 * to work with devices based on what they do, rather than how they are 349 * connected or how they work. 350 */ 351 struct class { 352 const char *name; 353 struct module *owner; 354 355 struct class_attribute *class_attrs; 356 const struct attribute_group **dev_groups; 357 struct kobject *dev_kobj; 358 359 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); 360 char *(*devnode)(struct device *dev, umode_t *mode); 361 362 void (*class_release)(struct class *class); 363 void (*dev_release)(struct device *dev); 364 365 int (*suspend)(struct device *dev, pm_message_t state); 366 int (*resume)(struct device *dev); 367 368 const struct kobj_ns_type_operations *ns_type; 369 const void *(*namespace)(struct device *dev); 370 371 const struct dev_pm_ops *pm; 372 373 struct subsys_private *p; 374 }; 375 376 struct class_dev_iter { 377 struct klist_iter ki; 378 const struct device_type *type; 379 }; 380 381 extern struct kobject *sysfs_dev_block_kobj; 382 extern struct kobject *sysfs_dev_char_kobj; 383 extern int __must_check __class_register(struct class *class, 384 struct lock_class_key *key); 385 extern void class_unregister(struct class *class); 386 387 /* This is a #define to keep the compiler from merging different 388 * instances of the __key variable */ 389 #define class_register(class) \ 390 ({ \ 391 static struct lock_class_key __key; \ 392 __class_register(class, &__key); \ 393 }) 394 395 struct class_compat; 396 struct class_compat *class_compat_register(const char *name); 397 void class_compat_unregister(struct class_compat *cls); 398 int class_compat_create_link(struct class_compat *cls, struct device *dev, 399 struct device *device_link); 400 void class_compat_remove_link(struct class_compat *cls, struct device *dev, 401 struct device *device_link); 402 403 extern void class_dev_iter_init(struct class_dev_iter *iter, 404 struct class *class, 405 struct device *start, 406 const struct device_type *type); 407 extern struct device *class_dev_iter_next(struct class_dev_iter *iter); 408 extern void class_dev_iter_exit(struct class_dev_iter *iter); 409 410 extern int class_for_each_device(struct class *class, struct device *start, 411 void *data, 412 int (*fn)(struct device *dev, void *data)); 413 extern struct device *class_find_device(struct class *class, 414 struct device *start, const void *data, 415 int (*match)(struct device *, const void *)); 416 417 struct class_attribute { 418 struct attribute attr; 419 ssize_t (*show)(struct class *class, struct class_attribute *attr, 420 char *buf); 421 ssize_t (*store)(struct class *class, struct class_attribute *attr, 422 const char *buf, size_t count); 423 }; 424 425 #define CLASS_ATTR(_name, _mode, _show, _store) \ 426 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) 427 #define CLASS_ATTR_RW(_name) \ 428 struct class_attribute class_attr_##_name = __ATTR_RW(_name) 429 #define CLASS_ATTR_RO(_name) \ 430 struct class_attribute class_attr_##_name = __ATTR_RO(_name) 431 432 extern int __must_check class_create_file_ns(struct class *class, 433 const struct class_attribute *attr, 434 const void *ns); 435 extern void class_remove_file_ns(struct class *class, 436 const struct class_attribute *attr, 437 const void *ns); 438 439 static inline int __must_check class_create_file(struct class *class, 440 const struct class_attribute *attr) 441 { 442 return class_create_file_ns(class, attr, NULL); 443 } 444 445 static inline void class_remove_file(struct class *class, 446 const struct class_attribute *attr) 447 { 448 return class_remove_file_ns(class, attr, NULL); 449 } 450 451 /* Simple class attribute that is just a static string */ 452 struct class_attribute_string { 453 struct class_attribute attr; 454 char *str; 455 }; 456 457 /* Currently read-only only */ 458 #define _CLASS_ATTR_STRING(_name, _mode, _str) \ 459 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } 460 #define CLASS_ATTR_STRING(_name, _mode, _str) \ 461 struct class_attribute_string class_attr_##_name = \ 462 _CLASS_ATTR_STRING(_name, _mode, _str) 463 464 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 465 char *buf); 466 467 struct class_interface { 468 struct list_head node; 469 struct class *class; 470 471 int (*add_dev) (struct device *, struct class_interface *); 472 void (*remove_dev) (struct device *, struct class_interface *); 473 }; 474 475 extern int __must_check class_interface_register(struct class_interface *); 476 extern void class_interface_unregister(struct class_interface *); 477 478 extern struct class * __must_check __class_create(struct module *owner, 479 const char *name, 480 struct lock_class_key *key); 481 extern void class_destroy(struct class *cls); 482 483 /* This is a #define to keep the compiler from merging different 484 * instances of the __key variable */ 485 #define class_create(owner, name) \ 486 ({ \ 487 static struct lock_class_key __key; \ 488 __class_create(owner, name, &__key); \ 489 }) 490 491 /* 492 * The type of device, "struct device" is embedded in. A class 493 * or bus can contain devices of different types 494 * like "partitions" and "disks", "mouse" and "event". 495 * This identifies the device type and carries type-specific 496 * information, equivalent to the kobj_type of a kobject. 497 * If "name" is specified, the uevent will contain it in 498 * the DEVTYPE variable. 499 */ 500 struct device_type { 501 const char *name; 502 const struct attribute_group **groups; 503 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 504 char *(*devnode)(struct device *dev, umode_t *mode, 505 kuid_t *uid, kgid_t *gid); 506 void (*release)(struct device *dev); 507 508 const struct dev_pm_ops *pm; 509 }; 510 511 /* interface for exporting device attributes */ 512 struct device_attribute { 513 struct attribute attr; 514 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 515 char *buf); 516 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 517 const char *buf, size_t count); 518 }; 519 520 struct dev_ext_attribute { 521 struct device_attribute attr; 522 void *var; 523 }; 524 525 ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr, 526 char *buf); 527 ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr, 528 const char *buf, size_t count); 529 ssize_t device_show_int(struct device *dev, struct device_attribute *attr, 530 char *buf); 531 ssize_t device_store_int(struct device *dev, struct device_attribute *attr, 532 const char *buf, size_t count); 533 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 534 char *buf); 535 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 536 const char *buf, size_t count); 537 538 #define DEVICE_ATTR(_name, _mode, _show, _store) \ 539 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 540 #define DEVICE_ATTR_RW(_name) \ 541 struct device_attribute dev_attr_##_name = __ATTR_RW(_name) 542 #define DEVICE_ATTR_RO(_name) \ 543 struct device_attribute dev_attr_##_name = __ATTR_RO(_name) 544 #define DEVICE_ATTR_WO(_name) \ 545 struct device_attribute dev_attr_##_name = __ATTR_WO(_name) 546 #define DEVICE_ULONG_ATTR(_name, _mode, _var) \ 547 struct dev_ext_attribute dev_attr_##_name = \ 548 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } 549 #define DEVICE_INT_ATTR(_name, _mode, _var) \ 550 struct dev_ext_attribute dev_attr_##_name = \ 551 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) } 552 #define DEVICE_BOOL_ATTR(_name, _mode, _var) \ 553 struct dev_ext_attribute dev_attr_##_name = \ 554 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) } 555 #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \ 556 struct device_attribute dev_attr_##_name = \ 557 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) 558 559 extern int device_create_file(struct device *device, 560 const struct device_attribute *entry); 561 extern void device_remove_file(struct device *dev, 562 const struct device_attribute *attr); 563 extern bool device_remove_file_self(struct device *dev, 564 const struct device_attribute *attr); 565 extern int __must_check device_create_bin_file(struct device *dev, 566 const struct bin_attribute *attr); 567 extern void device_remove_bin_file(struct device *dev, 568 const struct bin_attribute *attr); 569 570 /* device resource management */ 571 typedef void (*dr_release_t)(struct device *dev, void *res); 572 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 573 574 #ifdef CONFIG_DEBUG_DEVRES 575 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 576 const char *name); 577 #define devres_alloc(release, size, gfp) \ 578 __devres_alloc(release, size, gfp, #release) 579 #else 580 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 581 #endif 582 extern void devres_for_each_res(struct device *dev, dr_release_t release, 583 dr_match_t match, void *match_data, 584 void (*fn)(struct device *, void *, void *), 585 void *data); 586 extern void devres_free(void *res); 587 extern void devres_add(struct device *dev, void *res); 588 extern void *devres_find(struct device *dev, dr_release_t release, 589 dr_match_t match, void *match_data); 590 extern void *devres_get(struct device *dev, void *new_res, 591 dr_match_t match, void *match_data); 592 extern void *devres_remove(struct device *dev, dr_release_t release, 593 dr_match_t match, void *match_data); 594 extern int devres_destroy(struct device *dev, dr_release_t release, 595 dr_match_t match, void *match_data); 596 extern int devres_release(struct device *dev, dr_release_t release, 597 dr_match_t match, void *match_data); 598 599 /* devres group */ 600 extern void * __must_check devres_open_group(struct device *dev, void *id, 601 gfp_t gfp); 602 extern void devres_close_group(struct device *dev, void *id); 603 extern void devres_remove_group(struct device *dev, void *id); 604 extern int devres_release_group(struct device *dev, void *id); 605 606 /* managed devm_k.alloc/kfree for device drivers */ 607 extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp); 608 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp) 609 { 610 return devm_kmalloc(dev, size, gfp | __GFP_ZERO); 611 } 612 static inline void *devm_kmalloc_array(struct device *dev, 613 size_t n, size_t size, gfp_t flags) 614 { 615 if (size != 0 && n > SIZE_MAX / size) 616 return NULL; 617 return devm_kmalloc(dev, n * size, flags); 618 } 619 static inline void *devm_kcalloc(struct device *dev, 620 size_t n, size_t size, gfp_t flags) 621 { 622 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); 623 } 624 extern void devm_kfree(struct device *dev, void *p); 625 extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp); 626 extern void *devm_kmemdup(struct device *dev, const void *src, size_t len, 627 gfp_t gfp); 628 629 extern unsigned long devm_get_free_pages(struct device *dev, 630 gfp_t gfp_mask, unsigned int order); 631 extern void devm_free_pages(struct device *dev, unsigned long addr); 632 633 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); 634 void __iomem *devm_request_and_ioremap(struct device *dev, 635 struct resource *res); 636 637 /* allows to add/remove a custom action to devres stack */ 638 int devm_add_action(struct device *dev, void (*action)(void *), void *data); 639 void devm_remove_action(struct device *dev, void (*action)(void *), void *data); 640 641 struct device_dma_parameters { 642 /* 643 * a low level driver may set these to teach IOMMU code about 644 * sg limitations. 645 */ 646 unsigned int max_segment_size; 647 unsigned long segment_boundary_mask; 648 }; 649 650 struct acpi_device; 651 652 struct acpi_dev_node { 653 #ifdef CONFIG_ACPI 654 struct acpi_device *companion; 655 #endif 656 }; 657 658 /** 659 * struct device - The basic device structure 660 * @parent: The device's "parent" device, the device to which it is attached. 661 * In most cases, a parent device is some sort of bus or host 662 * controller. If parent is NULL, the device, is a top-level device, 663 * which is not usually what you want. 664 * @p: Holds the private data of the driver core portions of the device. 665 * See the comment of the struct device_private for detail. 666 * @kobj: A top-level, abstract class from which other classes are derived. 667 * @init_name: Initial name of the device. 668 * @type: The type of device. 669 * This identifies the device type and carries type-specific 670 * information. 671 * @mutex: Mutex to synchronize calls to its driver. 672 * @bus: Type of bus device is on. 673 * @driver: Which driver has allocated this 674 * @platform_data: Platform data specific to the device. 675 * Example: For devices on custom boards, as typical of embedded 676 * and SOC based hardware, Linux often uses platform_data to point 677 * to board-specific structures describing devices and how they 678 * are wired. That can include what ports are available, chip 679 * variants, which GPIO pins act in what additional roles, and so 680 * on. This shrinks the "Board Support Packages" (BSPs) and 681 * minimizes board-specific #ifdefs in drivers. 682 * @driver_data: Private pointer for driver specific info. 683 * @power: For device power management. 684 * See Documentation/power/devices.txt for details. 685 * @pm_domain: Provide callbacks that are executed during system suspend, 686 * hibernation, system resume and during runtime PM transitions 687 * along with subsystem-level and driver-level callbacks. 688 * @pins: For device pin management. 689 * See Documentation/pinctrl.txt for details. 690 * @numa_node: NUMA node this device is close to. 691 * @dma_mask: Dma mask (if dma'ble device). 692 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all 693 * hardware supports 64-bit addresses for consistent allocations 694 * such descriptors. 695 * @dma_pfn_offset: offset of DMA memory range relatively of RAM 696 * @dma_parms: A low level driver may set these to teach IOMMU code about 697 * segment limitations. 698 * @dma_pools: Dma pools (if dma'ble device). 699 * @dma_mem: Internal for coherent mem override. 700 * @cma_area: Contiguous memory area for dma allocations 701 * @archdata: For arch-specific additions. 702 * @of_node: Associated device tree node. 703 * @acpi_node: Associated ACPI device node. 704 * @devt: For creating the sysfs "dev". 705 * @id: device instance 706 * @devres_lock: Spinlock to protect the resource of the device. 707 * @devres_head: The resources list of the device. 708 * @knode_class: The node used to add the device to the class list. 709 * @class: The class of the device. 710 * @groups: Optional attribute groups. 711 * @release: Callback to free the device after all references have 712 * gone away. This should be set by the allocator of the 713 * device (i.e. the bus driver that discovered the device). 714 * @iommu_group: IOMMU group the device belongs to. 715 * 716 * @offline_disabled: If set, the device is permanently online. 717 * @offline: Set after successful invocation of bus type's .offline(). 718 * 719 * At the lowest level, every device in a Linux system is represented by an 720 * instance of struct device. The device structure contains the information 721 * that the device model core needs to model the system. Most subsystems, 722 * however, track additional information about the devices they host. As a 723 * result, it is rare for devices to be represented by bare device structures; 724 * instead, that structure, like kobject structures, is usually embedded within 725 * a higher-level representation of the device. 726 */ 727 struct device { 728 struct device *parent; 729 730 struct device_private *p; 731 732 struct kobject kobj; 733 const char *init_name; /* initial name of the device */ 734 const struct device_type *type; 735 736 struct mutex mutex; /* mutex to synchronize calls to 737 * its driver. 738 */ 739 740 struct bus_type *bus; /* type of bus device is on */ 741 struct device_driver *driver; /* which driver has allocated this 742 device */ 743 void *platform_data; /* Platform specific data, device 744 core doesn't touch it */ 745 void *driver_data; /* Driver data, set and get with 746 dev_set/get_drvdata */ 747 struct dev_pm_info power; 748 struct dev_pm_domain *pm_domain; 749 750 #ifdef CONFIG_PINCTRL 751 struct dev_pin_info *pins; 752 #endif 753 754 #ifdef CONFIG_NUMA 755 int numa_node; /* NUMA node this device is close to */ 756 #endif 757 u64 *dma_mask; /* dma mask (if dma'able device) */ 758 u64 coherent_dma_mask;/* Like dma_mask, but for 759 alloc_coherent mappings as 760 not all hardware supports 761 64 bit addresses for consistent 762 allocations such descriptors. */ 763 unsigned long dma_pfn_offset; 764 765 struct device_dma_parameters *dma_parms; 766 767 struct list_head dma_pools; /* dma pools (if dma'ble) */ 768 769 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 770 override */ 771 #ifdef CONFIG_DMA_CMA 772 struct cma *cma_area; /* contiguous memory area for dma 773 allocations */ 774 #endif 775 /* arch specific additions */ 776 struct dev_archdata archdata; 777 778 struct device_node *of_node; /* associated device tree node */ 779 struct acpi_dev_node acpi_node; /* associated ACPI device node */ 780 781 dev_t devt; /* dev_t, creates the sysfs "dev" */ 782 u32 id; /* device instance */ 783 784 spinlock_t devres_lock; 785 struct list_head devres_head; 786 787 struct klist_node knode_class; 788 struct class *class; 789 const struct attribute_group **groups; /* optional groups */ 790 791 void (*release)(struct device *dev); 792 struct iommu_group *iommu_group; 793 794 bool offline_disabled:1; 795 bool offline:1; 796 }; 797 798 static inline struct device *kobj_to_dev(struct kobject *kobj) 799 { 800 return container_of(kobj, struct device, kobj); 801 } 802 803 /* Get the wakeup routines, which depend on struct device */ 804 #include <linux/pm_wakeup.h> 805 806 static inline const char *dev_name(const struct device *dev) 807 { 808 /* Use the init name until the kobject becomes available */ 809 if (dev->init_name) 810 return dev->init_name; 811 812 return kobject_name(&dev->kobj); 813 } 814 815 extern __printf(2, 3) 816 int dev_set_name(struct device *dev, const char *name, ...); 817 818 #ifdef CONFIG_NUMA 819 static inline int dev_to_node(struct device *dev) 820 { 821 return dev->numa_node; 822 } 823 static inline void set_dev_node(struct device *dev, int node) 824 { 825 dev->numa_node = node; 826 } 827 #else 828 static inline int dev_to_node(struct device *dev) 829 { 830 return -1; 831 } 832 static inline void set_dev_node(struct device *dev, int node) 833 { 834 } 835 #endif 836 837 static inline void *dev_get_drvdata(const struct device *dev) 838 { 839 return dev->driver_data; 840 } 841 842 static inline void dev_set_drvdata(struct device *dev, void *data) 843 { 844 dev->driver_data = data; 845 } 846 847 static inline struct pm_subsys_data *dev_to_psd(struct device *dev) 848 { 849 return dev ? dev->power.subsys_data : NULL; 850 } 851 852 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 853 { 854 return dev->kobj.uevent_suppress; 855 } 856 857 static inline void dev_set_uevent_suppress(struct device *dev, int val) 858 { 859 dev->kobj.uevent_suppress = val; 860 } 861 862 static inline int device_is_registered(struct device *dev) 863 { 864 return dev->kobj.state_in_sysfs; 865 } 866 867 static inline void device_enable_async_suspend(struct device *dev) 868 { 869 if (!dev->power.is_prepared) 870 dev->power.async_suspend = true; 871 } 872 873 static inline void device_disable_async_suspend(struct device *dev) 874 { 875 if (!dev->power.is_prepared) 876 dev->power.async_suspend = false; 877 } 878 879 static inline bool device_async_suspend_enabled(struct device *dev) 880 { 881 return !!dev->power.async_suspend; 882 } 883 884 static inline void pm_suspend_ignore_children(struct device *dev, bool enable) 885 { 886 dev->power.ignore_children = enable; 887 } 888 889 static inline void dev_pm_syscore_device(struct device *dev, bool val) 890 { 891 #ifdef CONFIG_PM_SLEEP 892 dev->power.syscore = val; 893 #endif 894 } 895 896 static inline void device_lock(struct device *dev) 897 { 898 mutex_lock(&dev->mutex); 899 } 900 901 static inline int device_trylock(struct device *dev) 902 { 903 return mutex_trylock(&dev->mutex); 904 } 905 906 static inline void device_unlock(struct device *dev) 907 { 908 mutex_unlock(&dev->mutex); 909 } 910 911 void driver_init(void); 912 913 /* 914 * High level routines for use by the bus drivers 915 */ 916 extern int __must_check device_register(struct device *dev); 917 extern void device_unregister(struct device *dev); 918 extern void device_initialize(struct device *dev); 919 extern int __must_check device_add(struct device *dev); 920 extern void device_del(struct device *dev); 921 extern int device_for_each_child(struct device *dev, void *data, 922 int (*fn)(struct device *dev, void *data)); 923 extern struct device *device_find_child(struct device *dev, void *data, 924 int (*match)(struct device *dev, void *data)); 925 extern int device_rename(struct device *dev, const char *new_name); 926 extern int device_move(struct device *dev, struct device *new_parent, 927 enum dpm_order dpm_order); 928 extern const char *device_get_devnode(struct device *dev, 929 umode_t *mode, kuid_t *uid, kgid_t *gid, 930 const char **tmp); 931 932 static inline bool device_supports_offline(struct device *dev) 933 { 934 return dev->bus && dev->bus->offline && dev->bus->online; 935 } 936 937 extern void lock_device_hotplug(void); 938 extern void unlock_device_hotplug(void); 939 extern int lock_device_hotplug_sysfs(void); 940 extern int device_offline(struct device *dev); 941 extern int device_online(struct device *dev); 942 /* 943 * Root device objects for grouping under /sys/devices 944 */ 945 extern struct device *__root_device_register(const char *name, 946 struct module *owner); 947 948 /* This is a macro to avoid include problems with THIS_MODULE */ 949 #define root_device_register(name) \ 950 __root_device_register(name, THIS_MODULE) 951 952 extern void root_device_unregister(struct device *root); 953 954 static inline void *dev_get_platdata(const struct device *dev) 955 { 956 return dev->platform_data; 957 } 958 959 /* 960 * Manual binding of a device to driver. See drivers/base/bus.c 961 * for information on use. 962 */ 963 extern int __must_check device_bind_driver(struct device *dev); 964 extern void device_release_driver(struct device *dev); 965 extern int __must_check device_attach(struct device *dev); 966 extern int __must_check driver_attach(struct device_driver *drv); 967 extern int __must_check device_reprobe(struct device *dev); 968 969 /* 970 * Easy functions for dynamically creating devices on the fly 971 */ 972 extern struct device *device_create_vargs(struct class *cls, 973 struct device *parent, 974 dev_t devt, 975 void *drvdata, 976 const char *fmt, 977 va_list vargs); 978 extern __printf(5, 6) 979 struct device *device_create(struct class *cls, struct device *parent, 980 dev_t devt, void *drvdata, 981 const char *fmt, ...); 982 extern __printf(6, 7) 983 struct device *device_create_with_groups(struct class *cls, 984 struct device *parent, dev_t devt, void *drvdata, 985 const struct attribute_group **groups, 986 const char *fmt, ...); 987 extern void device_destroy(struct class *cls, dev_t devt); 988 989 /* 990 * Platform "fixup" functions - allow the platform to have their say 991 * about devices and actions that the general device layer doesn't 992 * know about. 993 */ 994 /* Notify platform of device discovery */ 995 extern int (*platform_notify)(struct device *dev); 996 997 extern int (*platform_notify_remove)(struct device *dev); 998 999 1000 /* 1001 * get_device - atomically increment the reference count for the device. 1002 * 1003 */ 1004 extern struct device *get_device(struct device *dev); 1005 extern void put_device(struct device *dev); 1006 1007 #ifdef CONFIG_DEVTMPFS 1008 extern int devtmpfs_create_node(struct device *dev); 1009 extern int devtmpfs_delete_node(struct device *dev); 1010 extern int devtmpfs_mount(const char *mntdir); 1011 #else 1012 static inline int devtmpfs_create_node(struct device *dev) { return 0; } 1013 static inline int devtmpfs_delete_node(struct device *dev) { return 0; } 1014 static inline int devtmpfs_mount(const char *mountpoint) { return 0; } 1015 #endif 1016 1017 /* drivers/base/power/shutdown.c */ 1018 extern void device_shutdown(void); 1019 1020 /* debugging and troubleshooting/diagnostic helpers. */ 1021 extern const char *dev_driver_string(const struct device *dev); 1022 1023 1024 #ifdef CONFIG_PRINTK 1025 1026 extern __printf(3, 0) 1027 int dev_vprintk_emit(int level, const struct device *dev, 1028 const char *fmt, va_list args); 1029 extern __printf(3, 4) 1030 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...); 1031 1032 extern __printf(3, 4) 1033 int dev_printk(const char *level, const struct device *dev, 1034 const char *fmt, ...); 1035 extern __printf(2, 3) 1036 int dev_emerg(const struct device *dev, const char *fmt, ...); 1037 extern __printf(2, 3) 1038 int dev_alert(const struct device *dev, const char *fmt, ...); 1039 extern __printf(2, 3) 1040 int dev_crit(const struct device *dev, const char *fmt, ...); 1041 extern __printf(2, 3) 1042 int dev_err(const struct device *dev, const char *fmt, ...); 1043 extern __printf(2, 3) 1044 int dev_warn(const struct device *dev, const char *fmt, ...); 1045 extern __printf(2, 3) 1046 int dev_notice(const struct device *dev, const char *fmt, ...); 1047 extern __printf(2, 3) 1048 int _dev_info(const struct device *dev, const char *fmt, ...); 1049 1050 #else 1051 1052 static inline __printf(3, 0) 1053 int dev_vprintk_emit(int level, const struct device *dev, 1054 const char *fmt, va_list args) 1055 { return 0; } 1056 static inline __printf(3, 4) 1057 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 1058 { return 0; } 1059 1060 static inline int __dev_printk(const char *level, const struct device *dev, 1061 struct va_format *vaf) 1062 { return 0; } 1063 static inline __printf(3, 4) 1064 int dev_printk(const char *level, const struct device *dev, 1065 const char *fmt, ...) 1066 { return 0; } 1067 1068 static inline __printf(2, 3) 1069 int dev_emerg(const struct device *dev, const char *fmt, ...) 1070 { return 0; } 1071 static inline __printf(2, 3) 1072 int dev_crit(const struct device *dev, const char *fmt, ...) 1073 { return 0; } 1074 static inline __printf(2, 3) 1075 int dev_alert(const struct device *dev, const char *fmt, ...) 1076 { return 0; } 1077 static inline __printf(2, 3) 1078 int dev_err(const struct device *dev, const char *fmt, ...) 1079 { return 0; } 1080 static inline __printf(2, 3) 1081 int dev_warn(const struct device *dev, const char *fmt, ...) 1082 { return 0; } 1083 static inline __printf(2, 3) 1084 int dev_notice(const struct device *dev, const char *fmt, ...) 1085 { return 0; } 1086 static inline __printf(2, 3) 1087 int _dev_info(const struct device *dev, const char *fmt, ...) 1088 { return 0; } 1089 1090 #endif 1091 1092 /* 1093 * Stupid hackaround for existing uses of non-printk uses dev_info 1094 * 1095 * Note that the definition of dev_info below is actually _dev_info 1096 * and a macro is used to avoid redefining dev_info 1097 */ 1098 1099 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg) 1100 1101 #if defined(CONFIG_DYNAMIC_DEBUG) 1102 #define dev_dbg(dev, format, ...) \ 1103 do { \ 1104 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ 1105 } while (0) 1106 #elif defined(DEBUG) 1107 #define dev_dbg(dev, format, arg...) \ 1108 dev_printk(KERN_DEBUG, dev, format, ##arg) 1109 #else 1110 #define dev_dbg(dev, format, arg...) \ 1111 ({ \ 1112 if (0) \ 1113 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 1114 0; \ 1115 }) 1116 #endif 1117 1118 #define dev_level_ratelimited(dev_level, dev, fmt, ...) \ 1119 do { \ 1120 static DEFINE_RATELIMIT_STATE(_rs, \ 1121 DEFAULT_RATELIMIT_INTERVAL, \ 1122 DEFAULT_RATELIMIT_BURST); \ 1123 if (__ratelimit(&_rs)) \ 1124 dev_level(dev, fmt, ##__VA_ARGS__); \ 1125 } while (0) 1126 1127 #define dev_emerg_ratelimited(dev, fmt, ...) \ 1128 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__) 1129 #define dev_alert_ratelimited(dev, fmt, ...) \ 1130 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__) 1131 #define dev_crit_ratelimited(dev, fmt, ...) \ 1132 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__) 1133 #define dev_err_ratelimited(dev, fmt, ...) \ 1134 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__) 1135 #define dev_warn_ratelimited(dev, fmt, ...) \ 1136 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__) 1137 #define dev_notice_ratelimited(dev, fmt, ...) \ 1138 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__) 1139 #define dev_info_ratelimited(dev, fmt, ...) \ 1140 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__) 1141 #if defined(CONFIG_DYNAMIC_DEBUG) 1142 /* descriptor check is first to prevent flooding with "callbacks suppressed" */ 1143 #define dev_dbg_ratelimited(dev, fmt, ...) \ 1144 do { \ 1145 static DEFINE_RATELIMIT_STATE(_rs, \ 1146 DEFAULT_RATELIMIT_INTERVAL, \ 1147 DEFAULT_RATELIMIT_BURST); \ 1148 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \ 1149 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \ 1150 __ratelimit(&_rs)) \ 1151 __dynamic_dev_dbg(&descriptor, dev, fmt, \ 1152 ##__VA_ARGS__); \ 1153 } while (0) 1154 #elif defined(DEBUG) 1155 #define dev_dbg_ratelimited(dev, fmt, ...) \ 1156 do { \ 1157 static DEFINE_RATELIMIT_STATE(_rs, \ 1158 DEFAULT_RATELIMIT_INTERVAL, \ 1159 DEFAULT_RATELIMIT_BURST); \ 1160 if (__ratelimit(&_rs)) \ 1161 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \ 1162 } while (0) 1163 #else 1164 #define dev_dbg_ratelimited(dev, fmt, ...) \ 1165 no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) 1166 #endif 1167 1168 #ifdef VERBOSE_DEBUG 1169 #define dev_vdbg dev_dbg 1170 #else 1171 #define dev_vdbg(dev, format, arg...) \ 1172 ({ \ 1173 if (0) \ 1174 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 1175 0; \ 1176 }) 1177 #endif 1178 1179 /* 1180 * dev_WARN*() acts like dev_printk(), but with the key difference of 1181 * using WARN/WARN_ONCE to include file/line information and a backtrace. 1182 */ 1183 #define dev_WARN(dev, format, arg...) \ 1184 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg); 1185 1186 #define dev_WARN_ONCE(dev, condition, format, arg...) \ 1187 WARN_ONCE(condition, "%s %s: " format, \ 1188 dev_driver_string(dev), dev_name(dev), ## arg) 1189 1190 /* Create alias, so I can be autoloaded. */ 1191 #define MODULE_ALIAS_CHARDEV(major,minor) \ 1192 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 1193 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 1194 MODULE_ALIAS("char-major-" __stringify(major) "-*") 1195 1196 #ifdef CONFIG_SYSFS_DEPRECATED 1197 extern long sysfs_deprecated; 1198 #else 1199 #define sysfs_deprecated 0 1200 #endif 1201 1202 /** 1203 * module_driver() - Helper macro for drivers that don't do anything 1204 * special in module init/exit. This eliminates a lot of boilerplate. 1205 * Each module may only use this macro once, and calling it replaces 1206 * module_init() and module_exit(). 1207 * 1208 * @__driver: driver name 1209 * @__register: register function for this driver type 1210 * @__unregister: unregister function for this driver type 1211 * @...: Additional arguments to be passed to __register and __unregister. 1212 * 1213 * Use this macro to construct bus specific macros for registering 1214 * drivers, and do not use it on its own. 1215 */ 1216 #define module_driver(__driver, __register, __unregister, ...) \ 1217 static int __init __driver##_init(void) \ 1218 { \ 1219 return __register(&(__driver) , ##__VA_ARGS__); \ 1220 } \ 1221 module_init(__driver##_init); \ 1222 static void __exit __driver##_exit(void) \ 1223 { \ 1224 __unregister(&(__driver) , ##__VA_ARGS__); \ 1225 } \ 1226 module_exit(__driver##_exit); 1227 1228 #endif /* _DEVICE_H_ */

1 #ifndef _LINUX_LIST_H 2 #define _LINUX_LIST_H 3 4 #include <linux/types.h> 5 #include <linux/stddef.h> 6 #include <linux/poison.h> 7 #include <linux/const.h> 8 9 /* 10 * Simple doubly linked list implementation. 11 * 12 * Some of the internal functions ("__xxx") are useful when 13 * manipulating whole lists rather than single entries, as 14 * sometimes we already know the next/prev entries and we can 15 * generate better code by using them directly rather than 16 * using the generic single-entry routines. 17 */ 18 19 #define LIST_HEAD_INIT(name) { &(name), &(name) } 20 21 #define LIST_HEAD(name) \ 22 struct list_head name = LIST_HEAD_INIT(name) 23 24 static inline void INIT_LIST_HEAD(struct list_head *list) 25 { 26 list->next = list; 27 list->prev = list; 28 } 29 30 /* 31 * Insert a new entry between two known consecutive entries. 32 * 33 * This is only for internal list manipulation where we know 34 * the prev/next entries already! 35 */ 36 #ifndef CONFIG_DEBUG_LIST 37 static inline void __list_add(struct list_head *new, 38 struct list_head *prev, 39 struct list_head *next) 40 { 41 next->prev = new; 42 new->next = next; 43 new->prev = prev; 44 prev->next = new; 45 } 46 #else 47 extern void __list_add(struct list_head *new, 48 struct list_head *prev, 49 struct list_head *next); 50 #endif 51 52 /** 53 * list_add - add a new entry 54 * @new: new entry to be added 55 * @head: list head to add it after 56 * 57 * Insert a new entry after the specified head. 58 * This is good for implementing stacks. 59 */ 60 static inline void list_add(struct list_head *new, struct list_head *head) 61 { 62 __list_add(new, head, head->next); 63 } 64 65 66 /** 67 * list_add_tail - add a new entry 68 * @new: new entry to be added 69 * @head: list head to add it before 70 * 71 * Insert a new entry before the specified head. 72 * This is useful for implementing queues. 73 */ 74 static inline void list_add_tail(struct list_head *new, struct list_head *head) 75 { 76 __list_add(new, head->prev, head); 77 } 78 79 /* 80 * Delete a list entry by making the prev/next entries 81 * point to each other. 82 * 83 * This is only for internal list manipulation where we know 84 * the prev/next entries already! 85 */ 86 static inline void __list_del(struct list_head * prev, struct list_head * next) 87 { 88 next->prev = prev; 89 prev->next = next; 90 } 91 92 /** 93 * list_del - deletes entry from list. 94 * @entry: the element to delete from the list. 95 * Note: list_empty() on entry does not return true after this, the entry is 96 * in an undefined state. 97 */ 98 #ifndef CONFIG_DEBUG_LIST 99 static inline void __list_del_entry(struct list_head *entry) 100 { 101 __list_del(entry->prev, entry->next); 102 } 103 104 static inline void list_del(struct list_head *entry) 105 { 106 __list_del(entry->prev, entry->next); 107 entry->next = LIST_POISON1; 108 entry->prev = LIST_POISON2; 109 } 110 #else 111 extern void __list_del_entry(struct list_head *entry); 112 extern void list_del(struct list_head *entry); 113 #endif 114 115 /** 116 * list_replace - replace old entry by new one 117 * @old : the element to be replaced 118 * @new : the new element to insert 119 * 120 * If @old was empty, it will be overwritten. 121 */ 122 static inline void list_replace(struct list_head *old, 123 struct list_head *new) 124 { 125 new->next = old->next; 126 new->next->prev = new; 127 new->prev = old->prev; 128 new->prev->next = new; 129 } 130 131 static inline void list_replace_init(struct list_head *old, 132 struct list_head *new) 133 { 134 list_replace(old, new); 135 INIT_LIST_HEAD(old); 136 } 137 138 /** 139 * list_del_init - deletes entry from list and reinitialize it. 140 * @entry: the element to delete from the list. 141 */ 142 static inline void list_del_init(struct list_head *entry) 143 { 144 __list_del_entry(entry); 145 INIT_LIST_HEAD(entry); 146 } 147 148 /** 149 * list_move - delete from one list and add as another's head 150 * @list: the entry to move 151 * @head: the head that will precede our entry 152 */ 153 static inline void list_move(struct list_head *list, struct list_head *head) 154 { 155 __list_del_entry(list); 156 list_add(list, head); 157 } 158 159 /** 160 * list_move_tail - delete from one list and add as another's tail 161 * @list: the entry to move 162 * @head: the head that will follow our entry 163 */ 164 static inline void list_move_tail(struct list_head *list, 165 struct list_head *head) 166 { 167 __list_del_entry(list); 168 list_add_tail(list, head); 169 } 170 171 /** 172 * list_is_last - tests whether @list is the last entry in list @head 173 * @list: the entry to test 174 * @head: the head of the list 175 */ 176 static inline int list_is_last(const struct list_head *list, 177 const struct list_head *head) 178 { 179 return list->next == head; 180 } 181 182 /** 183 * list_empty - tests whether a list is empty 184 * @head: the list to test. 185 */ 186 static inline int list_empty(const struct list_head *head) 187 { 188 return head->next == head; 189 } 190 191 /** 192 * list_empty_careful - tests whether a list is empty and not being modified 193 * @head: the list to test 194 * 195 * Description: 196 * tests whether a list is empty _and_ checks that no other CPU might be 197 * in the process of modifying either member (next or prev) 198 * 199 * NOTE: using list_empty_careful() without synchronization 200 * can only be safe if the only activity that can happen 201 * to the list entry is list_del_init(). Eg. it cannot be used 202 * if another CPU could re-list_add() it. 203 */ 204 static inline int list_empty_careful(const struct list_head *head) 205 { 206 struct list_head *next = head->next; 207 return (next == head) && (next == head->prev); 208 } 209 210 /** 211 * list_rotate_left - rotate the list to the left 212 * @head: the head of the list 213 */ 214 static inline void list_rotate_left(struct list_head *head) 215 { 216 struct list_head *first; 217 218 if (!list_empty(head)) { 219 first = head->next; 220 list_move_tail(first, head); 221 } 222 } 223 224 /** 225 * list_is_singular - tests whether a list has just one entry. 226 * @head: the list to test. 227 */ 228 static inline int list_is_singular(const struct list_head *head) 229 { 230 return !list_empty(head) && (head->next == head->prev); 231 } 232 233 static inline void __list_cut_position(struct list_head *list, 234 struct list_head *head, struct list_head *entry) 235 { 236 struct list_head *new_first = entry->next; 237 list->next = head->next; 238 list->next->prev = list; 239 list->prev = entry; 240 entry->next = list; 241 head->next = new_first; 242 new_first->prev = head; 243 } 244 245 /** 246 * list_cut_position - cut a list into two 247 * @list: a new list to add all removed entries 248 * @head: a list with entries 249 * @entry: an entry within head, could be the head itself 250 * and if so we won't cut the list 251 * 252 * This helper moves the initial part of @head, up to and 253 * including @entry, from @head to @list. You should 254 * pass on @entry an element you know is on @head. @list 255 * should be an empty list or a list you do not care about 256 * losing its data. 257 * 258 */ 259 static inline void list_cut_position(struct list_head *list, 260 struct list_head *head, struct list_head *entry) 261 { 262 if (list_empty(head)) 263 return; 264 if (list_is_singular(head) && 265 (head->next != entry && head != entry)) 266 return; 267 if (entry == head) 268 INIT_LIST_HEAD(list); 269 else 270 __list_cut_position(list, head, entry); 271 } 272 273 static inline void __list_splice(const struct list_head *list, 274 struct list_head *prev, 275 struct list_head *next) 276 { 277 struct list_head *first = list->next; 278 struct list_head *last = list->prev; 279 280 first->prev = prev; 281 prev->next = first; 282 283 last->next = next; 284 next->prev = last; 285 } 286 287 /** 288 * list_splice - join two lists, this is designed for stacks 289 * @list: the new list to add. 290 * @head: the place to add it in the first list. 291 */ 292 static inline void list_splice(const struct list_head *list, 293 struct list_head *head) 294 { 295 if (!list_empty(list)) 296 __list_splice(list, head, head->next); 297 } 298 299 /** 300 * list_splice_tail - join two lists, each list being a queue 301 * @list: the new list to add. 302 * @head: the place to add it in the first list. 303 */ 304 static inline void list_splice_tail(struct list_head *list, 305 struct list_head *head) 306 { 307 if (!list_empty(list)) 308 __list_splice(list, head->prev, head); 309 } 310 311 /** 312 * list_splice_init - join two lists and reinitialise the emptied list. 313 * @list: the new list to add. 314 * @head: the place to add it in the first list. 315 * 316 * The list at @list is reinitialised 317 */ 318 static inline void list_splice_init(struct list_head *list, 319 struct list_head *head) 320 { 321 if (!list_empty(list)) { 322 __list_splice(list, head, head->next); 323 INIT_LIST_HEAD(list); 324 } 325 } 326 327 /** 328 * list_splice_tail_init - join two lists and reinitialise the emptied list 329 * @list: the new list to add. 330 * @head: the place to add it in the first list. 331 * 332 * Each of the lists is a queue. 333 * The list at @list is reinitialised 334 */ 335 static inline void list_splice_tail_init(struct list_head *list, 336 struct list_head *head) 337 { 338 if (!list_empty(list)) { 339 __list_splice(list, head->prev, head); 340 INIT_LIST_HEAD(list); 341 } 342 } 343 344 /** 345 * list_entry - get the struct for this entry 346 * @ptr: the &struct list_head pointer. 347 * @type: the type of the struct this is embedded in. 348 * @member: the name of the list_struct within the struct. 349 */ 350 #define list_entry(ptr, type, member) \ 351 container_of(ptr, type, member) 352 353 /** 354 * list_first_entry - get the first element from a list 355 * @ptr: the list head to take the element from. 356 * @type: the type of the struct this is embedded in. 357 * @member: the name of the list_struct within the struct. 358 * 359 * Note, that list is expected to be not empty. 360 */ 361 #define list_first_entry(ptr, type, member) \ 362 list_entry((ptr)->next, type, member) 363 364 /** 365 * list_last_entry - get the last element from a list 366 * @ptr: the list head to take the element from. 367 * @type: the type of the struct this is embedded in. 368 * @member: the name of the list_struct within the struct. 369 * 370 * Note, that list is expected to be not empty. 371 */ 372 #define list_last_entry(ptr, type, member) \ 373 list_entry((ptr)->prev, type, member) 374 375 /** 376 * list_first_entry_or_null - get the first element from a list 377 * @ptr: the list head to take the element from. 378 * @type: the type of the struct this is embedded in. 379 * @member: the name of the list_struct within the struct. 380 * 381 * Note that if the list is empty, it returns NULL. 382 */ 383 #define list_first_entry_or_null(ptr, type, member) \ 384 (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL) 385 386 /** 387 * list_next_entry - get the next element in list 388 * @pos: the type * to cursor 389 * @member: the name of the list_struct within the struct. 390 */ 391 #define list_next_entry(pos, member) \ 392 list_entry((pos)->member.next, typeof(*(pos)), member) 393 394 /** 395 * list_prev_entry - get the prev element in list 396 * @pos: the type * to cursor 397 * @member: the name of the list_struct within the struct. 398 */ 399 #define list_prev_entry(pos, member) \ 400 list_entry((pos)->member.prev, typeof(*(pos)), member) 401 402 /** 403 * list_for_each - iterate over a list 404 * @pos: the &struct list_head to use as a loop cursor. 405 * @head: the head for your list. 406 */ 407 #define list_for_each(pos, head) \ 408 for (pos = (head)->next; pos != (head); pos = pos->next) 409 410 /** 411 * list_for_each_prev - iterate over a list backwards 412 * @pos: the &struct list_head to use as a loop cursor. 413 * @head: the head for your list. 414 */ 415 #define list_for_each_prev(pos, head) \ 416 for (pos = (head)->prev; pos != (head); pos = pos->prev) 417 418 /** 419 * list_for_each_safe - iterate over a list safe against removal of list entry 420 * @pos: the &struct list_head to use as a loop cursor. 421 * @n: another &struct list_head to use as temporary storage 422 * @head: the head for your list. 423 */ 424 #define list_for_each_safe(pos, n, head) \ 425 for (pos = (head)->next, n = pos->next; pos != (head); \ 426 pos = n, n = pos->next) 427 428 /** 429 * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry 430 * @pos: the &struct list_head to use as a loop cursor. 431 * @n: another &struct list_head to use as temporary storage 432 * @head: the head for your list. 433 */ 434 #define list_for_each_prev_safe(pos, n, head) \ 435 for (pos = (head)->prev, n = pos->prev; \ 436 pos != (head); \ 437 pos = n, n = pos->prev) 438 439 /** 440 * list_for_each_entry - iterate over list of given type 441 * @pos: the type * to use as a loop cursor. 442 * @head: the head for your list. 443 * @member: the name of the list_struct within the struct. 444 */ 445 #define list_for_each_entry(pos, head, member) \ 446 for (pos = list_first_entry(head, typeof(*pos), member); \ 447 &pos->member != (head); \ 448 pos = list_next_entry(pos, member)) 449 450 /** 451 * list_for_each_entry_reverse - iterate backwards over list of given type. 452 * @pos: the type * to use as a loop cursor. 453 * @head: the head for your list. 454 * @member: the name of the list_struct within the struct. 455 */ 456 #define list_for_each_entry_reverse(pos, head, member) \ 457 for (pos = list_last_entry(head, typeof(*pos), member); \ 458 &pos->member != (head); \ 459 pos = list_prev_entry(pos, member)) 460 461 /** 462 * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue() 463 * @pos: the type * to use as a start point 464 * @head: the head of the list 465 * @member: the name of the list_struct within the struct. 466 * 467 * Prepares a pos entry for use as a start point in list_for_each_entry_continue(). 468 */ 469 #define list_prepare_entry(pos, head, member) \ 470 ((pos) ? : list_entry(head, typeof(*pos), member)) 471 472 /** 473 * list_for_each_entry_continue - continue iteration over list of given type 474 * @pos: the type * to use as a loop cursor. 475 * @head: the head for your list. 476 * @member: the name of the list_struct within the struct. 477 * 478 * Continue to iterate over list of given type, continuing after 479 * the current position. 480 */ 481 #define list_for_each_entry_continue(pos, head, member) \ 482 for (pos = list_next_entry(pos, member); \ 483 &pos->member != (head); \ 484 pos = list_next_entry(pos, member)) 485 486 /** 487 * list_for_each_entry_continue_reverse - iterate backwards from the given point 488 * @pos: the type * to use as a loop cursor. 489 * @head: the head for your list. 490 * @member: the name of the list_struct within the struct. 491 * 492 * Start to iterate over list of given type backwards, continuing after 493 * the current position. 494 */ 495 #define list_for_each_entry_continue_reverse(pos, head, member) \ 496 for (pos = list_prev_entry(pos, member); \ 497 &pos->member != (head); \ 498 pos = list_prev_entry(pos, member)) 499 500 /** 501 * list_for_each_entry_from - iterate over list of given type from the current point 502 * @pos: the type * to use as a loop cursor. 503 * @head: the head for your list. 504 * @member: the name of the list_struct within the struct. 505 * 506 * Iterate over list of given type, continuing from current position. 507 */ 508 #define list_for_each_entry_from(pos, head, member) \ 509 for (; &pos->member != (head); \ 510 pos = list_next_entry(pos, member)) 511 512 /** 513 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry 514 * @pos: the type * to use as a loop cursor. 515 * @n: another type * to use as temporary storage 516 * @head: the head for your list. 517 * @member: the name of the list_struct within the struct. 518 */ 519 #define list_for_each_entry_safe(pos, n, head, member) \ 520 for (pos = list_first_entry(head, typeof(*pos), member), \ 521 n = list_next_entry(pos, member); \ 522 &pos->member != (head); \ 523 pos = n, n = list_next_entry(n, member)) 524 525 /** 526 * list_for_each_entry_safe_continue - continue list iteration safe against removal 527 * @pos: the type * to use as a loop cursor. 528 * @n: another type * to use as temporary storage 529 * @head: the head for your list. 530 * @member: the name of the list_struct within the struct. 531 * 532 * Iterate over list of given type, continuing after current point, 533 * safe against removal of list entry. 534 */ 535 #define list_for_each_entry_safe_continue(pos, n, head, member) \ 536 for (pos = list_next_entry(pos, member), \ 537 n = list_next_entry(pos, member); \ 538 &pos->member != (head); \ 539 pos = n, n = list_next_entry(n, member)) 540 541 /** 542 * list_for_each_entry_safe_from - iterate over list from current point safe against removal 543 * @pos: the type * to use as a loop cursor. 544 * @n: another type * to use as temporary storage 545 * @head: the head for your list. 546 * @member: the name of the list_struct within the struct. 547 * 548 * Iterate over list of given type from current point, safe against 549 * removal of list entry. 550 */ 551 #define list_for_each_entry_safe_from(pos, n, head, member) \ 552 for (n = list_next_entry(pos, member); \ 553 &pos->member != (head); \ 554 pos = n, n = list_next_entry(n, member)) 555 556 /** 557 * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal 558 * @pos: the type * to use as a loop cursor. 559 * @n: another type * to use as temporary storage 560 * @head: the head for your list. 561 * @member: the name of the list_struct within the struct. 562 * 563 * Iterate backwards over list of given type, safe against removal 564 * of list entry. 565 */ 566 #define list_for_each_entry_safe_reverse(pos, n, head, member) \ 567 for (pos = list_last_entry(head, typeof(*pos), member), \ 568 n = list_prev_entry(pos, member); \ 569 &pos->member != (head); \ 570 pos = n, n = list_prev_entry(n, member)) 571 572 /** 573 * list_safe_reset_next - reset a stale list_for_each_entry_safe loop 574 * @pos: the loop cursor used in the list_for_each_entry_safe loop 575 * @n: temporary storage used in list_for_each_entry_safe 576 * @member: the name of the list_struct within the struct. 577 * 578 * list_safe_reset_next is not safe to use in general if the list may be 579 * modified concurrently (eg. the lock is dropped in the loop body). An 580 * exception to this is if the cursor element (pos) is pinned in the list, 581 * and list_safe_reset_next is called after re-taking the lock and before 582 * completing the current iteration of the loop body. 583 */ 584 #define list_safe_reset_next(pos, n, member) \ 585 n = list_next_entry(pos, member) 586 587 /* 588 * Double linked lists with a single pointer list head. 589 * Mostly useful for hash tables where the two pointer list head is 590 * too wasteful. 591 * You lose the ability to access the tail in O(1). 592 */ 593 594 #define HLIST_HEAD_INIT { .first = NULL } 595 #define HLIST_HEAD(name) struct hlist_head name = { .first = NULL } 596 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) 597 static inline void INIT_HLIST_NODE(struct hlist_node *h) 598 { 599 h->next = NULL; 600 h->pprev = NULL; 601 } 602 603 static inline int hlist_unhashed(const struct hlist_node *h) 604 { 605 return !h->pprev; 606 } 607 608 static inline int hlist_empty(const struct hlist_head *h) 609 { 610 return !h->first; 611 } 612 613 static inline void __hlist_del(struct hlist_node *n) 614 { 615 struct hlist_node *next = n->next; 616 struct hlist_node **pprev = n->pprev; 617 *pprev = next; 618 if (next) 619 next->pprev = pprev; 620 } 621 622 static inline void hlist_del(struct hlist_node *n) 623 { 624 __hlist_del(n); 625 n->next = LIST_POISON1; 626 n->pprev = LIST_POISON2; 627 } 628 629 static inline void hlist_del_init(struct hlist_node *n) 630 { 631 if (!hlist_unhashed(n)) { 632 __hlist_del(n); 633 INIT_HLIST_NODE(n); 634 } 635 } 636 637 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h) 638 { 639 struct hlist_node *first = h->first; 640 n->next = first; 641 if (first) 642 first->pprev = &n->next; 643 h->first = n; 644 n->pprev = &h->first; 645 } 646 647 /* next must be != NULL */ 648 static inline void hlist_add_before(struct hlist_node *n, 649 struct hlist_node *next) 650 { 651 n->pprev = next->pprev; 652 n->next = next; 653 next->pprev = &n->next; 654 *(n->pprev) = n; 655 } 656 657 static inline void hlist_add_after(struct hlist_node *n, 658 struct hlist_node *next) 659 { 660 next->next = n->next; 661 n->next = next; 662 next->pprev = &n->next; 663 664 if(next->next) 665 next->next->pprev = &next->next; 666 } 667 668 /* after that we'll appear to be on some hlist and hlist_del will work */ 669 static inline void hlist_add_fake(struct hlist_node *n) 670 { 671 n->pprev = &n->next; 672 } 673 674 /* 675 * Move a list from one list head to another. Fixup the pprev 676 * reference of the first entry if it exists. 677 */ 678 static inline void hlist_move_list(struct hlist_head *old, 679 struct hlist_head *new) 680 { 681 new->first = old->first; 682 if (new->first) 683 new->first->pprev = &new->first; 684 old->first = NULL; 685 } 686 687 #define hlist_entry(ptr, type, member) container_of(ptr,type,member) 688 689 #define hlist_for_each(pos, head) \ 690 for (pos = (head)->first; pos ; pos = pos->next) 691 692 #define hlist_for_each_safe(pos, n, head) \ 693 for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \ 694 pos = n) 695 696 #define hlist_entry_safe(ptr, type, member) \ 697 ({ typeof(ptr) ____ptr = (ptr); \ 698 ____ptr ? hlist_entry(____ptr, type, member) : NULL; \ 699 }) 700 701 /** 702 * hlist_for_each_entry - iterate over list of given type 703 * @pos: the type * to use as a loop cursor. 704 * @head: the head for your list. 705 * @member: the name of the hlist_node within the struct. 706 */ 707 #define hlist_for_each_entry(pos, head, member) \ 708 for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\ 709 pos; \ 710 pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) 711 712 /** 713 * hlist_for_each_entry_continue - iterate over a hlist continuing after current point 714 * @pos: the type * to use as a loop cursor. 715 * @member: the name of the hlist_node within the struct. 716 */ 717 #define hlist_for_each_entry_continue(pos, member) \ 718 for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\ 719 pos; \ 720 pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) 721 722 /** 723 * hlist_for_each_entry_from - iterate over a hlist continuing from current point 724 * @pos: the type * to use as a loop cursor. 725 * @member: the name of the hlist_node within the struct. 726 */ 727 #define hlist_for_each_entry_from(pos, member) \ 728 for (; pos; \ 729 pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) 730 731 /** 732 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry 733 * @pos: the type * to use as a loop cursor. 734 * @n: another &struct hlist_node to use as temporary storage 735 * @head: the head for your list. 736 * @member: the name of the hlist_node within the struct. 737 */ 738 #define hlist_for_each_entry_safe(pos, n, head, member) \ 739 for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\ 740 pos && ({ n = pos->member.next; 1; }); \ 741 pos = hlist_entry_safe(n, typeof(*pos), member)) 742 743 #endif

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