linux/drivers/net/wimax/i2400m/control.c
<<
>>
Prefs
   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 *
  53 * i2400m_dev_initialize()       Called by i2400m_dev_start()
  54 *   i2400m_set_init_config()
  55 *   i2400m_cmd_get_state()
  56 * i2400m_dev_shutdown()        Called by i2400m_dev_stop()
  57 *   i2400m_reset()
  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>
  79#include <linux/slab.h>
  80#include <linux/wimax/i2400m.h>
  81#include <linux/export.h>
  82#include <linux/moduleparam.h>
  83
  84
  85#define D_SUBMODULE control
  86#include "debug-levels.h"
  87
  88static int i2400m_idle_mode_disabled;/* 0 (idle mode enabled) by default */
  89module_param_named(idle_mode_disabled, i2400m_idle_mode_disabled, int, 0644);
  90MODULE_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 */
  95static int i2400m_power_save_disabled;
  96module_param_named(power_save_disabled, i2400m_power_save_disabled, int, 0644);
  97MODULE_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
 103static int i2400m_passive_mode; /* 0 (passive mode disabled) by default */
 104module_param_named(passive_mode, i2400m_passive_mode, int, 0644);
 105MODULE_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
 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 */
 123static
 124ssize_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 "
 133                       "size (got %zu vs %zd expected)\n",
 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 */
 160static
 161const 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        }
 202error_short_header:
 203error_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 */
 223static
 224const 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 "
 238                                 "mismatch (%zu vs %zd needed)\n",
 239                                 tlv_type, match, tlv_size);
 240        }
 241        return tlv;
 242}
 243
 244
 245static 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 */
 282int 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;
 291        if (status >= ARRAY_SIZE(ms_to_errno)) {
 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 */
 310static
 311void 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
 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);
 364                i2400m_reset(i2400m, I2400M_RT_WARM);
 365                break;
 366        }
 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 *
 383 * In fact, doc says that every time we get a link-up, we should do a
 384 * DHCP negotiation...
 385 */
 386static
 387void 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
 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);
 415        }
 416        d_fnend(3, dev, "(i2400m %p ms %p [%u]) = void\n",
 417                i2400m, ms, status);
 418}
 419
 420
 421/*
 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 */
 431static
 432void 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
 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 *
 477 * Walk over the TLVs in a report state and act on them.
 478 */
 479static
 480void 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;
 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,
 493                                             tlv_size, tlv)))
 494                i2400m_report_state_parse_tlv(i2400m, tlv, tag);
 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 */
 513void 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)) {
 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                        }
 542                }
 543                break;
 544        }
 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 */
 563static void i2400m_msg_ack_hook(struct i2400m *i2400m,
 564                                 const struct i2400m_l3l4_hdr *l3l4_hdr,
 565                                 size_t size)
 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;
 588        }
 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 */
 598int 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;
 622error_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 */
 640void 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))
 648                kfree_skb(ack_skb);
 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(),
 680 * it contains the response in a netlink attribute and is ready to be
 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 */
 707struct 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
 723        rmb();          /* Make sure we see what i2400m_dev_reset_handle() */
 724        if (i2400m->boot_mode)
 725                return ERR_PTR(-EL3RST);
 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;
 760        }
 761
 762        if (unlikely(i2400m->trace_msg_from_user))
 763                wimax_msg(&i2400m->wimax_dev, "echo", buf, buf_len, GFP_KERNEL);
 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 */
 798        if (unlikely(i2400m->trace_msg_from_user))
 799                wimax_msg(&i2400m->wimax_dev, "echo",
 800                          ack_l3l4_hdr, ack_len, GFP_KERNEL);
 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
 819error_bad_ack_type:
 820error_bad_ack_len:
 821        kfree_skb(ack_skb);
 822error_ack_status:
 823error_wait_for_completion:
 824error_tx:
 825        mutex_unlock(&i2400m->msg_mutex);
 826error_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 */
 844enum {
 845        I2400M_WAKEUP_ENABLED  = 0x01,
 846        I2400M_WAKEUP_DISABLED = 0x02,
 847        I2400M_TLV_TYPE_WAKEUP_MODE = 144,
 848};
 849
 850struct i2400m_cmd_enter_power_save {
 851        struct i2400m_l3l4_hdr hdr;
 852        struct i2400m_tlv_hdr tlv;
 853        __le32 val;
 854} __packed;
 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 */
 863int 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);
 900error_msg_to_dev:
 901        kfree(cmd);
 902error_alloc:
 903        return result;
 904}
 905EXPORT_SYMBOL_GPL(i2400m_cmd_enter_powersave);
 906
 907
 908/*
 909 * Definitions for getting device information
 910 */
 911enum {
 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 */
 927struct 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);
 971error_msg_to_dev:
 972        kfree(cmd);
 973error_alloc:
 974        return ack_skb;
 975
 976error_no_tlv:
 977error_cmd_failed:
 978        kfree_skb(ack_skb);
 979        kfree(cmd);
 980        return ERR_PTR(result);
 981}
 982
 983
 984/* Firmware interface versions we support */
 985enum {
 986        I2400M_HDIv_MAJOR = 9,
 987        I2400M_HDIv_MINOR = 1,
 988        I2400M_HDIv_MINOR_2 = 2,
 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).
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.
1008 */
1009int 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;
1058        if (major != I2400M_HDIv_MAJOR) {
1059                dev_err(dev, "unsupported major fw version "
1060                        "%u.%u.%u\n", major, minor, branch);
1061                goto error_bad_major;
1062        }
1063        result = 0;
1064        if (minor < I2400M_HDIv_MINOR_2 && minor > I2400M_HDIv_MINOR)
1065                dev_warn(dev, "untested minor fw version %u.%u.%u\n",
1066                         major, minor, branch);
1067        /* Yes, we ignore the branch -- we don't have to track it */
1068        i2400m->fw_version = major << 16 | minor;
1069        dev_info(dev, "firmware interface version %u.%u.%u\n",
1070                 major, minor, branch);
1071error_bad_major:
1072error_no_tlv:
1073error_cmd_failed:
1074        kfree_skb(ack_skb);
1075error_msg_to_dev:
1076        kfree(cmd);
1077error_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 */
1093int 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);
1119error_msg_to_dev:
1120        kfree(cmd);
1121error_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 */
1141static int i2400m_cmd_get_state(struct i2400m *i2400m)
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);
1177error_cmd_failed:
1178error_msg_to_dev:
1179        kfree(cmd);
1180error_alloc:
1181        return result;
1182}
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 */
1194static int i2400m_set_init_config(struct i2400m *i2400m,
1195                                  const struct i2400m_tlv_hdr **arg,
1196                                  size_t args)
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);
1254error_msg_to_dev:
1255        kfree(buf);
1256error_alloc:
1257none:
1258        d_fnend(3, dev, "(i2400m %p arg %p args %zu) = %d\n",
1259                i2400m, arg, args, result);
1260        return result;
1261
1262}
1263
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 */
1282int 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);
1327error_cmd_failed:
1328error_msg_to_dev:
1329        kfree(cmd);
1330error_alloc:
1331        return result;
1332}
1333
1334
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 */
1348int 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;
1353        struct i2400m_tlv_config_idle_timeout idle_timeout;
1354        struct i2400m_tlv_config_d2h_data_format df;
1355        struct i2400m_tlv_config_dl_host_reorder dlhr;
1356        const struct i2400m_tlv_hdr *args[9];
1357        unsigned argc = 0;
1358
1359        d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
1360        if (i2400m_passive_mode)
1361                goto out_passive;
1362        /* Disable idle mode? (enabled by default) */
1363        if (i2400m_idle_mode_disabled) {
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                }
1380        }
1381        if (i2400m_ge_v1_4(i2400m)) {
1382                /* Enable extended RX data format? */
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;
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                }
1400        }
1401        result = i2400m_set_init_config(i2400m, args, argc);
1402        if (result < 0)
1403                goto error;
1404out_passive:
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);
1412error:
1413        if (result < 0)
1414                dev_err(dev, "failed to initialize the device: %d\n", result);
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 *
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.
1429 */
1430void i2400m_dev_shutdown(struct i2400m *i2400m)
1431{
1432        struct device *dev = i2400m_dev(i2400m);
1433
1434        d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
1435        d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
1436}
1437