Root/
1 | /* |
2 | * Linux WiMAX |
3 | * Initialization, addition and removal of wimax devices |
4 | * |
5 | * |
6 | * Copyright (C) 2005-2006 Intel Corporation <linux-wimax@intel.com> |
7 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> |
8 | * |
9 | * This program is free software; you can redistribute it and/or |
10 | * modify it under the terms of the GNU General Public License version |
11 | * 2 as published by the Free Software Foundation. |
12 | * |
13 | * This program is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 | * GNU General Public License for more details. |
17 | * |
18 | * You should have received a copy of the GNU General Public License |
19 | * along with this program; if not, write to the Free Software |
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
21 | * 02110-1301, USA. |
22 | * |
23 | * |
24 | * This implements: |
25 | * |
26 | * - basic life cycle of 'struct wimax_dev' [wimax_dev_*()]; on |
27 | * addition/registration initialize all subfields and allocate |
28 | * generic netlink resources for user space communication. On |
29 | * removal/unregistration, undo all that. |
30 | * |
31 | * - device state machine [wimax_state_change()] and support to send |
32 | * reports to user space when the state changes |
33 | * [wimax_gnl_re_state_change*()]. |
34 | * |
35 | * See include/net/wimax.h for rationales and design. |
36 | * |
37 | * ROADMAP |
38 | * |
39 | * [__]wimax_state_change() Called by drivers to update device's state |
40 | * wimax_gnl_re_state_change_alloc() |
41 | * wimax_gnl_re_state_change_send() |
42 | * |
43 | * wimax_dev_init() Init a device |
44 | * wimax_dev_add() Register |
45 | * wimax_rfkill_add() |
46 | * wimax_gnl_add() Register all the generic netlink resources. |
47 | * wimax_id_table_add() |
48 | * wimax_dev_rm() Unregister |
49 | * wimax_id_table_rm() |
50 | * wimax_gnl_rm() |
51 | * wimax_rfkill_rm() |
52 | */ |
53 | #include <linux/device.h> |
54 | #include <linux/gfp.h> |
55 | #include <net/genetlink.h> |
56 | #include <linux/netdevice.h> |
57 | #include <linux/wimax.h> |
58 | #include "wimax-internal.h" |
59 | |
60 | |
61 | #define D_SUBMODULE stack |
62 | #include "debug-levels.h" |
63 | |
64 | static char wimax_debug_params[128]; |
65 | module_param_string(debug, wimax_debug_params, sizeof(wimax_debug_params), |
66 | 0644); |
67 | MODULE_PARM_DESC(debug, |
68 | "String of space-separated NAME:VALUE pairs, where NAMEs " |
69 | "are the different debug submodules and VALUE are the " |
70 | "initial debug value to set."); |
71 | |
72 | /* |
73 | * Authoritative source for the RE_STATE_CHANGE attribute policy |
74 | * |
75 | * We don't really use it here, but /me likes to keep the definition |
76 | * close to where the data is generated. |
77 | */ |
78 | /* |
79 | static const struct nla_policy wimax_gnl_re_status_change[WIMAX_GNL_ATTR_MAX + 1] = { |
80 | [WIMAX_GNL_STCH_STATE_OLD] = { .type = NLA_U8 }, |
81 | [WIMAX_GNL_STCH_STATE_NEW] = { .type = NLA_U8 }, |
82 | }; |
83 | */ |
84 | |
85 | |
86 | /* |
87 | * Allocate a Report State Change message |
88 | * |
89 | * @header: save it, you need it for _send() |
90 | * |
91 | * Creates and fills a basic state change message; different code |
92 | * paths can then add more attributes to the message as needed. |
93 | * |
94 | * Use wimax_gnl_re_state_change_send() to send the returned skb. |
95 | * |
96 | * Returns: skb with the genl message if ok, IS_ERR() ptr on error |
97 | * with an errno code. |
98 | */ |
99 | static |
100 | struct sk_buff *wimax_gnl_re_state_change_alloc( |
101 | struct wimax_dev *wimax_dev, |
102 | enum wimax_st new_state, enum wimax_st old_state, |
103 | void **header) |
104 | { |
105 | int result; |
106 | struct device *dev = wimax_dev_to_dev(wimax_dev); |
107 | void *data; |
108 | struct sk_buff *report_skb; |
109 | |
110 | d_fnstart(3, dev, "(wimax_dev %p new_state %u old_state %u)\n", |
111 | wimax_dev, new_state, old_state); |
112 | result = -ENOMEM; |
113 | report_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); |
114 | if (report_skb == NULL) { |
115 | dev_err(dev, "RE_STCH: can't create message\n"); |
116 | goto error_new; |
117 | } |
118 | data = genlmsg_put(report_skb, 0, wimax_gnl_mcg.id, &wimax_gnl_family, |
119 | 0, WIMAX_GNL_RE_STATE_CHANGE); |
120 | if (data == NULL) { |
121 | dev_err(dev, "RE_STCH: can't put data into message\n"); |
122 | goto error_put; |
123 | } |
124 | *header = data; |
125 | |
126 | result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_OLD, old_state); |
127 | if (result < 0) { |
128 | dev_err(dev, "RE_STCH: Error adding OLD attr: %d\n", result); |
129 | goto error_put; |
130 | } |
131 | result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_NEW, new_state); |
132 | if (result < 0) { |
133 | dev_err(dev, "RE_STCH: Error adding NEW attr: %d\n", result); |
134 | goto error_put; |
135 | } |
136 | result = nla_put_u32(report_skb, WIMAX_GNL_STCH_IFIDX, |
137 | wimax_dev->net_dev->ifindex); |
138 | if (result < 0) { |
139 | dev_err(dev, "RE_STCH: Error adding IFINDEX attribute\n"); |
140 | goto error_put; |
141 | } |
142 | d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %p\n", |
143 | wimax_dev, new_state, old_state, report_skb); |
144 | return report_skb; |
145 | |
146 | error_put: |
147 | nlmsg_free(report_skb); |
148 | error_new: |
149 | d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %d\n", |
150 | wimax_dev, new_state, old_state, result); |
151 | return ERR_PTR(result); |
152 | } |
153 | |
154 | |
155 | /* |
156 | * Send a Report State Change message (as created with _alloc). |
157 | * |
158 | * @report_skb: as returned by wimax_gnl_re_state_change_alloc() |
159 | * @header: as returned by wimax_gnl_re_state_change_alloc() |
160 | * |
161 | * Returns: 0 if ok, < 0 errno code on error. |
162 | * |
163 | * If the message is NULL, pretend it didn't happen. |
164 | */ |
165 | static |
166 | int wimax_gnl_re_state_change_send( |
167 | struct wimax_dev *wimax_dev, struct sk_buff *report_skb, |
168 | void *header) |
169 | { |
170 | int result = 0; |
171 | struct device *dev = wimax_dev_to_dev(wimax_dev); |
172 | d_fnstart(3, dev, "(wimax_dev %p report_skb %p)\n", |
173 | wimax_dev, report_skb); |
174 | if (report_skb == NULL) { |
175 | result = -ENOMEM; |
176 | goto out; |
177 | } |
178 | genlmsg_end(report_skb, header); |
179 | genlmsg_multicast(report_skb, 0, wimax_gnl_mcg.id, GFP_KERNEL); |
180 | out: |
181 | d_fnend(3, dev, "(wimax_dev %p report_skb %p) = %d\n", |
182 | wimax_dev, report_skb, result); |
183 | return result; |
184 | } |
185 | |
186 | |
187 | static |
188 | void __check_new_state(enum wimax_st old_state, enum wimax_st new_state, |
189 | unsigned allowed_states_bm) |
190 | { |
191 | if (WARN_ON(((1 << new_state) & allowed_states_bm) == 0)) { |
192 | printk(KERN_ERR "SW BUG! Forbidden state change %u -> %u\n", |
193 | old_state, new_state); |
194 | } |
195 | } |
196 | |
197 | |
198 | /* |
199 | * Set the current state of a WiMAX device [unlocking version of |
200 | * wimax_state_change(). |
201 | */ |
202 | void __wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state) |
203 | { |
204 | struct device *dev = wimax_dev_to_dev(wimax_dev); |
205 | enum wimax_st old_state = wimax_dev->state; |
206 | struct sk_buff *stch_skb; |
207 | void *header; |
208 | |
209 | d_fnstart(3, dev, "(wimax_dev %p new_state %u [old %u])\n", |
210 | wimax_dev, new_state, old_state); |
211 | |
212 | if (WARN_ON(new_state >= __WIMAX_ST_INVALID)) { |
213 | dev_err(dev, "SW BUG: requesting invalid state %u\n", |
214 | new_state); |
215 | goto out; |
216 | } |
217 | if (old_state == new_state) |
218 | goto out; |
219 | header = NULL; /* gcc complains? can't grok why */ |
220 | stch_skb = wimax_gnl_re_state_change_alloc( |
221 | wimax_dev, new_state, old_state, &header); |
222 | |
223 | /* Verify the state transition and do exit-from-state actions */ |
224 | switch (old_state) { |
225 | case __WIMAX_ST_NULL: |
226 | __check_new_state(old_state, new_state, |
227 | 1 << WIMAX_ST_DOWN); |
228 | break; |
229 | case WIMAX_ST_DOWN: |
230 | __check_new_state(old_state, new_state, |
231 | 1 << __WIMAX_ST_QUIESCING |
232 | | 1 << WIMAX_ST_UNINITIALIZED |
233 | | 1 << WIMAX_ST_RADIO_OFF); |
234 | break; |
235 | case __WIMAX_ST_QUIESCING: |
236 | __check_new_state(old_state, new_state, 1 << WIMAX_ST_DOWN); |
237 | break; |
238 | case WIMAX_ST_UNINITIALIZED: |
239 | __check_new_state(old_state, new_state, |
240 | 1 << __WIMAX_ST_QUIESCING |
241 | | 1 << WIMAX_ST_RADIO_OFF); |
242 | break; |
243 | case WIMAX_ST_RADIO_OFF: |
244 | __check_new_state(old_state, new_state, |
245 | 1 << __WIMAX_ST_QUIESCING |
246 | | 1 << WIMAX_ST_READY); |
247 | break; |
248 | case WIMAX_ST_READY: |
249 | __check_new_state(old_state, new_state, |
250 | 1 << __WIMAX_ST_QUIESCING |
251 | | 1 << WIMAX_ST_RADIO_OFF |
252 | | 1 << WIMAX_ST_SCANNING |
253 | | 1 << WIMAX_ST_CONNECTING |
254 | | 1 << WIMAX_ST_CONNECTED); |
255 | break; |
256 | case WIMAX_ST_SCANNING: |
257 | __check_new_state(old_state, new_state, |
258 | 1 << __WIMAX_ST_QUIESCING |
259 | | 1 << WIMAX_ST_RADIO_OFF |
260 | | 1 << WIMAX_ST_READY |
261 | | 1 << WIMAX_ST_CONNECTING |
262 | | 1 << WIMAX_ST_CONNECTED); |
263 | break; |
264 | case WIMAX_ST_CONNECTING: |
265 | __check_new_state(old_state, new_state, |
266 | 1 << __WIMAX_ST_QUIESCING |
267 | | 1 << WIMAX_ST_RADIO_OFF |
268 | | 1 << WIMAX_ST_READY |
269 | | 1 << WIMAX_ST_SCANNING |
270 | | 1 << WIMAX_ST_CONNECTED); |
271 | break; |
272 | case WIMAX_ST_CONNECTED: |
273 | __check_new_state(old_state, new_state, |
274 | 1 << __WIMAX_ST_QUIESCING |
275 | | 1 << WIMAX_ST_RADIO_OFF |
276 | | 1 << WIMAX_ST_READY); |
277 | netif_tx_disable(wimax_dev->net_dev); |
278 | netif_carrier_off(wimax_dev->net_dev); |
279 | break; |
280 | case __WIMAX_ST_INVALID: |
281 | default: |
282 | dev_err(dev, "SW BUG: wimax_dev %p is in unknown state %u\n", |
283 | wimax_dev, wimax_dev->state); |
284 | WARN_ON(1); |
285 | goto out; |
286 | } |
287 | |
288 | /* Execute the actions of entry to the new state */ |
289 | switch (new_state) { |
290 | case __WIMAX_ST_NULL: |
291 | dev_err(dev, "SW BUG: wimax_dev %p entering NULL state " |
292 | "from %u\n", wimax_dev, wimax_dev->state); |
293 | WARN_ON(1); /* Nobody can enter this state */ |
294 | break; |
295 | case WIMAX_ST_DOWN: |
296 | break; |
297 | case __WIMAX_ST_QUIESCING: |
298 | break; |
299 | case WIMAX_ST_UNINITIALIZED: |
300 | break; |
301 | case WIMAX_ST_RADIO_OFF: |
302 | break; |
303 | case WIMAX_ST_READY: |
304 | break; |
305 | case WIMAX_ST_SCANNING: |
306 | break; |
307 | case WIMAX_ST_CONNECTING: |
308 | break; |
309 | case WIMAX_ST_CONNECTED: |
310 | netif_carrier_on(wimax_dev->net_dev); |
311 | netif_wake_queue(wimax_dev->net_dev); |
312 | break; |
313 | case __WIMAX_ST_INVALID: |
314 | default: |
315 | BUG(); |
316 | } |
317 | __wimax_state_set(wimax_dev, new_state); |
318 | if (stch_skb) |
319 | wimax_gnl_re_state_change_send(wimax_dev, stch_skb, header); |
320 | out: |
321 | d_fnend(3, dev, "(wimax_dev %p new_state %u [old %u]) = void\n", |
322 | wimax_dev, new_state, old_state); |
323 | return; |
324 | } |
325 | |
326 | |
327 | /** |
328 | * wimax_state_change - Set the current state of a WiMAX device |
329 | * |
330 | * @wimax_dev: WiMAX device descriptor (properly referenced) |
331 | * @new_state: New state to switch to |
332 | * |
333 | * This implements the state changes for the wimax devices. It will |
334 | * |
335 | * - verify that the state transition is legal (for now it'll just |
336 | * print a warning if not) according to the table in |
337 | * linux/wimax.h's documentation for 'enum wimax_st'. |
338 | * |
339 | * - perform the actions needed for leaving the current state and |
340 | * whichever are needed for entering the new state. |
341 | * |
342 | * - issue a report to user space indicating the new state (and an |
343 | * optional payload with information about the new state). |
344 | * |
345 | * NOTE: @wimax_dev must be locked |
346 | */ |
347 | void wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state) |
348 | { |
349 | /* |
350 | * A driver cannot take the wimax_dev out of the |
351 | * __WIMAX_ST_NULL state unless by calling wimax_dev_add(). If |
352 | * the wimax_dev's state is still NULL, we ignore any request |
353 | * to change its state because it means it hasn't been yet |
354 | * registered. |
355 | * |
356 | * There is no need to complain about it, as routines that |
357 | * call this might be shared from different code paths that |
358 | * are called before or after wimax_dev_add() has done its |
359 | * job. |
360 | */ |
361 | mutex_lock(&wimax_dev->mutex); |
362 | if (wimax_dev->state > __WIMAX_ST_NULL) |
363 | __wimax_state_change(wimax_dev, new_state); |
364 | mutex_unlock(&wimax_dev->mutex); |
365 | return; |
366 | } |
367 | EXPORT_SYMBOL_GPL(wimax_state_change); |
368 | |
369 | |
370 | /** |
371 | * wimax_state_get() - Return the current state of a WiMAX device |
372 | * |
373 | * @wimax_dev: WiMAX device descriptor |
374 | * |
375 | * Returns: Current state of the device according to its driver. |
376 | */ |
377 | enum wimax_st wimax_state_get(struct wimax_dev *wimax_dev) |
378 | { |
379 | enum wimax_st state; |
380 | mutex_lock(&wimax_dev->mutex); |
381 | state = wimax_dev->state; |
382 | mutex_unlock(&wimax_dev->mutex); |
383 | return state; |
384 | } |
385 | EXPORT_SYMBOL_GPL(wimax_state_get); |
386 | |
387 | |
388 | /** |
389 | * wimax_dev_init - initialize a newly allocated instance |
390 | * |
391 | * @wimax_dev: WiMAX device descriptor to initialize. |
392 | * |
393 | * Initializes fields of a freshly allocated @wimax_dev instance. This |
394 | * function assumes that after allocation, the memory occupied by |
395 | * @wimax_dev was zeroed. |
396 | */ |
397 | void wimax_dev_init(struct wimax_dev *wimax_dev) |
398 | { |
399 | INIT_LIST_HEAD(&wimax_dev->id_table_node); |
400 | __wimax_state_set(wimax_dev, __WIMAX_ST_NULL); |
401 | mutex_init(&wimax_dev->mutex); |
402 | mutex_init(&wimax_dev->mutex_reset); |
403 | } |
404 | EXPORT_SYMBOL_GPL(wimax_dev_init); |
405 | |
406 | /* |
407 | * This extern is declared here because it's easier to keep track -- |
408 | * both declarations are a list of the same |
409 | */ |
410 | extern struct genl_ops |
411 | wimax_gnl_msg_from_user, |
412 | wimax_gnl_reset, |
413 | wimax_gnl_rfkill, |
414 | wimax_gnl_state_get; |
415 | |
416 | static |
417 | struct genl_ops *wimax_gnl_ops[] = { |
418 | &wimax_gnl_msg_from_user, |
419 | &wimax_gnl_reset, |
420 | &wimax_gnl_rfkill, |
421 | &wimax_gnl_state_get, |
422 | }; |
423 | |
424 | |
425 | static |
426 | size_t wimax_addr_scnprint(char *addr_str, size_t addr_str_size, |
427 | unsigned char *addr, size_t addr_len) |
428 | { |
429 | unsigned cnt, total; |
430 | for (total = cnt = 0; cnt < addr_len; cnt++) |
431 | total += scnprintf(addr_str + total, addr_str_size - total, |
432 | "%02x%c", addr[cnt], |
433 | cnt == addr_len - 1 ? '\0' : ':'); |
434 | return total; |
435 | } |
436 | |
437 | |
438 | /** |
439 | * wimax_dev_add - Register a new WiMAX device |
440 | * |
441 | * @wimax_dev: WiMAX device descriptor (as embedded in your @net_dev's |
442 | * priv data). You must have called wimax_dev_init() on it before. |
443 | * |
444 | * @net_dev: net device the @wimax_dev is associated with. The |
445 | * function expects SET_NETDEV_DEV() and register_netdev() were |
446 | * already called on it. |
447 | * |
448 | * Registers the new WiMAX device, sets up the user-kernel control |
449 | * interface (generic netlink) and common WiMAX infrastructure. |
450 | * |
451 | * Note that the parts that will allow interaction with user space are |
452 | * setup at the very end, when the rest is in place, as once that |
453 | * happens, the driver might get user space control requests via |
454 | * netlink or from debugfs that might translate into calls into |
455 | * wimax_dev->op_*(). |
456 | */ |
457 | int wimax_dev_add(struct wimax_dev *wimax_dev, struct net_device *net_dev) |
458 | { |
459 | int result; |
460 | struct device *dev = net_dev->dev.parent; |
461 | char addr_str[32]; |
462 | |
463 | d_fnstart(3, dev, "(wimax_dev %p net_dev %p)\n", wimax_dev, net_dev); |
464 | |
465 | /* Do the RFKILL setup before locking, as RFKILL will call |
466 | * into our functions. */ |
467 | wimax_dev->net_dev = net_dev; |
468 | result = wimax_rfkill_add(wimax_dev); |
469 | if (result < 0) |
470 | goto error_rfkill_add; |
471 | |
472 | /* Set up user-space interaction */ |
473 | mutex_lock(&wimax_dev->mutex); |
474 | wimax_id_table_add(wimax_dev); |
475 | result = wimax_debugfs_add(wimax_dev); |
476 | if (result < 0) { |
477 | dev_err(dev, "cannot initialize debugfs: %d\n", |
478 | result); |
479 | goto error_debugfs_add; |
480 | } |
481 | |
482 | __wimax_state_set(wimax_dev, WIMAX_ST_DOWN); |
483 | mutex_unlock(&wimax_dev->mutex); |
484 | |
485 | wimax_addr_scnprint(addr_str, sizeof(addr_str), |
486 | net_dev->dev_addr, net_dev->addr_len); |
487 | dev_err(dev, "WiMAX interface %s (%s) ready\n", |
488 | net_dev->name, addr_str); |
489 | d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev); |
490 | return 0; |
491 | |
492 | error_debugfs_add: |
493 | wimax_id_table_rm(wimax_dev); |
494 | mutex_unlock(&wimax_dev->mutex); |
495 | wimax_rfkill_rm(wimax_dev); |
496 | error_rfkill_add: |
497 | d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n", |
498 | wimax_dev, net_dev, result); |
499 | return result; |
500 | } |
501 | EXPORT_SYMBOL_GPL(wimax_dev_add); |
502 | |
503 | |
504 | /** |
505 | * wimax_dev_rm - Unregister an existing WiMAX device |
506 | * |
507 | * @wimax_dev: WiMAX device descriptor |
508 | * |
509 | * Unregisters a WiMAX device previously registered for use with |
510 | * wimax_add_rm(). |
511 | * |
512 | * IMPORTANT! Must call before calling unregister_netdev(). |
513 | * |
514 | * After this function returns, you will not get any more user space |
515 | * control requests (via netlink or debugfs) and thus to wimax_dev->ops. |
516 | * |
517 | * Reentrancy control is ensured by setting the state to |
518 | * %__WIMAX_ST_QUIESCING. rfkill operations coming through |
519 | * wimax_*rfkill*() will be stopped by the quiescing state; ops coming |
520 | * from the rfkill subsystem will be stopped by the support being |
521 | * removed by wimax_rfkill_rm(). |
522 | */ |
523 | void wimax_dev_rm(struct wimax_dev *wimax_dev) |
524 | { |
525 | d_fnstart(3, NULL, "(wimax_dev %p)\n", wimax_dev); |
526 | |
527 | mutex_lock(&wimax_dev->mutex); |
528 | __wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING); |
529 | wimax_debugfs_rm(wimax_dev); |
530 | wimax_id_table_rm(wimax_dev); |
531 | __wimax_state_change(wimax_dev, WIMAX_ST_DOWN); |
532 | mutex_unlock(&wimax_dev->mutex); |
533 | wimax_rfkill_rm(wimax_dev); |
534 | d_fnend(3, NULL, "(wimax_dev %p) = void\n", wimax_dev); |
535 | } |
536 | EXPORT_SYMBOL_GPL(wimax_dev_rm); |
537 | |
538 | |
539 | /* Debug framework control of debug levels */ |
540 | struct d_level D_LEVEL[] = { |
541 | D_SUBMODULE_DEFINE(debugfs), |
542 | D_SUBMODULE_DEFINE(id_table), |
543 | D_SUBMODULE_DEFINE(op_msg), |
544 | D_SUBMODULE_DEFINE(op_reset), |
545 | D_SUBMODULE_DEFINE(op_rfkill), |
546 | D_SUBMODULE_DEFINE(op_state_get), |
547 | D_SUBMODULE_DEFINE(stack), |
548 | }; |
549 | size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL); |
550 | |
551 | |
552 | struct genl_family wimax_gnl_family = { |
553 | .id = GENL_ID_GENERATE, |
554 | .name = "WiMAX", |
555 | .version = WIMAX_GNL_VERSION, |
556 | .hdrsize = 0, |
557 | .maxattr = WIMAX_GNL_ATTR_MAX, |
558 | }; |
559 | |
560 | struct genl_multicast_group wimax_gnl_mcg = { |
561 | .name = "msg", |
562 | }; |
563 | |
564 | |
565 | |
566 | /* Shutdown the wimax stack */ |
567 | static |
568 | int __init wimax_subsys_init(void) |
569 | { |
570 | int result, cnt; |
571 | |
572 | d_fnstart(4, NULL, "()\n"); |
573 | d_parse_params(D_LEVEL, D_LEVEL_SIZE, wimax_debug_params, |
574 | "wimax.debug"); |
575 | |
576 | snprintf(wimax_gnl_family.name, sizeof(wimax_gnl_family.name), |
577 | "WiMAX"); |
578 | result = genl_register_family(&wimax_gnl_family); |
579 | if (unlikely(result < 0)) { |
580 | printk(KERN_ERR "cannot register generic netlink family: %d\n", |
581 | result); |
582 | goto error_register_family; |
583 | } |
584 | |
585 | for (cnt = 0; cnt < ARRAY_SIZE(wimax_gnl_ops); cnt++) { |
586 | result = genl_register_ops(&wimax_gnl_family, |
587 | wimax_gnl_ops[cnt]); |
588 | d_printf(4, NULL, "registering generic netlink op code " |
589 | "%u: %d\n", wimax_gnl_ops[cnt]->cmd, result); |
590 | if (unlikely(result < 0)) { |
591 | printk(KERN_ERR "cannot register generic netlink op " |
592 | "code %u: %d\n", |
593 | wimax_gnl_ops[cnt]->cmd, result); |
594 | goto error_register_ops; |
595 | } |
596 | } |
597 | |
598 | result = genl_register_mc_group(&wimax_gnl_family, &wimax_gnl_mcg); |
599 | if (result < 0) |
600 | goto error_mc_group; |
601 | d_fnend(4, NULL, "() = 0\n"); |
602 | return 0; |
603 | |
604 | error_mc_group: |
605 | error_register_ops: |
606 | for (cnt--; cnt >= 0; cnt--) |
607 | genl_unregister_ops(&wimax_gnl_family, |
608 | wimax_gnl_ops[cnt]); |
609 | genl_unregister_family(&wimax_gnl_family); |
610 | error_register_family: |
611 | d_fnend(4, NULL, "() = %d\n", result); |
612 | return result; |
613 | |
614 | } |
615 | module_init(wimax_subsys_init); |
616 | |
617 | |
618 | /* Shutdown the wimax stack */ |
619 | static |
620 | void __exit wimax_subsys_exit(void) |
621 | { |
622 | int cnt; |
623 | wimax_id_table_release(); |
624 | genl_unregister_mc_group(&wimax_gnl_family, &wimax_gnl_mcg); |
625 | for (cnt = ARRAY_SIZE(wimax_gnl_ops) - 1; cnt >= 0; cnt--) |
626 | genl_unregister_ops(&wimax_gnl_family, |
627 | wimax_gnl_ops[cnt]); |
628 | genl_unregister_family(&wimax_gnl_family); |
629 | } |
630 | module_exit(wimax_subsys_exit); |
631 | |
632 | MODULE_AUTHOR("Intel Corporation <linux-wimax@intel.com>"); |
633 | MODULE_DESCRIPTION("Linux WiMAX stack"); |
634 | MODULE_LICENSE("GPL"); |
635 | |
636 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9