]>
Commit | Line | Data |
---|---|---|
15530dfd IPG |
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); | |
ff491a73 PNA |
166 | if (report_skb == NULL) { |
167 | result = -ENOMEM; | |
15530dfd | 168 | goto out; |
15530dfd | 169 | } |
ff491a73 PNA |
170 | genlmsg_end(report_skb, header); |
171 | genlmsg_multicast(report_skb, 0, wimax_gnl_mcg.id, GFP_KERNEL); | |
15530dfd IPG |
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 | { | |
94c7f2d4 IPG |
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 | */ | |
15530dfd | 353 | mutex_lock(&wimax_dev->mutex); |
94c7f2d4 IPG |
354 | if (wimax_dev->state > __WIMAX_ST_NULL) |
355 | __wimax_state_change(wimax_dev, new_state); | |
15530dfd IPG |
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); | |
94c7f2d4 | 392 | __wimax_state_set(wimax_dev, __WIMAX_ST_NULL); |
15530dfd IPG |
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, | |
7f0333eb PZ |
405 | wimax_gnl_rfkill, |
406 | wimax_gnl_state_get; | |
15530dfd IPG |
407 | |
408 | static | |
409 | struct genl_ops *wimax_gnl_ops[] = { | |
410 | &wimax_gnl_msg_from_user, | |
411 | &wimax_gnl_reset, | |
412 | &wimax_gnl_rfkill, | |
7f0333eb | 413 | &wimax_gnl_state_get, |
15530dfd IPG |
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 | ||
1af7ad51 IPG |
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), | |
7f0333eb | 538 | D_SUBMODULE_DEFINE(op_state_get), |
1af7ad51 IPG |
539 | D_SUBMODULE_DEFINE(stack), |
540 | }; | |
541 | size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL); | |
542 | ||
543 | ||
15530dfd IPG |
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 |