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