linux/drivers/uwb/reset.c
<<
>>
Prefs
   1/*
   2 * Ultra Wide Band
   3 * UWB basic command support and radio reset
   4 *
   5 * Copyright (C) 2005-2006 Intel Corporation
   6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   7 *
   8 * This program is free software; you can redistribute it and/or
   9 * modify it under the terms of the GNU General Public License version
  10 * 2 as published by the Free Software Foundation.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20 * 02110-1301, USA.
  21 *
  22 *
  23 * FIXME:
  24 *
  25 *  - docs
  26 *
  27 *  - Now we are serializing (using the uwb_dev->mutex) the command
  28 *    execution; it should be parallelized as much as possible some
  29 *    day.
  30 */
  31#include <linux/kernel.h>
  32#include <linux/err.h>
  33#include <linux/slab.h>
  34#include <linux/delay.h>
  35#include <linux/export.h>
  36
  37#include "uwb-internal.h"
  38
  39/**
  40 * Command result codes (WUSB1.0[T8-69])
  41 */
  42static
  43const char *__strerror[] = {
  44        "success",
  45        "failure",
  46        "hardware failure",
  47        "no more slots",
  48        "beacon is too large",
  49        "invalid parameter",
  50        "unsupported power level",
  51        "time out (wa) or invalid ie data (whci)",
  52        "beacon size exceeded",
  53        "cancelled",
  54        "invalid state",
  55        "invalid size",
  56        "ack not received",
  57        "no more asie notification",
  58};
  59
  60
  61/** Return a string matching the given error code */
  62const char *uwb_rc_strerror(unsigned code)
  63{
  64        if (code == 255)
  65                return "time out";
  66        if (code >= ARRAY_SIZE(__strerror))
  67                return "unknown error";
  68        return __strerror[code];
  69}
  70
  71int uwb_rc_cmd_async(struct uwb_rc *rc, const char *cmd_name,
  72                     struct uwb_rccb *cmd, size_t cmd_size,
  73                     u8 expected_type, u16 expected_event,
  74                     uwb_rc_cmd_cb_f cb, void *arg)
  75{
  76        struct device *dev = &rc->uwb_dev.dev;
  77        struct uwb_rc_neh *neh;
  78        int needtofree = 0;
  79        int result;
  80
  81        uwb_dev_lock(&rc->uwb_dev);     /* Protect against rc->priv being removed */
  82        if (rc->priv == NULL) {
  83                uwb_dev_unlock(&rc->uwb_dev);
  84                return -ESHUTDOWN;
  85        }
  86
  87        if (rc->filter_cmd) {
  88                needtofree = rc->filter_cmd(rc, &cmd, &cmd_size);
  89                if (needtofree < 0 && needtofree != -ENOANO) {
  90                        dev_err(dev, "%s: filter error: %d\n",
  91                                cmd_name, needtofree);
  92                        uwb_dev_unlock(&rc->uwb_dev);
  93                        return needtofree;
  94                }
  95        }
  96
  97        neh = uwb_rc_neh_add(rc, cmd, expected_type, expected_event, cb, arg);
  98        if (IS_ERR(neh)) {
  99                result = PTR_ERR(neh);
 100                uwb_dev_unlock(&rc->uwb_dev);
 101                goto out;
 102        }
 103
 104        result = rc->cmd(rc, cmd, cmd_size);
 105        uwb_dev_unlock(&rc->uwb_dev);
 106        if (result < 0)
 107                uwb_rc_neh_rm(rc, neh);
 108        else
 109                uwb_rc_neh_arm(rc, neh);
 110        uwb_rc_neh_put(neh);
 111out:
 112        if (needtofree == 1)
 113                kfree(cmd);
 114        return result < 0 ? result : 0;
 115}
 116EXPORT_SYMBOL_GPL(uwb_rc_cmd_async);
 117
 118struct uwb_rc_cmd_done_params {
 119        struct completion completion;
 120        struct uwb_rceb *reply;
 121        ssize_t reply_size;
 122};
 123
 124static void uwb_rc_cmd_done(struct uwb_rc *rc, void *arg,
 125                            struct uwb_rceb *reply, ssize_t reply_size)
 126{
 127        struct uwb_rc_cmd_done_params *p = (struct uwb_rc_cmd_done_params *)arg;
 128
 129        if (reply_size > 0) {
 130                if (p->reply)
 131                        reply_size = min(p->reply_size, reply_size);
 132                else
 133                        p->reply = kmalloc(reply_size, GFP_ATOMIC);
 134
 135                if (p->reply)
 136                        memcpy(p->reply, reply, reply_size);
 137                else
 138                        reply_size = -ENOMEM;
 139        }
 140        p->reply_size = reply_size;
 141        complete(&p->completion);
 142}
 143
 144
 145/**
 146 * Generic function for issuing commands to the Radio Control Interface
 147 *
 148 * @rc:       UWB Radio Control descriptor
 149 * @cmd_name: Name of the command being issued (for error messages)
 150 * @cmd:      Pointer to rccb structure containing the command;
 151 *            normally you embed this structure as the first member of
 152 *            the full command structure.
 153 * @cmd_size: Size of the whole command buffer pointed to by @cmd.
 154 * @reply:    Pointer to where to store the reply
 155 * @reply_size: @reply's size
 156 * @expected_type: Expected type in the return event
 157 * @expected_event: Expected event code in the return event
 158 * @preply:   Here a pointer to where the event data is received will
 159 *            be stored. Once done with the data, free with kfree().
 160 *
 161 * This function is generic; it works for commands that return a fixed
 162 * and known size or for commands that return a variable amount of data.
 163 *
 164 * If a buffer is provided, that is used, although it could be chopped
 165 * to the maximum size of the buffer. If the buffer is NULL, then one
 166 * be allocated in *preply with the whole contents of the reply.
 167 *
 168 * @rc needs to be referenced
 169 */
 170static
 171ssize_t __uwb_rc_cmd(struct uwb_rc *rc, const char *cmd_name,
 172                     struct uwb_rccb *cmd, size_t cmd_size,
 173                     struct uwb_rceb *reply, size_t reply_size,
 174                     u8 expected_type, u16 expected_event,
 175                     struct uwb_rceb **preply)
 176{
 177        ssize_t result = 0;
 178        struct device *dev = &rc->uwb_dev.dev;
 179        struct uwb_rc_cmd_done_params params;
 180
 181        init_completion(&params.completion);
 182        params.reply = reply;
 183        params.reply_size = reply_size;
 184
 185        result = uwb_rc_cmd_async(rc, cmd_name, cmd, cmd_size,
 186                                  expected_type, expected_event,
 187                                  uwb_rc_cmd_done, &params);
 188        if (result)
 189                return result;
 190
 191        wait_for_completion(&params.completion);
 192
 193        if (preply)
 194                *preply = params.reply;
 195
 196        if (params.reply_size < 0)
 197                dev_err(dev, "%s: confirmation event 0x%02x/%04x/%02x "
 198                        "reception failed: %d\n", cmd_name,
 199                        expected_type, expected_event, cmd->bCommandContext,
 200                        (int)params.reply_size);
 201        return params.reply_size;
 202}
 203
 204
 205/**
 206 * Generic function for issuing commands to the Radio Control Interface
 207 *
 208 * @rc:       UWB Radio Control descriptor
 209 * @cmd_name: Name of the command being issued (for error messages)
 210 * @cmd:      Pointer to rccb structure containing the command;
 211 *            normally you embed this structure as the first member of
 212 *            the full command structure.
 213 * @cmd_size: Size of the whole command buffer pointed to by @cmd.
 214 * @reply:    Pointer to the beginning of the confirmation event
 215 *            buffer. Normally bigger than an 'struct hwarc_rceb'.
 216 *            You need to fill out reply->bEventType and reply->wEvent (in
 217 *            cpu order) as the function will use them to verify the
 218 *            confirmation event.
 219 * @reply_size: Size of the reply buffer
 220 *
 221 * The function checks that the length returned in the reply is at
 222 * least as big as @reply_size; if not, it will be deemed an error and
 223 * -EIO returned.
 224 *
 225 * @rc needs to be referenced
 226 */
 227ssize_t uwb_rc_cmd(struct uwb_rc *rc, const char *cmd_name,
 228                   struct uwb_rccb *cmd, size_t cmd_size,
 229                   struct uwb_rceb *reply, size_t reply_size)
 230{
 231        struct device *dev = &rc->uwb_dev.dev;
 232        ssize_t result;
 233
 234        result = __uwb_rc_cmd(rc, cmd_name,
 235                              cmd, cmd_size, reply, reply_size,
 236                              reply->bEventType, reply->wEvent, NULL);
 237
 238        if (result > 0 && result < reply_size) {
 239                dev_err(dev, "%s: not enough data returned for decoding reply "
 240                        "(%zu bytes received vs at least %zu needed)\n",
 241                        cmd_name, result, reply_size);
 242                result = -EIO;
 243        }
 244        return result;
 245}
 246EXPORT_SYMBOL_GPL(uwb_rc_cmd);
 247
 248
 249/**
 250 * Generic function for issuing commands to the Radio Control
 251 * Interface that return an unknown amount of data
 252 *
 253 * @rc:       UWB Radio Control descriptor
 254 * @cmd_name: Name of the command being issued (for error messages)
 255 * @cmd:      Pointer to rccb structure containing the command;
 256 *            normally you embed this structure as the first member of
 257 *            the full command structure.
 258 * @cmd_size: Size of the whole command buffer pointed to by @cmd.
 259 * @expected_type: Expected type in the return event
 260 * @expected_event: Expected event code in the return event
 261 * @preply:   Here a pointer to where the event data is received will
 262 *            be stored. Once done with the data, free with kfree().
 263 *
 264 * The function checks that the length returned in the reply is at
 265 * least as big as a 'struct uwb_rceb *'; if not, it will be deemed an
 266 * error and -EIO returned.
 267 *
 268 * @rc needs to be referenced
 269 */
 270ssize_t uwb_rc_vcmd(struct uwb_rc *rc, const char *cmd_name,
 271                    struct uwb_rccb *cmd, size_t cmd_size,
 272                    u8 expected_type, u16 expected_event,
 273                    struct uwb_rceb **preply)
 274{
 275        return __uwb_rc_cmd(rc, cmd_name, cmd, cmd_size, NULL, 0,
 276                            expected_type, expected_event, preply);
 277}
 278EXPORT_SYMBOL_GPL(uwb_rc_vcmd);
 279
 280
 281/**
 282 * Reset a UWB Host Controller (and all radio settings)
 283 *
 284 * @rc:      Host Controller descriptor
 285 * @returns: 0 if ok, < 0 errno code on error
 286 *
 287 * We put the command on kmalloc'ed memory as some arches cannot do
 288 * USB from the stack. The reply event is copied from an stage buffer,
 289 * so it can be in the stack. See WUSB1.0[8.6.2.4] for more details.
 290 */
 291int uwb_rc_reset(struct uwb_rc *rc)
 292{
 293        int result = -ENOMEM;
 294        struct uwb_rc_evt_confirm reply;
 295        struct uwb_rccb *cmd;
 296        size_t cmd_size = sizeof(*cmd);
 297
 298        mutex_lock(&rc->uwb_dev.mutex);
 299        cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 300        if (cmd == NULL)
 301                goto error_kzalloc;
 302        cmd->bCommandType = UWB_RC_CET_GENERAL;
 303        cmd->wCommand = cpu_to_le16(UWB_RC_CMD_RESET);
 304        reply.rceb.bEventType = UWB_RC_CET_GENERAL;
 305        reply.rceb.wEvent = UWB_RC_CMD_RESET;
 306        result = uwb_rc_cmd(rc, "RESET", cmd, cmd_size,
 307                            &reply.rceb, sizeof(reply));
 308        if (result < 0)
 309                goto error_cmd;
 310        if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
 311                dev_err(&rc->uwb_dev.dev,
 312                        "RESET: command execution failed: %s (%d)\n",
 313                        uwb_rc_strerror(reply.bResultCode), reply.bResultCode);
 314                result = -EIO;
 315        }
 316error_cmd:
 317        kfree(cmd);
 318error_kzalloc:
 319        mutex_unlock(&rc->uwb_dev.mutex);
 320        return result;
 321}
 322
 323int uwbd_msg_handle_reset(struct uwb_event *evt)
 324{
 325        struct uwb_rc *rc = evt->rc;
 326        int ret;
 327
 328        dev_info(&rc->uwb_dev.dev, "resetting radio controller\n");
 329        ret = rc->reset(rc);
 330        if (ret < 0) {
 331                dev_err(&rc->uwb_dev.dev, "failed to reset hardware: %d\n", ret);
 332                goto error;
 333        }
 334        return 0;
 335error:
 336        /* Nothing can be done except try the reset again. Wait a bit
 337           to avoid reset loops during probe() or remove(). */
 338        msleep(1000);
 339        uwb_rc_reset_all(rc);
 340        return ret;
 341}
 342
 343/**
 344 * uwb_rc_reset_all - request a reset of the radio controller and PALs
 345 * @rc: the radio controller of the hardware device to be reset.
 346 *
 347 * The full hardware reset of the radio controller and all the PALs
 348 * will be scheduled.
 349 */
 350void uwb_rc_reset_all(struct uwb_rc *rc)
 351{
 352        struct uwb_event *evt;
 353
 354        evt = kzalloc(sizeof(struct uwb_event), GFP_ATOMIC);
 355        if (unlikely(evt == NULL))
 356                return;
 357
 358        evt->rc = __uwb_rc_get(rc);     /* will be put by uwbd's uwbd_event_handle() */
 359        evt->ts_jiffies = jiffies;
 360        evt->type = UWB_EVT_TYPE_MSG;
 361        evt->message = UWB_EVT_MSG_RESET;
 362
 363        uwbd_event_queue(evt);
 364}
 365EXPORT_SYMBOL_GPL(uwb_rc_reset_all);
 366
 367void uwb_rc_pre_reset(struct uwb_rc *rc)
 368{
 369        rc->stop(rc);
 370        uwbd_flush(rc);
 371
 372        uwb_radio_reset_state(rc);
 373        uwb_rsv_remove_all(rc);
 374}
 375EXPORT_SYMBOL_GPL(uwb_rc_pre_reset);
 376
 377int uwb_rc_post_reset(struct uwb_rc *rc)
 378{
 379        int ret;
 380
 381        ret = rc->start(rc);
 382        if (ret)
 383                goto out;
 384        ret = uwb_rc_mac_addr_set(rc, &rc->uwb_dev.mac_addr);
 385        if (ret)
 386                goto out;
 387        ret = uwb_rc_dev_addr_set(rc, &rc->uwb_dev.dev_addr);
 388        if (ret)
 389                goto out;
 390out:
 391        return ret;
 392}
 393EXPORT_SYMBOL_GPL(uwb_rc_post_reset);
 394
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.