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