Commit | Line | Data |
---|---|---|
3a35a1d0 IPG |
1 | /* |
2 | * Intel Wireless WiMAX Connection 2400m | |
3 | * Miscellaneous control functions for managing the device | |
4 | * | |
5 | * | |
6 | * Copyright (C) 2007-2008 Intel Corporation. All rights reserved. | |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions | |
10 | * are met: | |
11 | * | |
12 | * * Redistributions of source code must retain the above copyright | |
13 | * notice, this list of conditions and the following disclaimer. | |
14 | * * Redistributions in binary form must reproduce the above copyright | |
15 | * notice, this list of conditions and the following disclaimer in | |
16 | * the documentation and/or other materials provided with the | |
17 | * distribution. | |
18 | * * Neither the name of Intel Corporation nor the names of its | |
19 | * contributors may be used to endorse or promote products derived | |
20 | * from this software without specific prior written permission. | |
21 | * | |
22 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
23 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
24 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
25 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
26 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
27 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
28 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
29 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
30 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
31 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
32 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
33 | * | |
34 | * | |
35 | * Intel Corporation <linux-wimax@intel.com> | |
36 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | |
37 | * - Initial implementation | |
38 | * | |
39 | * This is a collection of functions used to control the device (plus | |
40 | * a few helpers). | |
41 | * | |
42 | * There are utilities for handling TLV buffers, hooks on the device's | |
43 | * reports to act on device changes of state [i2400m_report_hook()], | |
44 | * on acks to commands [i2400m_msg_ack_hook()], a helper for sending | |
45 | * commands to the device and blocking until a reply arrives | |
46 | * [i2400m_msg_to_dev()], a few high level commands for manipulating | |
47 | * the device state, powersving mode and configuration plus the | |
48 | * routines to setup the device once communication is stablished with | |
49 | * it [i2400m_dev_initialize()]. | |
50 | * | |
51 | * ROADMAP | |
52 | * | |
421f91d2 | 53 | * i2400m_dev_initialize() Called by i2400m_dev_start() |
3a35a1d0 | 54 | * i2400m_set_init_config() |
3a35a1d0 IPG |
55 | * i2400m_cmd_get_state() |
56 | * i2400m_dev_shutdown() Called by i2400m_dev_stop() | |
c931ceeb | 57 | * i2400m_reset() |
3a35a1d0 IPG |
58 | * |
59 | * i2400m_{cmd,get,set}_*() | |
60 | * i2400m_msg_to_dev() | |
61 | * i2400m_msg_check_status() | |
62 | * | |
63 | * i2400m_report_hook() Called on reception of an event | |
64 | * i2400m_report_state_hook() | |
65 | * i2400m_tlv_buffer_walk() | |
66 | * i2400m_tlv_match() | |
67 | * i2400m_report_tlv_system_state() | |
68 | * i2400m_report_tlv_rf_switches_status() | |
69 | * i2400m_report_tlv_media_status() | |
70 | * i2400m_cmd_enter_powersave() | |
71 | * | |
72 | * i2400m_msg_ack_hook() Called on reception of a reply to a | |
73 | * command, get or set | |
74 | */ | |
75 | ||
76 | #include <stdarg.h> | |
77 | #include "i2400m.h" | |
78 | #include <linux/kernel.h> | |
5a0e3ad6 | 79 | #include <linux/slab.h> |
3a35a1d0 | 80 | #include <linux/wimax/i2400m.h> |
ee40fa06 | 81 | #include <linux/export.h> |
6eb07caf | 82 | #include <linux/moduleparam.h> |
3a35a1d0 IPG |
83 | |
84 | ||
85 | #define D_SUBMODULE control | |
86 | #include "debug-levels.h" | |
87 | ||
9d7fdf1b PP |
88 | static int i2400m_idle_mode_disabled;/* 0 (idle mode enabled) by default */ |
89 | module_param_named(idle_mode_disabled, i2400m_idle_mode_disabled, int, 0644); | |
90 | MODULE_PARM_DESC(idle_mode_disabled, | |
91 | "If true, the device will not enable idle mode negotiation " | |
92 | "with the base station (when connected) to save power."); | |
93 | ||
94 | /* 0 (power saving enabled) by default */ | |
95 | static int i2400m_power_save_disabled; | |
96 | module_param_named(power_save_disabled, i2400m_power_save_disabled, int, 0644); | |
97 | MODULE_PARM_DESC(power_save_disabled, | |
98 | "If true, the driver will not tell the device to enter " | |
99 | "power saving mode when it reports it is ready for it. " | |
100 | "False by default (so the device is told to do power " | |
101 | "saving)."); | |
102 | ||
e3d32687 | 103 | static int i2400m_passive_mode; /* 0 (passive mode disabled) by default */ |
55a662d6 IPG |
104 | module_param_named(passive_mode, i2400m_passive_mode, int, 0644); |
105 | MODULE_PARM_DESC(passive_mode, | |
106 | "If true, the driver will not do any device setup " | |
107 | "and leave it up to user space, who must be properly " | |
108 | "setup."); | |
109 | ||
3a35a1d0 IPG |
110 | |
111 | /* | |
112 | * Return if a TLV is of a give type and size | |
113 | * | |
114 | * @tlv_hdr: pointer to the TLV | |
115 | * @tlv_type: type of the TLV we are looking for | |
116 | * @tlv_size: expected size of the TLV we are looking for (if -1, | |
117 | * don't check the size). This includes the header | |
118 | * Returns: 0 if the TLV matches | |
119 | * < 0 if it doesn't match at all | |
120 | * > 0 total TLV + payload size, if the type matches, but not | |
121 | * the size | |
122 | */ | |
123 | static | |
124 | ssize_t i2400m_tlv_match(const struct i2400m_tlv_hdr *tlv, | |
125 | enum i2400m_tlv tlv_type, ssize_t tlv_size) | |
126 | { | |
127 | if (le16_to_cpu(tlv->type) != tlv_type) /* Not our type? skip */ | |
128 | return -1; | |
129 | if (tlv_size != -1 | |
130 | && le16_to_cpu(tlv->length) + sizeof(*tlv) != tlv_size) { | |
131 | size_t size = le16_to_cpu(tlv->length) + sizeof(*tlv); | |
132 | printk(KERN_WARNING "W: tlv type 0x%x mismatched because of " | |
2a304bb8 | 133 | "size (got %zu vs %zd expected)\n", |
3a35a1d0 IPG |
134 | tlv_type, size, tlv_size); |
135 | return size; | |
136 | } | |
137 | return 0; | |
138 | } | |
139 | ||
140 | ||
141 | /* | |
142 | * Given a buffer of TLVs, iterate over them | |
143 | * | |
144 | * @i2400m: device instance | |
145 | * @tlv_buf: pointer to the beginning of the TLV buffer | |
146 | * @buf_size: buffer size in bytes | |
147 | * @tlv_pos: seek position; this is assumed to be a pointer returned | |
148 | * by i2400m_tlv_buffer_walk() [and thus, validated]. The | |
149 | * TLV returned will be the one following this one. | |
150 | * | |
151 | * Usage: | |
152 | * | |
153 | * tlv_itr = NULL; | |
154 | * while (tlv_itr = i2400m_tlv_buffer_walk(i2400m, buf, size, tlv_itr)) { | |
155 | * ... | |
156 | * // Do stuff with tlv_itr, DON'T MODIFY IT | |
157 | * ... | |
158 | * } | |
159 | */ | |
160 | static | |
161 | const struct i2400m_tlv_hdr *i2400m_tlv_buffer_walk( | |
162 | struct i2400m *i2400m, | |
163 | const void *tlv_buf, size_t buf_size, | |
164 | const struct i2400m_tlv_hdr *tlv_pos) | |
165 | { | |
166 | struct device *dev = i2400m_dev(i2400m); | |
167 | const struct i2400m_tlv_hdr *tlv_top = tlv_buf + buf_size; | |
168 | size_t offset, length, avail_size; | |
169 | unsigned type; | |
170 | ||
171 | if (tlv_pos == NULL) /* Take the first one? */ | |
172 | tlv_pos = tlv_buf; | |
173 | else /* Nope, the next one */ | |
174 | tlv_pos = (void *) tlv_pos | |
175 | + le16_to_cpu(tlv_pos->length) + sizeof(*tlv_pos); | |
176 | if (tlv_pos == tlv_top) { /* buffer done */ | |
177 | tlv_pos = NULL; | |
178 | goto error_beyond_end; | |
179 | } | |
180 | if (tlv_pos > tlv_top) { | |
181 | tlv_pos = NULL; | |
182 | WARN_ON(1); | |
183 | goto error_beyond_end; | |
184 | } | |
185 | offset = (void *) tlv_pos - (void *) tlv_buf; | |
186 | avail_size = buf_size - offset; | |
187 | if (avail_size < sizeof(*tlv_pos)) { | |
188 | dev_err(dev, "HW BUG? tlv_buf %p [%zu bytes], tlv @%zu: " | |
189 | "short header\n", tlv_buf, buf_size, offset); | |
190 | goto error_short_header; | |
191 | } | |
192 | type = le16_to_cpu(tlv_pos->type); | |
193 | length = le16_to_cpu(tlv_pos->length); | |
194 | if (avail_size < sizeof(*tlv_pos) + length) { | |
195 | dev_err(dev, "HW BUG? tlv_buf %p [%zu bytes], " | |
196 | "tlv type 0x%04x @%zu: " | |
197 | "short data (%zu bytes vs %zu needed)\n", | |
198 | tlv_buf, buf_size, type, offset, avail_size, | |
199 | sizeof(*tlv_pos) + length); | |
200 | goto error_short_header; | |
201 | } | |
202 | error_short_header: | |
203 | error_beyond_end: | |
204 | return tlv_pos; | |
205 | } | |
206 | ||
207 | ||
208 | /* | |
209 | * Find a TLV in a buffer of sequential TLVs | |
210 | * | |
211 | * @i2400m: device descriptor | |
212 | * @tlv_hdr: pointer to the first TLV in the sequence | |
213 | * @size: size of the buffer in bytes; all TLVs are assumed to fit | |
214 | * fully in the buffer (otherwise we'll complain). | |
215 | * @tlv_type: type of the TLV we are looking for | |
216 | * @tlv_size: expected size of the TLV we are looking for (if -1, | |
217 | * don't check the size). This includes the header | |
218 | * | |
219 | * Returns: NULL if the TLV is not found, otherwise a pointer to | |
220 | * it. If the sizes don't match, an error is printed and NULL | |
221 | * returned. | |
222 | */ | |
223 | static | |
224 | const struct i2400m_tlv_hdr *i2400m_tlv_find( | |
225 | struct i2400m *i2400m, | |
226 | const struct i2400m_tlv_hdr *tlv_hdr, size_t size, | |
227 | enum i2400m_tlv tlv_type, ssize_t tlv_size) | |
228 | { | |
229 | ssize_t match; | |
230 | struct device *dev = i2400m_dev(i2400m); | |
231 | const struct i2400m_tlv_hdr *tlv = NULL; | |
232 | while ((tlv = i2400m_tlv_buffer_walk(i2400m, tlv_hdr, size, tlv))) { | |
233 | match = i2400m_tlv_match(tlv, tlv_type, tlv_size); | |
234 | if (match == 0) /* found it :) */ | |
235 | break; | |
236 | if (match > 0) | |
237 | dev_warn(dev, "TLV type 0x%04x found with size " | |
2a304bb8 | 238 | "mismatch (%zu vs %zd needed)\n", |
3a35a1d0 IPG |
239 | tlv_type, match, tlv_size); |
240 | } | |
241 | return tlv; | |
242 | } | |
243 | ||
244 | ||
245 | static const struct | |
246 | { | |
247 | char *msg; | |
248 | int errno; | |
249 | } ms_to_errno[I2400M_MS_MAX] = { | |
250 | [I2400M_MS_DONE_OK] = { "", 0 }, | |
251 | [I2400M_MS_DONE_IN_PROGRESS] = { "", 0 }, | |
252 | [I2400M_MS_INVALID_OP] = { "invalid opcode", -ENOSYS }, | |
253 | [I2400M_MS_BAD_STATE] = { "invalid state", -EILSEQ }, | |
254 | [I2400M_MS_ILLEGAL_VALUE] = { "illegal value", -EINVAL }, | |
255 | [I2400M_MS_MISSING_PARAMS] = { "missing parameters", -ENOMSG }, | |
256 | [I2400M_MS_VERSION_ERROR] = { "bad version", -EIO }, | |
257 | [I2400M_MS_ACCESSIBILITY_ERROR] = { "accesibility error", -EIO }, | |
258 | [I2400M_MS_BUSY] = { "busy", -EBUSY }, | |
259 | [I2400M_MS_CORRUPTED_TLV] = { "corrupted TLV", -EILSEQ }, | |
260 | [I2400M_MS_UNINITIALIZED] = { "not unitialized", -EILSEQ }, | |
261 | [I2400M_MS_UNKNOWN_ERROR] = { "unknown error", -EIO }, | |
262 | [I2400M_MS_PRODUCTION_ERROR] = { "production error", -EIO }, | |
263 | [I2400M_MS_NO_RF] = { "no RF", -EIO }, | |
264 | [I2400M_MS_NOT_READY_FOR_POWERSAVE] = | |
265 | { "not ready for powersave", -EACCES }, | |
266 | [I2400M_MS_THERMAL_CRITICAL] = { "thermal critical", -EL3HLT }, | |
267 | }; | |
268 | ||
269 | ||
270 | /* | |
271 | * i2400m_msg_check_status - translate a message's status code | |
272 | * | |
273 | * @i2400m: device descriptor | |
274 | * @l3l4_hdr: message header | |
275 | * @strbuf: buffer to place a formatted error message (unless NULL). | |
276 | * @strbuf_size: max amount of available space; larger messages will | |
277 | * be truncated. | |
278 | * | |
279 | * Returns: errno code corresponding to the status code in @l3l4_hdr | |
280 | * and a message in @strbuf describing the error. | |
281 | */ | |
282 | int i2400m_msg_check_status(const struct i2400m_l3l4_hdr *l3l4_hdr, | |
283 | char *strbuf, size_t strbuf_size) | |
284 | { | |
285 | int result; | |
286 | enum i2400m_ms status = le16_to_cpu(l3l4_hdr->status); | |
287 | const char *str; | |
288 | ||
289 | if (status == 0) | |
290 | return 0; | |
a6346fa5 | 291 | if (status >= ARRAY_SIZE(ms_to_errno)) { |
3a35a1d0 IPG |
292 | str = "unknown status code"; |
293 | result = -EBADR; | |
294 | } else { | |
295 | str = ms_to_errno[status].msg; | |
296 | result = ms_to_errno[status].errno; | |
297 | } | |
298 | if (strbuf) | |
299 | snprintf(strbuf, strbuf_size, "%s (%d)", str, status); | |
300 | return result; | |
301 | } | |
302 | ||
303 | ||
304 | /* | |
305 | * Act on a TLV System State reported by the device | |
306 | * | |
307 | * @i2400m: device descriptor | |
308 | * @ss: validated System State TLV | |
309 | */ | |
310 | static | |
311 | void i2400m_report_tlv_system_state(struct i2400m *i2400m, | |
312 | const struct i2400m_tlv_system_state *ss) | |
313 | { | |
314 | struct device *dev = i2400m_dev(i2400m); | |
315 | struct wimax_dev *wimax_dev = &i2400m->wimax_dev; | |
316 | enum i2400m_system_state i2400m_state = le32_to_cpu(ss->state); | |
317 | ||
318 | d_fnstart(3, dev, "(i2400m %p ss %p [%u])\n", i2400m, ss, i2400m_state); | |
319 | ||
3a35a1d0 IPG |
320 | if (i2400m->state != i2400m_state) { |
321 | i2400m->state = i2400m_state; | |
322 | wake_up_all(&i2400m->state_wq); | |
323 | } | |
324 | switch (i2400m_state) { | |
325 | case I2400M_SS_UNINITIALIZED: | |
326 | case I2400M_SS_INIT: | |
327 | case I2400M_SS_CONFIG: | |
328 | case I2400M_SS_PRODUCTION: | |
329 | wimax_state_change(wimax_dev, WIMAX_ST_UNINITIALIZED); | |
330 | break; | |
331 | ||
332 | case I2400M_SS_RF_OFF: | |
333 | case I2400M_SS_RF_SHUTDOWN: | |
334 | wimax_state_change(wimax_dev, WIMAX_ST_RADIO_OFF); | |
335 | break; | |
336 | ||
337 | case I2400M_SS_READY: | |
338 | case I2400M_SS_STANDBY: | |
339 | case I2400M_SS_SLEEPACTIVE: | |
340 | wimax_state_change(wimax_dev, WIMAX_ST_READY); | |
341 | break; | |
342 | ||
343 | case I2400M_SS_CONNECTING: | |
344 | case I2400M_SS_WIMAX_CONNECTED: | |
345 | wimax_state_change(wimax_dev, WIMAX_ST_READY); | |
346 | break; | |
347 | ||
348 | case I2400M_SS_SCAN: | |
349 | case I2400M_SS_OUT_OF_ZONE: | |
350 | wimax_state_change(wimax_dev, WIMAX_ST_SCANNING); | |
351 | break; | |
352 | ||
353 | case I2400M_SS_IDLE: | |
354 | d_printf(1, dev, "entering BS-negotiated idle mode\n"); | |
355 | case I2400M_SS_DISCONNECTING: | |
356 | case I2400M_SS_DATA_PATH_CONNECTED: | |
357 | wimax_state_change(wimax_dev, WIMAX_ST_CONNECTED); | |
358 | break; | |
359 | ||
360 | default: | |
361 | /* Huh? just in case, shut it down */ | |
362 | dev_err(dev, "HW BUG? unknown state %u: shutting down\n", | |
363 | i2400m_state); | |
c931ceeb | 364 | i2400m_reset(i2400m, I2400M_RT_WARM); |
3a35a1d0 | 365 | break; |
ee289b64 | 366 | } |
3a35a1d0 IPG |
367 | d_fnend(3, dev, "(i2400m %p ss %p [%u]) = void\n", |
368 | i2400m, ss, i2400m_state); | |
369 | } | |
370 | ||
371 | ||
372 | /* | |
373 | * Parse and act on a TLV Media Status sent by the device | |
374 | * | |
375 | * @i2400m: device descriptor | |
376 | * @ms: validated Media Status TLV | |
377 | * | |
378 | * This will set the carrier up on down based on the device's link | |
379 | * report. This is done asides of what the WiMAX stack does based on | |
380 | * the device's state as sometimes we need to do a link-renew (the BS | |
381 | * wants us to renew a DHCP lease, for example). | |
382 | * | |
25985edc | 383 | * In fact, doc says that every time we get a link-up, we should do a |
3a35a1d0 IPG |
384 | * DHCP negotiation... |
385 | */ | |
386 | static | |
387 | void i2400m_report_tlv_media_status(struct i2400m *i2400m, | |
388 | const struct i2400m_tlv_media_status *ms) | |
389 | { | |
390 | struct device *dev = i2400m_dev(i2400m); | |
391 | struct wimax_dev *wimax_dev = &i2400m->wimax_dev; | |
392 | struct net_device *net_dev = wimax_dev->net_dev; | |
393 | enum i2400m_media_status status = le32_to_cpu(ms->media_status); | |
394 | ||
395 | d_fnstart(3, dev, "(i2400m %p ms %p [%u])\n", i2400m, ms, status); | |
396 | ||
3a35a1d0 IPG |
397 | switch (status) { |
398 | case I2400M_MEDIA_STATUS_LINK_UP: | |
399 | netif_carrier_on(net_dev); | |
400 | break; | |
401 | case I2400M_MEDIA_STATUS_LINK_DOWN: | |
402 | netif_carrier_off(net_dev); | |
403 | break; | |
404 | /* | |
405 | * This is the network telling us we need to retrain the DHCP | |
406 | * lease -- so far, we are trusting the WiMAX Network Service | |
407 | * in user space to pick this up and poke the DHCP client. | |
408 | */ | |
409 | case I2400M_MEDIA_STATUS_LINK_RENEW: | |
410 | netif_carrier_on(net_dev); | |
411 | break; | |
412 | default: | |
413 | dev_err(dev, "HW BUG? unknown media status %u\n", | |
414 | status); | |
ee289b64 | 415 | } |
3a35a1d0 IPG |
416 | d_fnend(3, dev, "(i2400m %p ms %p [%u]) = void\n", |
417 | i2400m, ms, status); | |
418 | } | |
419 | ||
420 | ||
421 | /* | |
8ac1101f IPG |
422 | * Process a TLV from a 'state report' |
423 | * | |
424 | * @i2400m: device descriptor | |
425 | * @tlv: pointer to the TLV header; it has been already validated for | |
426 | * consistent size. | |
427 | * @tag: for error messages | |
428 | * | |
429 | * Act on the TLVs from a 'state report'. | |
430 | */ | |
431 | static | |
432 | void i2400m_report_state_parse_tlv(struct i2400m *i2400m, | |
433 | const struct i2400m_tlv_hdr *tlv, | |
434 | const char *tag) | |
435 | { | |
436 | struct device *dev = i2400m_dev(i2400m); | |
437 | const struct i2400m_tlv_media_status *ms; | |
438 | const struct i2400m_tlv_system_state *ss; | |
439 | const struct i2400m_tlv_rf_switches_status *rfss; | |
440 | ||
441 | if (0 == i2400m_tlv_match(tlv, I2400M_TLV_SYSTEM_STATE, sizeof(*ss))) { | |
442 | ss = container_of(tlv, typeof(*ss), hdr); | |
443 | d_printf(2, dev, "%s: system state TLV " | |
444 | "found (0x%04x), state 0x%08x\n", | |
445 | tag, I2400M_TLV_SYSTEM_STATE, | |
446 | le32_to_cpu(ss->state)); | |
447 | i2400m_report_tlv_system_state(i2400m, ss); | |
448 | } | |
449 | if (0 == i2400m_tlv_match(tlv, I2400M_TLV_RF_STATUS, sizeof(*rfss))) { | |
450 | rfss = container_of(tlv, typeof(*rfss), hdr); | |
451 | d_printf(2, dev, "%s: RF status TLV " | |
452 | "found (0x%04x), sw 0x%02x hw 0x%02x\n", | |
453 | tag, I2400M_TLV_RF_STATUS, | |
454 | le32_to_cpu(rfss->sw_rf_switch), | |
455 | le32_to_cpu(rfss->hw_rf_switch)); | |
456 | i2400m_report_tlv_rf_switches_status(i2400m, rfss); | |
457 | } | |
458 | if (0 == i2400m_tlv_match(tlv, I2400M_TLV_MEDIA_STATUS, sizeof(*ms))) { | |
459 | ms = container_of(tlv, typeof(*ms), hdr); | |
460 | d_printf(2, dev, "%s: Media Status TLV: %u\n", | |
461 | tag, le32_to_cpu(ms->media_status)); | |
462 | i2400m_report_tlv_media_status(i2400m, ms); | |
463 | } | |
464 | } | |
465 | ||
466 | ||
467 | /* | |
468 | * Parse a 'state report' and extract information | |
3a35a1d0 IPG |
469 | * |
470 | * @i2400m: device descriptor | |
471 | * @l3l4_hdr: pointer to message; it has been already validated for | |
472 | * consistent size. | |
473 | * @size: size of the message (header + payload). The header length | |
474 | * declaration is assumed to be congruent with @size (as in | |
475 | * sizeof(*l3l4_hdr) + l3l4_hdr->length == size) | |
476 | * | |
8ac1101f | 477 | * Walk over the TLVs in a report state and act on them. |
3a35a1d0 IPG |
478 | */ |
479 | static | |
480 | void i2400m_report_state_hook(struct i2400m *i2400m, | |
481 | const struct i2400m_l3l4_hdr *l3l4_hdr, | |
482 | size_t size, const char *tag) | |
483 | { | |
484 | struct device *dev = i2400m_dev(i2400m); | |
485 | const struct i2400m_tlv_hdr *tlv; | |
3a35a1d0 IPG |
486 | size_t tlv_size = le16_to_cpu(l3l4_hdr->length); |
487 | ||
488 | d_fnstart(4, dev, "(i2400m %p, l3l4_hdr %p, size %zu, %s)\n", | |
489 | i2400m, l3l4_hdr, size, tag); | |
490 | tlv = NULL; | |
491 | ||
492 | while ((tlv = i2400m_tlv_buffer_walk(i2400m, &l3l4_hdr->pl, | |
8ac1101f IPG |
493 | tlv_size, tlv))) |
494 | i2400m_report_state_parse_tlv(i2400m, tlv, tag); | |
3a35a1d0 IPG |
495 | d_fnend(4, dev, "(i2400m %p, l3l4_hdr %p, size %zu, %s) = void\n", |
496 | i2400m, l3l4_hdr, size, tag); | |
497 | } | |
498 | ||
499 | ||
500 | /* | |
501 | * i2400m_report_hook - (maybe) act on a report | |
502 | * | |
503 | * @i2400m: device descriptor | |
504 | * @l3l4_hdr: pointer to message; it has been already validated for | |
505 | * consistent size. | |
506 | * @size: size of the message (header + payload). The header length | |
507 | * declaration is assumed to be congruent with @size (as in | |
508 | * sizeof(*l3l4_hdr) + l3l4_hdr->length == size) | |
509 | * | |
510 | * Extract information we might need (like carrien on/off) from a | |
511 | * device report. | |
512 | */ | |
513 | void i2400m_report_hook(struct i2400m *i2400m, | |
514 | const struct i2400m_l3l4_hdr *l3l4_hdr, size_t size) | |
515 | { | |
516 | struct device *dev = i2400m_dev(i2400m); | |
517 | unsigned msg_type; | |
518 | ||
519 | d_fnstart(3, dev, "(i2400m %p l3l4_hdr %p size %zu)\n", | |
520 | i2400m, l3l4_hdr, size); | |
521 | /* Chew on the message, we might need some information from | |
522 | * here */ | |
523 | msg_type = le16_to_cpu(l3l4_hdr->type); | |
524 | switch (msg_type) { | |
525 | case I2400M_MT_REPORT_STATE: /* carrier detection... */ | |
526 | i2400m_report_state_hook(i2400m, | |
527 | l3l4_hdr, size, "REPORT STATE"); | |
528 | break; | |
529 | /* If the device is ready for power save, then ask it to do | |
530 | * it. */ | |
531 | case I2400M_MT_REPORT_POWERSAVE_READY: /* zzzzz */ | |
532 | if (l3l4_hdr->status == cpu_to_le16(I2400M_MS_DONE_OK)) { | |
fb101674 IPG |
533 | if (i2400m_power_save_disabled) |
534 | d_printf(1, dev, "ready for powersave, " | |
535 | "not requesting (disabled by module " | |
536 | "parameter)\n"); | |
537 | else { | |
538 | d_printf(1, dev, "ready for powersave, " | |
539 | "requesting\n"); | |
540 | i2400m_cmd_enter_powersave(i2400m); | |
541 | } | |
3a35a1d0 IPG |
542 | } |
543 | break; | |
ee289b64 | 544 | } |
3a35a1d0 IPG |
545 | d_fnend(3, dev, "(i2400m %p l3l4_hdr %p size %zu) = void\n", |
546 | i2400m, l3l4_hdr, size); | |
547 | } | |
548 | ||
549 | ||
550 | /* | |
551 | * i2400m_msg_ack_hook - process cmd/set/get ack for internal status | |
552 | * | |
553 | * @i2400m: device descriptor | |
554 | * @l3l4_hdr: pointer to message; it has been already validated for | |
555 | * consistent size. | |
556 | * @size: size of the message | |
557 | * | |
558 | * Extract information we might need from acks to commands and act on | |
559 | * it. This is akin to i2400m_report_hook(). Note most of this | |
560 | * processing should be done in the function that calls the | |
561 | * command. This is here for some cases where it can't happen... | |
562 | */ | |
e3d32687 | 563 | static void i2400m_msg_ack_hook(struct i2400m *i2400m, |
564 | const struct i2400m_l3l4_hdr *l3l4_hdr, | |
565 | size_t size) | |
3a35a1d0 IPG |
566 | { |
567 | int result; | |
568 | struct device *dev = i2400m_dev(i2400m); | |
569 | unsigned ack_type, ack_status; | |
570 | char strerr[32]; | |
571 | ||
572 | /* Chew on the message, we might need some information from | |
573 | * here */ | |
574 | ack_type = le16_to_cpu(l3l4_hdr->type); | |
575 | ack_status = le16_to_cpu(l3l4_hdr->status); | |
576 | switch (ack_type) { | |
577 | case I2400M_MT_CMD_ENTER_POWERSAVE: | |
578 | /* This is just left here for the sake of example, as | |
579 | * the processing is done somewhere else. */ | |
580 | if (0) { | |
581 | result = i2400m_msg_check_status( | |
582 | l3l4_hdr, strerr, sizeof(strerr)); | |
583 | if (result >= 0) | |
584 | d_printf(1, dev, "ready for power save: %zd\n", | |
585 | size); | |
586 | } | |
587 | break; | |
ee289b64 | 588 | } |
3a35a1d0 IPG |
589 | } |
590 | ||
591 | ||
592 | /* | |
593 | * i2400m_msg_size_check() - verify message size and header are congruent | |
594 | * | |
595 | * It is ok if the total message size is larger than the expected | |
596 | * size, as there can be padding. | |
597 | */ | |
598 | int i2400m_msg_size_check(struct i2400m *i2400m, | |
599 | const struct i2400m_l3l4_hdr *l3l4_hdr, | |
600 | size_t msg_size) | |
601 | { | |
602 | int result; | |
603 | struct device *dev = i2400m_dev(i2400m); | |
604 | size_t expected_size; | |
605 | d_fnstart(4, dev, "(i2400m %p l3l4_hdr %p msg_size %zu)\n", | |
606 | i2400m, l3l4_hdr, msg_size); | |
607 | if (msg_size < sizeof(*l3l4_hdr)) { | |
608 | dev_err(dev, "bad size for message header " | |
609 | "(expected at least %zu, got %zu)\n", | |
610 | (size_t) sizeof(*l3l4_hdr), msg_size); | |
611 | result = -EIO; | |
612 | goto error_hdr_size; | |
613 | } | |
614 | expected_size = le16_to_cpu(l3l4_hdr->length) + sizeof(*l3l4_hdr); | |
615 | if (msg_size < expected_size) { | |
616 | dev_err(dev, "bad size for message code 0x%04x (expected %zu, " | |
617 | "got %zu)\n", le16_to_cpu(l3l4_hdr->type), | |
618 | expected_size, msg_size); | |
619 | result = -EIO; | |
620 | } else | |
621 | result = 0; | |
622 | error_hdr_size: | |
623 | d_fnend(4, dev, | |
624 | "(i2400m %p l3l4_hdr %p msg_size %zu) = %d\n", | |
625 | i2400m, l3l4_hdr, msg_size, result); | |
626 | return result; | |
627 | } | |
628 | ||
629 | ||
630 | ||
631 | /* | |
632 | * Cancel a wait for a command ACK | |
633 | * | |
634 | * @i2400m: device descriptor | |
635 | * @code: [negative] errno code to cancel with (don't use | |
636 | * -EINPROGRESS) | |
637 | * | |
638 | * If there is an ack already filled out, free it. | |
639 | */ | |
640 | void i2400m_msg_to_dev_cancel_wait(struct i2400m *i2400m, int code) | |
641 | { | |
642 | struct sk_buff *ack_skb; | |
643 | unsigned long flags; | |
644 | ||
645 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
646 | ack_skb = i2400m->ack_skb; | |
647 | if (ack_skb && !IS_ERR(ack_skb)) | |
f4895b8b | 648 | kfree_skb(ack_skb); |
3a35a1d0 IPG |
649 | i2400m->ack_skb = ERR_PTR(code); |
650 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
651 | } | |
652 | ||
653 | ||
654 | /** | |
655 | * i2400m_msg_to_dev - Send a control message to the device and get a response | |
656 | * | |
657 | * @i2400m: device descriptor | |
658 | * | |
659 | * @msg_skb: an skb * | |
660 | * | |
661 | * @buf: pointer to the buffer containing the message to be sent; it | |
662 | * has to start with a &struct i2400M_l3l4_hdr and then | |
663 | * followed by the payload. Once this function returns, the | |
664 | * buffer can be reused. | |
665 | * | |
666 | * @buf_len: buffer size | |
667 | * | |
668 | * Returns: | |
669 | * | |
670 | * Pointer to skb containing the ack message. You need to check the | |
671 | * pointer with IS_ERR(), as it might be an error code. Error codes | |
672 | * could happen because: | |
673 | * | |
674 | * - the message wasn't formatted correctly | |
675 | * - couldn't send the message | |
676 | * - failed waiting for a response | |
677 | * - the ack message wasn't formatted correctly | |
678 | * | |
679 | * The returned skb has been allocated with wimax_msg_to_user_alloc(), | |
25985edc | 680 | * it contains the response in a netlink attribute and is ready to be |
3a35a1d0 IPG |
681 | * passed up to user space with wimax_msg_to_user_send(). To access |
682 | * the payload and its length, use wimax_msg_{data,len}() on the skb. | |
683 | * | |
684 | * The skb has to be freed with kfree_skb() once done. | |
685 | * | |
686 | * Description: | |
687 | * | |
688 | * This function delivers a message/command to the device and waits | |
689 | * for an ack to be received. The format is described in | |
690 | * linux/wimax/i2400m.h. In summary, a command/get/set is followed by an | |
691 | * ack. | |
692 | * | |
693 | * This function will not check the ack status, that's left up to the | |
694 | * caller. Once done with the ack skb, it has to be kfree_skb()ed. | |
695 | * | |
696 | * The i2400m handles only one message at the same time, thus we need | |
697 | * the mutex to exclude other players. | |
698 | * | |
699 | * We write the message and then wait for an answer to come back. The | |
700 | * RX path intercepts control messages and handles them in | |
701 | * i2400m_rx_ctl(). Reports (notifications) are (maybe) processed | |
702 | * locally and then forwarded (as needed) to user space on the WiMAX | |
703 | * stack message pipe. Acks are saved and passed back to us through an | |
704 | * skb in i2400m->ack_skb which is ready to be given to generic | |
705 | * netlink if need be. | |
706 | */ | |
707 | struct sk_buff *i2400m_msg_to_dev(struct i2400m *i2400m, | |
708 | const void *buf, size_t buf_len) | |
709 | { | |
710 | int result; | |
711 | struct device *dev = i2400m_dev(i2400m); | |
712 | const struct i2400m_l3l4_hdr *msg_l3l4_hdr; | |
713 | struct sk_buff *ack_skb; | |
714 | const struct i2400m_l3l4_hdr *ack_l3l4_hdr; | |
715 | size_t ack_len; | |
716 | int ack_timeout; | |
717 | unsigned msg_type; | |
718 | unsigned long flags; | |
719 | ||
720 | d_fnstart(3, dev, "(i2400m %p buf %p len %zu)\n", | |
721 | i2400m, buf, buf_len); | |
722 | ||
b4013f91 | 723 | rmb(); /* Make sure we see what i2400m_dev_reset_handle() */ |
3a35a1d0 | 724 | if (i2400m->boot_mode) |
0bcfc5ef | 725 | return ERR_PTR(-EL3RST); |
3a35a1d0 IPG |
726 | |
727 | msg_l3l4_hdr = buf; | |
728 | /* Check msg & payload consistency */ | |
729 | result = i2400m_msg_size_check(i2400m, msg_l3l4_hdr, buf_len); | |
730 | if (result < 0) | |
731 | goto error_bad_msg; | |
732 | msg_type = le16_to_cpu(msg_l3l4_hdr->type); | |
733 | d_printf(1, dev, "CMD/GET/SET 0x%04x %zu bytes\n", | |
734 | msg_type, buf_len); | |
735 | d_dump(2, dev, buf, buf_len); | |
736 | ||
737 | /* Setup the completion, ack_skb ("we are waiting") and send | |
738 | * the message to the device */ | |
739 | mutex_lock(&i2400m->msg_mutex); | |
740 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
741 | i2400m->ack_skb = ERR_PTR(-EINPROGRESS); | |
742 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
743 | init_completion(&i2400m->msg_completion); | |
744 | result = i2400m_tx(i2400m, buf, buf_len, I2400M_PT_CTRL); | |
745 | if (result < 0) { | |
746 | dev_err(dev, "can't send message 0x%04x: %d\n", | |
747 | le16_to_cpu(msg_l3l4_hdr->type), result); | |
748 | goto error_tx; | |
749 | } | |
750 | ||
751 | /* Some commands take longer to execute because of crypto ops, | |
752 | * so we give them some more leeway on timeout */ | |
753 | switch (msg_type) { | |
754 | case I2400M_MT_GET_TLS_OPERATION_RESULT: | |
755 | case I2400M_MT_CMD_SEND_EAP_RESPONSE: | |
756 | ack_timeout = 5 * HZ; | |
757 | break; | |
758 | default: | |
759 | ack_timeout = HZ; | |
ee289b64 | 760 | } |
3a35a1d0 | 761 | |
223beea2 IPG |
762 | if (unlikely(i2400m->trace_msg_from_user)) |
763 | wimax_msg(&i2400m->wimax_dev, "echo", buf, buf_len, GFP_KERNEL); | |
3a35a1d0 IPG |
764 | /* The RX path in rx.c will put any response for this message |
765 | * in i2400m->ack_skb and wake us up. If we cancel the wait, | |
766 | * we need to change the value of i2400m->ack_skb to something | |
767 | * not -EINPROGRESS so RX knows there is no one waiting. */ | |
768 | result = wait_for_completion_interruptible_timeout( | |
769 | &i2400m->msg_completion, ack_timeout); | |
770 | if (result == 0) { | |
771 | dev_err(dev, "timeout waiting for reply to message 0x%04x\n", | |
772 | msg_type); | |
773 | result = -ETIMEDOUT; | |
774 | i2400m_msg_to_dev_cancel_wait(i2400m, result); | |
775 | goto error_wait_for_completion; | |
776 | } else if (result < 0) { | |
777 | dev_err(dev, "error waiting for reply to message 0x%04x: %d\n", | |
778 | msg_type, result); | |
779 | i2400m_msg_to_dev_cancel_wait(i2400m, result); | |
780 | goto error_wait_for_completion; | |
781 | } | |
782 | ||
783 | /* Pull out the ack data from i2400m->ack_skb -- see if it is | |
784 | * an error and act accordingly */ | |
785 | spin_lock_irqsave(&i2400m->rx_lock, flags); | |
786 | ack_skb = i2400m->ack_skb; | |
787 | if (IS_ERR(ack_skb)) | |
788 | result = PTR_ERR(ack_skb); | |
789 | else | |
790 | result = 0; | |
791 | i2400m->ack_skb = NULL; | |
792 | spin_unlock_irqrestore(&i2400m->rx_lock, flags); | |
793 | if (result < 0) | |
794 | goto error_ack_status; | |
795 | ack_l3l4_hdr = wimax_msg_data_len(ack_skb, &ack_len); | |
796 | ||
797 | /* Check the ack and deliver it if it is ok */ | |
223beea2 IPG |
798 | if (unlikely(i2400m->trace_msg_from_user)) |
799 | wimax_msg(&i2400m->wimax_dev, "echo", | |
800 | ack_l3l4_hdr, ack_len, GFP_KERNEL); | |
3a35a1d0 IPG |
801 | result = i2400m_msg_size_check(i2400m, ack_l3l4_hdr, ack_len); |
802 | if (result < 0) { | |
803 | dev_err(dev, "HW BUG? reply to message 0x%04x: %d\n", | |
804 | msg_type, result); | |
805 | goto error_bad_ack_len; | |
806 | } | |
807 | if (msg_type != le16_to_cpu(ack_l3l4_hdr->type)) { | |
808 | dev_err(dev, "HW BUG? bad reply 0x%04x to message 0x%04x\n", | |
809 | le16_to_cpu(ack_l3l4_hdr->type), msg_type); | |
810 | result = -EIO; | |
811 | goto error_bad_ack_type; | |
812 | } | |
813 | i2400m_msg_ack_hook(i2400m, ack_l3l4_hdr, ack_len); | |
814 | mutex_unlock(&i2400m->msg_mutex); | |
815 | d_fnend(3, dev, "(i2400m %p buf %p len %zu) = %p\n", | |
816 | i2400m, buf, buf_len, ack_skb); | |
817 | return ack_skb; | |
818 | ||
819 | error_bad_ack_type: | |
820 | error_bad_ack_len: | |
821 | kfree_skb(ack_skb); | |
822 | error_ack_status: | |
823 | error_wait_for_completion: | |
824 | error_tx: | |
825 | mutex_unlock(&i2400m->msg_mutex); | |
826 | error_bad_msg: | |
827 | d_fnend(3, dev, "(i2400m %p buf %p len %zu) = %d\n", | |
828 | i2400m, buf, buf_len, result); | |
829 | return ERR_PTR(result); | |
830 | } | |
831 | ||
832 | ||
833 | /* | |
834 | * Definitions for the Enter Power Save command | |
835 | * | |
836 | * The Enter Power Save command requests the device to go into power | |
837 | * saving mode. The device will ack or nak the command depending on it | |
838 | * being ready for it. If it acks, we tell the USB subsystem to | |
839 | * | |
840 | * As well, the device might request to go into power saving mode by | |
841 | * sending a report (REPORT_POWERSAVE_READY), in which case, we issue | |
842 | * this command. The hookups in the RX coder allow | |
843 | */ | |
844 | enum { | |
845 | I2400M_WAKEUP_ENABLED = 0x01, | |
846 | I2400M_WAKEUP_DISABLED = 0x02, | |
847 | I2400M_TLV_TYPE_WAKEUP_MODE = 144, | |
848 | }; | |
849 | ||
850 | struct i2400m_cmd_enter_power_save { | |
851 | struct i2400m_l3l4_hdr hdr; | |
852 | struct i2400m_tlv_hdr tlv; | |
853 | __le32 val; | |
ba2d3587 | 854 | } __packed; |
3a35a1d0 IPG |
855 | |
856 | ||
857 | /* | |
858 | * Request entering power save | |
859 | * | |
860 | * This command is (mainly) executed when the device indicates that it | |
861 | * is ready to go into powersave mode via a REPORT_POWERSAVE_READY. | |
862 | */ | |
863 | int i2400m_cmd_enter_powersave(struct i2400m *i2400m) | |
864 | { | |
865 | int result; | |
866 | struct device *dev = i2400m_dev(i2400m); | |
867 | struct sk_buff *ack_skb; | |
868 | struct i2400m_cmd_enter_power_save *cmd; | |
869 | char strerr[32]; | |
870 | ||
871 | result = -ENOMEM; | |
872 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
873 | if (cmd == NULL) | |
874 | goto error_alloc; | |
875 | cmd->hdr.type = cpu_to_le16(I2400M_MT_CMD_ENTER_POWERSAVE); | |
876 | cmd->hdr.length = cpu_to_le16(sizeof(*cmd) - sizeof(cmd->hdr)); | |
877 | cmd->hdr.version = cpu_to_le16(I2400M_L3L4_VERSION); | |
878 | cmd->tlv.type = cpu_to_le16(I2400M_TLV_TYPE_WAKEUP_MODE); | |
879 | cmd->tlv.length = cpu_to_le16(sizeof(cmd->val)); | |
880 | cmd->val = cpu_to_le32(I2400M_WAKEUP_ENABLED); | |
881 | ||
882 | ack_skb = i2400m_msg_to_dev(i2400m, cmd, sizeof(*cmd)); | |
883 | result = PTR_ERR(ack_skb); | |
884 | if (IS_ERR(ack_skb)) { | |
885 | dev_err(dev, "Failed to issue 'Enter power save' command: %d\n", | |
886 | result); | |
887 | goto error_msg_to_dev; | |
888 | } | |
889 | result = i2400m_msg_check_status(wimax_msg_data(ack_skb), | |
890 | strerr, sizeof(strerr)); | |
891 | if (result == -EACCES) | |
892 | d_printf(1, dev, "Cannot enter power save mode\n"); | |
893 | else if (result < 0) | |
894 | dev_err(dev, "'Enter power save' (0x%04x) command failed: " | |
895 | "%d - %s\n", I2400M_MT_CMD_ENTER_POWERSAVE, | |
896 | result, strerr); | |
897 | else | |
898 | d_printf(1, dev, "device ready to power save\n"); | |
899 | kfree_skb(ack_skb); | |
900 | error_msg_to_dev: | |
901 | kfree(cmd); | |
902 | error_alloc: | |
903 | return result; | |
904 | } | |
905 | EXPORT_SYMBOL_GPL(i2400m_cmd_enter_powersave); | |
906 | ||
907 | ||
908 | /* | |
909 | * Definitions for getting device information | |
910 | */ | |
911 | enum { | |
912 | I2400M_TLV_DETAILED_DEVICE_INFO = 140 | |
913 | }; | |
914 | ||
915 | /** | |
916 | * i2400m_get_device_info - Query the device for detailed device information | |
917 | * | |
918 | * @i2400m: device descriptor | |
919 | * | |
920 | * Returns: an skb whose skb->data points to a 'struct | |
921 | * i2400m_tlv_detailed_device_info'. When done, kfree_skb() it. The | |
922 | * skb is *guaranteed* to contain the whole TLV data structure. | |
923 | * | |
924 | * On error, IS_ERR(skb) is true and ERR_PTR(skb) is the error | |
925 | * code. | |
926 | */ | |
927 | struct sk_buff *i2400m_get_device_info(struct i2400m *i2400m) | |
928 | { | |
929 | int result; | |
930 | struct device *dev = i2400m_dev(i2400m); | |
931 | struct sk_buff *ack_skb; | |
932 | struct i2400m_l3l4_hdr *cmd; | |
933 | const struct i2400m_l3l4_hdr *ack; | |
934 | size_t ack_len; | |
935 | const struct i2400m_tlv_hdr *tlv; | |
936 | const struct i2400m_tlv_detailed_device_info *ddi; | |
937 | char strerr[32]; | |
938 | ||
939 | ack_skb = ERR_PTR(-ENOMEM); | |
940 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
941 | if (cmd == NULL) | |
942 | goto error_alloc; | |
943 | cmd->type = cpu_to_le16(I2400M_MT_GET_DEVICE_INFO); | |
944 | cmd->length = 0; | |
945 | cmd->version = cpu_to_le16(I2400M_L3L4_VERSION); | |
946 | ||
947 | ack_skb = i2400m_msg_to_dev(i2400m, cmd, sizeof(*cmd)); | |
948 | if (IS_ERR(ack_skb)) { | |
949 | dev_err(dev, "Failed to issue 'get device info' command: %ld\n", | |
950 | PTR_ERR(ack_skb)); | |
951 | goto error_msg_to_dev; | |
952 | } | |
953 | ack = wimax_msg_data_len(ack_skb, &ack_len); | |
954 | result = i2400m_msg_check_status(ack, strerr, sizeof(strerr)); | |
955 | if (result < 0) { | |
956 | dev_err(dev, "'get device info' (0x%04x) command failed: " | |
957 | "%d - %s\n", I2400M_MT_GET_DEVICE_INFO, result, | |
958 | strerr); | |
959 | goto error_cmd_failed; | |
960 | } | |
961 | tlv = i2400m_tlv_find(i2400m, ack->pl, ack_len - sizeof(*ack), | |
962 | I2400M_TLV_DETAILED_DEVICE_INFO, sizeof(*ddi)); | |
963 | if (tlv == NULL) { | |
964 | dev_err(dev, "GET DEVICE INFO: " | |
965 | "detailed device info TLV not found (0x%04x)\n", | |
966 | I2400M_TLV_DETAILED_DEVICE_INFO); | |
967 | result = -EIO; | |
968 | goto error_no_tlv; | |
969 | } | |
970 | skb_pull(ack_skb, (void *) tlv - (void *) ack_skb->data); | |
971 | error_msg_to_dev: | |
972 | kfree(cmd); | |
973 | error_alloc: | |
974 | return ack_skb; | |
975 | ||
976 | error_no_tlv: | |
977 | error_cmd_failed: | |
978 | kfree_skb(ack_skb); | |
979 | kfree(cmd); | |
980 | return ERR_PTR(result); | |
981 | } | |
982 | ||
983 | ||
984 | /* Firmware interface versions we support */ | |
985 | enum { | |
986 | I2400M_HDIv_MAJOR = 9, | |
3a35a1d0 | 987 | I2400M_HDIv_MINOR = 1, |
efa05d0f | 988 | I2400M_HDIv_MINOR_2 = 2, |
3a35a1d0 IPG |
989 | }; |
990 | ||
991 | ||
992 | /** | |
993 | * i2400m_firmware_check - check firmware versions are compatible with | |
994 | * the driver | |
995 | * | |
996 | * @i2400m: device descriptor | |
997 | * | |
998 | * Returns: 0 if ok, < 0 errno code an error and a message in the | |
999 | * kernel log. | |
1000 | * | |
1001 | * Long function, but quite simple; first chunk launches the command | |
1002 | * and double checks the reply for the right TLV. Then we process the | |
1003 | * TLV (where the meat is). | |
6a0f7ab8 IPG |
1004 | * |
1005 | * Once we process the TLV that gives us the firmware's interface | |
1006 | * version, we encode it and save it in i2400m->fw_version for future | |
1007 | * reference. | |
3a35a1d0 IPG |
1008 | */ |
1009 | int i2400m_firmware_check(struct i2400m *i2400m) | |
1010 | { | |
1011 | int result; | |
1012 | struct device *dev = i2400m_dev(i2400m); | |
1013 | struct sk_buff *ack_skb; | |
1014 | struct i2400m_l3l4_hdr *cmd; | |
1015 | const struct i2400m_l3l4_hdr *ack; | |
1016 | size_t ack_len; | |
1017 | const struct i2400m_tlv_hdr *tlv; | |
1018 | const struct i2400m_tlv_l4_message_versions *l4mv; | |
1019 | char strerr[32]; | |
1020 | unsigned major, minor, branch; | |
1021 | ||
1022 | result = -ENOMEM; | |
1023 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
1024 | if (cmd == NULL) | |
1025 | goto error_alloc; | |
1026 | cmd->type = cpu_to_le16(I2400M_MT_GET_LM_VERSION); | |
1027 | cmd->length = 0; | |
1028 | cmd->version = cpu_to_le16(I2400M_L3L4_VERSION); | |
1029 | ||
1030 | ack_skb = i2400m_msg_to_dev(i2400m, cmd, sizeof(*cmd)); | |
1031 | if (IS_ERR(ack_skb)) { | |
1032 | result = PTR_ERR(ack_skb); | |
1033 | dev_err(dev, "Failed to issue 'get lm version' command: %-d\n", | |
1034 | result); | |
1035 | goto error_msg_to_dev; | |
1036 | } | |
1037 | ack = wimax_msg_data_len(ack_skb, &ack_len); | |
1038 | result = i2400m_msg_check_status(ack, strerr, sizeof(strerr)); | |
1039 | if (result < 0) { | |
1040 | dev_err(dev, "'get lm version' (0x%04x) command failed: " | |
1041 | "%d - %s\n", I2400M_MT_GET_LM_VERSION, result, | |
1042 | strerr); | |
1043 | goto error_cmd_failed; | |
1044 | } | |
1045 | tlv = i2400m_tlv_find(i2400m, ack->pl, ack_len - sizeof(*ack), | |
1046 | I2400M_TLV_L4_MESSAGE_VERSIONS, sizeof(*l4mv)); | |
1047 | if (tlv == NULL) { | |
1048 | dev_err(dev, "get lm version: TLV not found (0x%04x)\n", | |
1049 | I2400M_TLV_L4_MESSAGE_VERSIONS); | |
1050 | result = -EIO; | |
1051 | goto error_no_tlv; | |
1052 | } | |
1053 | l4mv = container_of(tlv, typeof(*l4mv), hdr); | |
1054 | major = le16_to_cpu(l4mv->major); | |
1055 | minor = le16_to_cpu(l4mv->minor); | |
1056 | branch = le16_to_cpu(l4mv->branch); | |
1057 | result = -EINVAL; | |
efa05d0f IPG |
1058 | if (major != I2400M_HDIv_MAJOR) { |
1059 | dev_err(dev, "unsupported major fw version " | |
3a35a1d0 IPG |
1060 | "%u.%u.%u\n", major, minor, branch); |
1061 | goto error_bad_major; | |
1062 | } | |
3a35a1d0 | 1063 | result = 0; |
efa05d0f IPG |
1064 | if (minor < I2400M_HDIv_MINOR_2 && minor > I2400M_HDIv_MINOR) |
1065 | dev_warn(dev, "untested minor fw version %u.%u.%u\n", | |
3a35a1d0 | 1066 | major, minor, branch); |
6a0f7ab8 IPG |
1067 | /* Yes, we ignore the branch -- we don't have to track it */ |
1068 | i2400m->fw_version = major << 16 | minor; | |
3a35a1d0 IPG |
1069 | dev_info(dev, "firmware interface version %u.%u.%u\n", |
1070 | major, minor, branch); | |
6a0f7ab8 | 1071 | error_bad_major: |
3a35a1d0 IPG |
1072 | error_no_tlv: |
1073 | error_cmd_failed: | |
1074 | kfree_skb(ack_skb); | |
1075 | error_msg_to_dev: | |
1076 | kfree(cmd); | |
1077 | error_alloc: | |
1078 | return result; | |
1079 | } | |
1080 | ||
1081 | ||
1082 | /* | |
1083 | * Send an DoExitIdle command to the device to ask it to go out of | |
1084 | * basestation-idle mode. | |
1085 | * | |
1086 | * @i2400m: device descriptor | |
1087 | * | |
1088 | * This starts a renegotiation with the basestation that might involve | |
1089 | * another crypto handshake with user space. | |
1090 | * | |
1091 | * Returns: 0 if ok, < 0 errno code on error. | |
1092 | */ | |
1093 | int i2400m_cmd_exit_idle(struct i2400m *i2400m) | |
1094 | { | |
1095 | int result; | |
1096 | struct device *dev = i2400m_dev(i2400m); | |
1097 | struct sk_buff *ack_skb; | |
1098 | struct i2400m_l3l4_hdr *cmd; | |
1099 | char strerr[32]; | |
1100 | ||
1101 | result = -ENOMEM; | |
1102 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
1103 | if (cmd == NULL) | |
1104 | goto error_alloc; | |
1105 | cmd->type = cpu_to_le16(I2400M_MT_CMD_EXIT_IDLE); | |
1106 | cmd->length = 0; | |
1107 | cmd->version = cpu_to_le16(I2400M_L3L4_VERSION); | |
1108 | ||
1109 | ack_skb = i2400m_msg_to_dev(i2400m, cmd, sizeof(*cmd)); | |
1110 | result = PTR_ERR(ack_skb); | |
1111 | if (IS_ERR(ack_skb)) { | |
1112 | dev_err(dev, "Failed to issue 'exit idle' command: %d\n", | |
1113 | result); | |
1114 | goto error_msg_to_dev; | |
1115 | } | |
1116 | result = i2400m_msg_check_status(wimax_msg_data(ack_skb), | |
1117 | strerr, sizeof(strerr)); | |
1118 | kfree_skb(ack_skb); | |
1119 | error_msg_to_dev: | |
1120 | kfree(cmd); | |
1121 | error_alloc: | |
1122 | return result; | |
1123 | ||
1124 | } | |
1125 | ||
1126 | ||
1127 | /* | |
1128 | * Query the device for its state, update the WiMAX stack's idea of it | |
1129 | * | |
1130 | * @i2400m: device descriptor | |
1131 | * | |
1132 | * Returns: 0 if ok, < 0 errno code on error. | |
1133 | * | |
1134 | * Executes a 'Get State' command and parses the returned | |
1135 | * TLVs. | |
1136 | * | |
1137 | * Because this is almost identical to a 'Report State', we use | |
1138 | * i2400m_report_state_hook() to parse the answer. This will set the | |
1139 | * carrier state, as well as the RF Kill switches state. | |
1140 | */ | |
e3d32687 | 1141 | static int i2400m_cmd_get_state(struct i2400m *i2400m) |
3a35a1d0 IPG |
1142 | { |
1143 | int result; | |
1144 | struct device *dev = i2400m_dev(i2400m); | |
1145 | struct sk_buff *ack_skb; | |
1146 | struct i2400m_l3l4_hdr *cmd; | |
1147 | const struct i2400m_l3l4_hdr *ack; | |
1148 | size_t ack_len; | |
1149 | char strerr[32]; | |
1150 | ||
1151 | result = -ENOMEM; | |
1152 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
1153 | if (cmd == NULL) | |
1154 | goto error_alloc; | |
1155 | cmd->type = cpu_to_le16(I2400M_MT_GET_STATE); | |
1156 | cmd->length = 0; | |
1157 | cmd->version = cpu_to_le16(I2400M_L3L4_VERSION); | |
1158 | ||
1159 | ack_skb = i2400m_msg_to_dev(i2400m, cmd, sizeof(*cmd)); | |
1160 | if (IS_ERR(ack_skb)) { | |
1161 | dev_err(dev, "Failed to issue 'get state' command: %ld\n", | |
1162 | PTR_ERR(ack_skb)); | |
1163 | result = PTR_ERR(ack_skb); | |
1164 | goto error_msg_to_dev; | |
1165 | } | |
1166 | ack = wimax_msg_data_len(ack_skb, &ack_len); | |
1167 | result = i2400m_msg_check_status(ack, strerr, sizeof(strerr)); | |
1168 | if (result < 0) { | |
1169 | dev_err(dev, "'get state' (0x%04x) command failed: " | |
1170 | "%d - %s\n", I2400M_MT_GET_STATE, result, strerr); | |
1171 | goto error_cmd_failed; | |
1172 | } | |
1173 | i2400m_report_state_hook(i2400m, ack, ack_len - sizeof(*ack), | |
1174 | "GET STATE"); | |
1175 | result = 0; | |
1176 | kfree_skb(ack_skb); | |
1177 | error_cmd_failed: | |
1178 | error_msg_to_dev: | |
1179 | kfree(cmd); | |
1180 | error_alloc: | |
1181 | return result; | |
1182 | } | |
3a35a1d0 IPG |
1183 | |
1184 | /** | |
1185 | * Set basic configuration settings | |
1186 | * | |
1187 | * @i2400m: device descriptor | |
1188 | * @args: array of pointers to the TLV headers to send for | |
1189 | * configuration (each followed by its payload). | |
1190 | * TLV headers and payloads must be properly initialized, with the | |
1191 | * right endianess (LE). | |
1192 | * @arg_size: number of pointers in the @args array | |
1193 | */ | |
e3d32687 | 1194 | static int i2400m_set_init_config(struct i2400m *i2400m, |
1195 | const struct i2400m_tlv_hdr **arg, | |
1196 | size_t args) | |
3a35a1d0 IPG |
1197 | { |
1198 | int result; | |
1199 | struct device *dev = i2400m_dev(i2400m); | |
1200 | struct sk_buff *ack_skb; | |
1201 | struct i2400m_l3l4_hdr *cmd; | |
1202 | char strerr[32]; | |
1203 | unsigned argc, argsize, tlv_size; | |
1204 | const struct i2400m_tlv_hdr *tlv_hdr; | |
1205 | void *buf, *itr; | |
1206 | ||
1207 | d_fnstart(3, dev, "(i2400m %p arg %p args %zu)\n", i2400m, arg, args); | |
1208 | result = 0; | |
1209 | if (args == 0) | |
1210 | goto none; | |
1211 | /* Compute the size of all the TLVs, so we can alloc a | |
1212 | * contiguous command block to copy them. */ | |
1213 | argsize = 0; | |
1214 | for (argc = 0; argc < args; argc++) { | |
1215 | tlv_hdr = arg[argc]; | |
1216 | argsize += sizeof(*tlv_hdr) + le16_to_cpu(tlv_hdr->length); | |
1217 | } | |
1218 | WARN_ON(argc >= 9); /* As per hw spec */ | |
1219 | ||
1220 | /* Alloc the space for the command and TLVs*/ | |
1221 | result = -ENOMEM; | |
1222 | buf = kzalloc(sizeof(*cmd) + argsize, GFP_KERNEL); | |
1223 | if (buf == NULL) | |
1224 | goto error_alloc; | |
1225 | cmd = buf; | |
1226 | cmd->type = cpu_to_le16(I2400M_MT_SET_INIT_CONFIG); | |
1227 | cmd->length = cpu_to_le16(argsize); | |
1228 | cmd->version = cpu_to_le16(I2400M_L3L4_VERSION); | |
1229 | ||
1230 | /* Copy the TLVs */ | |
1231 | itr = buf + sizeof(*cmd); | |
1232 | for (argc = 0; argc < args; argc++) { | |
1233 | tlv_hdr = arg[argc]; | |
1234 | tlv_size = sizeof(*tlv_hdr) + le16_to_cpu(tlv_hdr->length); | |
1235 | memcpy(itr, tlv_hdr, tlv_size); | |
1236 | itr += tlv_size; | |
1237 | } | |
1238 | ||
1239 | /* Send the message! */ | |
1240 | ack_skb = i2400m_msg_to_dev(i2400m, buf, sizeof(*cmd) + argsize); | |
1241 | result = PTR_ERR(ack_skb); | |
1242 | if (IS_ERR(ack_skb)) { | |
1243 | dev_err(dev, "Failed to issue 'init config' command: %d\n", | |
1244 | result); | |
1245 | ||
1246 | goto error_msg_to_dev; | |
1247 | } | |
1248 | result = i2400m_msg_check_status(wimax_msg_data(ack_skb), | |
1249 | strerr, sizeof(strerr)); | |
1250 | if (result < 0) | |
1251 | dev_err(dev, "'init config' (0x%04x) command failed: %d - %s\n", | |
1252 | I2400M_MT_SET_INIT_CONFIG, result, strerr); | |
1253 | kfree_skb(ack_skb); | |
1254 | error_msg_to_dev: | |
1255 | kfree(buf); | |
1256 | error_alloc: | |
1257 | none: | |
1258 | d_fnend(3, dev, "(i2400m %p arg %p args %zu) = %d\n", | |
1259 | i2400m, arg, args, result); | |
1260 | return result; | |
1261 | ||
1262 | } | |
3a35a1d0 | 1263 | |
8987691a IPG |
1264 | /** |
1265 | * i2400m_set_idle_timeout - Set the device's idle mode timeout | |
1266 | * | |
1267 | * @i2400m: i2400m device descriptor | |
1268 | * | |
1269 | * @msecs: milliseconds for the timeout to enter idle mode. Between | |
1270 | * 100 to 300000 (5m); 0 to disable. In increments of 100. | |
1271 | * | |
1272 | * After this @msecs of the link being idle (no data being sent or | |
1273 | * received), the device will negotiate with the basestation entering | |
1274 | * idle mode for saving power. The connection is maintained, but | |
1275 | * getting out of it (done in tx.c) will require some negotiation, | |
1276 | * possible crypto re-handshake and a possible DHCP re-lease. | |
1277 | * | |
1278 | * Only available if fw_version >= 0x00090002. | |
1279 | * | |
1280 | * Returns: 0 if ok, < 0 errno code on error. | |
1281 | */ | |
1282 | int i2400m_set_idle_timeout(struct i2400m *i2400m, unsigned msecs) | |
1283 | { | |
1284 | int result; | |
1285 | struct device *dev = i2400m_dev(i2400m); | |
1286 | struct sk_buff *ack_skb; | |
1287 | struct { | |
1288 | struct i2400m_l3l4_hdr hdr; | |
1289 | struct i2400m_tlv_config_idle_timeout cit; | |
1290 | } *cmd; | |
1291 | const struct i2400m_l3l4_hdr *ack; | |
1292 | size_t ack_len; | |
1293 | char strerr[32]; | |
1294 | ||
1295 | result = -ENOSYS; | |
1296 | if (i2400m_le_v1_3(i2400m)) | |
1297 | goto error_alloc; | |
1298 | result = -ENOMEM; | |
1299 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
1300 | if (cmd == NULL) | |
1301 | goto error_alloc; | |
1302 | cmd->hdr.type = cpu_to_le16(I2400M_MT_GET_STATE); | |
1303 | cmd->hdr.length = cpu_to_le16(sizeof(*cmd) - sizeof(cmd->hdr)); | |
1304 | cmd->hdr.version = cpu_to_le16(I2400M_L3L4_VERSION); | |
1305 | ||
1306 | cmd->cit.hdr.type = | |
1307 | cpu_to_le16(I2400M_TLV_CONFIG_IDLE_TIMEOUT); | |
1308 | cmd->cit.hdr.length = cpu_to_le16(sizeof(cmd->cit.timeout)); | |
1309 | cmd->cit.timeout = cpu_to_le32(msecs); | |
1310 | ||
1311 | ack_skb = i2400m_msg_to_dev(i2400m, cmd, sizeof(*cmd)); | |
1312 | if (IS_ERR(ack_skb)) { | |
1313 | dev_err(dev, "Failed to issue 'set idle timeout' command: " | |
1314 | "%ld\n", PTR_ERR(ack_skb)); | |
1315 | result = PTR_ERR(ack_skb); | |
1316 | goto error_msg_to_dev; | |
1317 | } | |
1318 | ack = wimax_msg_data_len(ack_skb, &ack_len); | |
1319 | result = i2400m_msg_check_status(ack, strerr, sizeof(strerr)); | |
1320 | if (result < 0) { | |
1321 | dev_err(dev, "'set idle timeout' (0x%04x) command failed: " | |
1322 | "%d - %s\n", I2400M_MT_GET_STATE, result, strerr); | |
1323 | goto error_cmd_failed; | |
1324 | } | |
1325 | result = 0; | |
1326 | kfree_skb(ack_skb); | |
1327 | error_cmd_failed: | |
1328 | error_msg_to_dev: | |
1329 | kfree(cmd); | |
1330 | error_alloc: | |
1331 | return result; | |
1332 | } | |
1333 | ||
1334 | ||
3a35a1d0 IPG |
1335 | /** |
1336 | * i2400m_dev_initialize - Initialize the device once communications are ready | |
1337 | * | |
1338 | * @i2400m: device descriptor | |
1339 | * | |
1340 | * Returns: 0 if ok, < 0 errno code on error. | |
1341 | * | |
1342 | * Configures the device to work the way we like it. | |
1343 | * | |
1344 | * At the point of this call, the device is registered with the WiMAX | |
1345 | * and netdev stacks, firmware is uploaded and we can talk to the | |
1346 | * device normally. | |
1347 | */ | |
1348 | int i2400m_dev_initialize(struct i2400m *i2400m) | |
1349 | { | |
1350 | int result; | |
1351 | struct device *dev = i2400m_dev(i2400m); | |
1352 | struct i2400m_tlv_config_idle_parameters idle_params; | |
8987691a | 1353 | struct i2400m_tlv_config_idle_timeout idle_timeout; |
fd5c565c | 1354 | struct i2400m_tlv_config_d2h_data_format df; |
c747583d | 1355 | struct i2400m_tlv_config_dl_host_reorder dlhr; |
3a35a1d0 IPG |
1356 | const struct i2400m_tlv_hdr *args[9]; |
1357 | unsigned argc = 0; | |
1358 | ||
1359 | d_fnstart(3, dev, "(i2400m %p)\n", i2400m); | |
55a662d6 IPG |
1360 | if (i2400m_passive_mode) |
1361 | goto out_passive; | |
c747583d | 1362 | /* Disable idle mode? (enabled by default) */ |
3a35a1d0 | 1363 | if (i2400m_idle_mode_disabled) { |
8987691a IPG |
1364 | if (i2400m_le_v1_3(i2400m)) { |
1365 | idle_params.hdr.type = | |
1366 | cpu_to_le16(I2400M_TLV_CONFIG_IDLE_PARAMETERS); | |
1367 | idle_params.hdr.length = cpu_to_le16( | |
1368 | sizeof(idle_params) - sizeof(idle_params.hdr)); | |
1369 | idle_params.idle_timeout = 0; | |
1370 | idle_params.idle_paging_interval = 0; | |
1371 | args[argc++] = &idle_params.hdr; | |
1372 | } else { | |
1373 | idle_timeout.hdr.type = | |
1374 | cpu_to_le16(I2400M_TLV_CONFIG_IDLE_TIMEOUT); | |
1375 | idle_timeout.hdr.length = cpu_to_le16( | |
1376 | sizeof(idle_timeout) - sizeof(idle_timeout.hdr)); | |
1377 | idle_timeout.timeout = 0; | |
1378 | args[argc++] = &idle_timeout.hdr; | |
1379 | } | |
3a35a1d0 | 1380 | } |
fd5c565c | 1381 | if (i2400m_ge_v1_4(i2400m)) { |
c747583d | 1382 | /* Enable extended RX data format? */ |
fd5c565c IPG |
1383 | df.hdr.type = |
1384 | cpu_to_le16(I2400M_TLV_CONFIG_D2H_DATA_FORMAT); | |
1385 | df.hdr.length = cpu_to_le16( | |
1386 | sizeof(df) - sizeof(df.hdr)); | |
1387 | df.format = 1; | |
1388 | args[argc++] = &df.hdr; | |
c747583d IPG |
1389 | |
1390 | /* Enable RX data reordering? | |
1391 | * (switch flipped in rx.c:i2400m_rx_setup() after fw upload) */ | |
1392 | if (i2400m->rx_reorder) { | |
1393 | dlhr.hdr.type = | |
1394 | cpu_to_le16(I2400M_TLV_CONFIG_DL_HOST_REORDER); | |
1395 | dlhr.hdr.length = cpu_to_le16( | |
1396 | sizeof(dlhr) - sizeof(dlhr.hdr)); | |
1397 | dlhr.reorder = 1; | |
1398 | args[argc++] = &dlhr.hdr; | |
1399 | } | |
fd5c565c | 1400 | } |
3a35a1d0 | 1401 | result = i2400m_set_init_config(i2400m, args, argc); |
3a35a1d0 IPG |
1402 | if (result < 0) |
1403 | goto error; | |
55a662d6 | 1404 | out_passive: |
3a35a1d0 IPG |
1405 | /* |
1406 | * Update state: Here it just calls a get state; parsing the | |
1407 | * result (System State TLV and RF Status TLV [done in the rx | |
1408 | * path hooks]) will set the hardware and software RF-Kill | |
1409 | * status. | |
1410 | */ | |
1411 | result = i2400m_cmd_get_state(i2400m); | |
1412 | error: | |
8987691a IPG |
1413 | if (result < 0) |
1414 | dev_err(dev, "failed to initialize the device: %d\n", result); | |
3a35a1d0 IPG |
1415 | d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result); |
1416 | return result; | |
1417 | } | |
1418 | ||
1419 | ||
1420 | /** | |
1421 | * i2400m_dev_shutdown - Shutdown a running device | |
1422 | * | |
1423 | * @i2400m: device descriptor | |
1424 | * | |
b4bd07e3 IPG |
1425 | * Release resources acquired during the running of the device; in |
1426 | * theory, should also tell the device to go to sleep, switch off the | |
1427 | * radio, all that, but at this point, in most cases (driver | |
1428 | * disconnection, reset handling) we can't even talk to the device. | |
3a35a1d0 IPG |
1429 | */ |
1430 | void i2400m_dev_shutdown(struct i2400m *i2400m) | |
1431 | { | |
3a35a1d0 IPG |
1432 | struct device *dev = i2400m_dev(i2400m); |
1433 | ||
1434 | d_fnstart(3, dev, "(i2400m %p)\n", i2400m); | |
b4bd07e3 | 1435 | d_fnend(3, dev, "(i2400m %p) = void\n", i2400m); |
3a35a1d0 | 1436 | } |