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