drivers/usb/wusbcore/mmc.c

   1 /*
   2  * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
   3  * MMC (Microscheduled Management Command) handling
   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  * WUIEs and MMC IEs...well, they are almost the same at the end. MMC
  24  * IEs are Wireless USB IEs that go into the MMC period...[what is
  25  * that? look in Design-overview.txt].
  26  *
  27  *
  28  * This is a simple subsystem to keep track of which IEs are being
  29  * sent by the host in the MMC period.
  30  *
  31  * For each WUIE we ask to send, we keep it in an array, so we can
  32  * request its removal later, or replace the content. They are tracked
  33  * by pointer, so be sure to use the same pointer if you want to
  34  * remove it or update the contents.
  35  *
  36  * FIXME:
  37  *  - add timers that autoremove intervalled IEs?
  38  */
  39 #include <linux/usb/wusb.h>
  40 #include "wusbhc.h"
  41
  42 /* Initialize the MMCIEs handling mechanism */
  43 int wusbhc_mmcie_create(struct wusbhc *wusbhc)
  44 {
  45         u8 mmcies = wusbhc->mmcies_max;
  46         wusbhc->mmcie = kzalloc(mmcies * sizeof(wusbhc->mmcie[0]), GFP_KERNEL);
  47         if (wusbhc->mmcie == NULL)
  48                 return -ENOMEM;
  49         mutex_init(&wusbhc->mmcie_mutex);
  50         return 0;
  51 }
  52
  53 /* Release resources used by the MMCIEs handling mechanism */
  54 void wusbhc_mmcie_destroy(struct wusbhc *wusbhc)
  55 {
  56         kfree(wusbhc->mmcie);
  57 }
  58
  59 /*
  60  * Add or replace an MMC Wireless USB IE.
  61  *
  62  * @interval:    See WUSB1.0[8.5.3.1]
  63  * @repeat_cnt:  See WUSB1.0[8.5.3.1]
  64  * @handle:      See WUSB1.0[8.5.3.1]
  65  * @wuie:        Pointer to the header of the WUSB IE data to add.
  66  *               MUST BE allocated in a kmalloc buffer (no stack or
  67  *               vmalloc).
  68  *               THE CALLER ALWAYS OWNS THE POINTER (we don't free it
  69  *               on remove, we just forget about it).
  70  * @returns:     0 if ok, < 0 errno code on error.
  71  *
  72  * Goes over the *whole* @wusbhc->mmcie array looking for (a) the
  73  * first free spot and (b) if @wuie is already in the array (aka:
  74  * transmitted in the MMCs) the spot were it is.
  75  *
  76  * If present, we "overwrite it" (update).
  77  *
  78  *
  79  * NOTE: Need special ordering rules -- see below WUSB1.0 Table 7-38.
  80  *       The host uses the handle as the 'sort' index. We
  81  *       allocate the last one always for the WUIE_ID_HOST_INFO, and
  82  *       the rest, first come first serve in inverse order.
  83  *
  84  *       Host software must make sure that it adds the other IEs in
  85  *       the right order... the host hardware is responsible for
  86  *       placing the WCTA IEs in the right place with the other IEs
  87  *       set by host software.
  88  *
  89  * NOTE: we can access wusbhc->wa_descr without locking because it is
  90  *       read only.
  91  */
  92 int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
  93                      struct wuie_hdr *wuie)
  94 {
  95         int result = -ENOBUFS;
  96         struct device *dev = wusbhc->dev;
  97         unsigned handle, itr;
  98
  99         /* Search a handle, taking into account the ordering */
 100         mutex_lock(&wusbhc->mmcie_mutex);
 101         switch (wuie->bIEIdentifier) {
 102         case WUIE_ID_HOST_INFO:
 103                 /* Always last */
 104                 handle = wusbhc->mmcies_max - 1;
 105                 break;
 106         case WUIE_ID_ISOCH_DISCARD:
 107                 dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x "
 108                         "unimplemented\n", wuie->bIEIdentifier);
 109                 result = -ENOSYS;
 110                 goto error_unlock;
 111         default:
 112                 /* search for it or find the last empty slot */
 113                 handle = ~0;
 114                 for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) {
 115                         if (wusbhc->mmcie[itr] == wuie) {
 116                                 handle = itr;
 117                                 break;
 118                         }
 119                         if (wusbhc->mmcie[itr] == NULL)
 120                                 handle = itr;
 121                 }
 122                 if (handle == ~0) {
 123                         if (printk_ratelimit())
 124                                 dev_err(dev, "MMC handle space exhausted\n");
 125                         goto error_unlock;
 126                 }
 127         }
 128         result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle,
 129                                      wuie);
 130         if (result >= 0)
 131                 wusbhc->mmcie[handle] = wuie;
 132 error_unlock:
 133         mutex_unlock(&wusbhc->mmcie_mutex);
 134         return result;
 135 }
 136 EXPORT_SYMBOL_GPL(wusbhc_mmcie_set);
 137
 138 /*
 139  * Remove an MMC IE previously added with wusbhc_mmcie_set()
 140  *
 141  * @wuie        Pointer used to add the WUIE
 142  */
 143 void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie)
 144 {
 145         int result;
 146         struct device *dev = wusbhc->dev;
 147         unsigned handle, itr;
 148
 149         mutex_lock(&wusbhc->mmcie_mutex);
 150         for (itr = 0; itr < wusbhc->mmcies_max; itr++)
 151                 if (wusbhc->mmcie[itr] == wuie) {
 152                         handle = itr;
 153                         goto found;
 154                 }
 155         mutex_unlock(&wusbhc->mmcie_mutex);
 156         return;
 157
 158 found:
 159         result = (wusbhc->mmcie_rm)(wusbhc, handle);
 160         if (result == 0)
 161                 wusbhc->mmcie[itr] = NULL;
 162         else if (printk_ratelimit())
 163                 dev_err(dev, "MMC: Failed to remove IE %p (0x%02x)\n",
 164                         wuie, wuie->bIEIdentifier);
 165         mutex_unlock(&wusbhc->mmcie_mutex);
 166         return;
 167 }
 168 EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);
 169
 170 /*
 171  * wusbhc_start - start transmitting MMCs and accepting connections
 172  * @wusbhc: the HC to start
 173  * @chid: the CHID to use for this host
 174  *
 175  * Establishes a cluster reservation, enables device connections, and
 176  * starts MMCs with appropriate DNTS parameters.
 177  */
 178 int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
 179 {
 180         int result;
 181         struct device *dev = wusbhc->dev;
 182
 183         WARN_ON(wusbhc->wuie_host_info != NULL);
 184
 185         result = wusbhc_rsv_establish(wusbhc);
 186         if (result < 0) {
 187                 dev_err(dev, "cannot establish cluster reservation: %d\n",
 188                         result);
 189                 goto error_rsv_establish;
 190         }
 191
 192         result = wusbhc_devconnect_start(wusbhc, chid);
 193         if (result < 0) {
 194                 dev_err(dev, "error enabling device connections: %d\n", result);
 195                 goto error_devconnect_start;
 196         }
 197
 198         result = wusbhc_sec_start(wusbhc);
 199         if (result < 0) {
 200                 dev_err(dev, "error starting security in the HC: %d\n", result);
 201                 goto error_sec_start;
 202         }
 203         /* FIXME: the choice of the DNTS parameters is somewhat
 204          * arbitrary */
 205         result = wusbhc->set_num_dnts(wusbhc, 0, 15);
 206         if (result < 0) {
 207                 dev_err(dev, "Cannot set DNTS parameters: %d\n", result);
 208                 goto error_set_num_dnts;
 209         }
 210         result = wusbhc->start(wusbhc);
 211         if (result < 0) {
 212                 dev_err(dev, "error starting wusbch: %d\n", result);
 213                 goto error_wusbhc_start;
 214         }
 215         wusbhc->active = 1;
 216         return 0;
 217
 218 error_wusbhc_start:
 219         wusbhc_sec_stop(wusbhc);
 220 error_set_num_dnts:
 221 error_sec_start:
 222         wusbhc_devconnect_stop(wusbhc);
 223 error_devconnect_start:
 224         wusbhc_rsv_terminate(wusbhc);
 225 error_rsv_establish:
 226         return result;
 227 }
 228
 229 /*
 230  * Disconnect all from the WUSB Channel
 231  *
 232  * Send a Host Disconnect IE in the MMC, wait, don't send it any more
 233  */
 234 static int __wusbhc_host_disconnect_ie(struct wusbhc *wusbhc)
 235 {
 236         int result = -ENOMEM;
 237         struct wuie_host_disconnect *host_disconnect_ie;
 238         might_sleep();
 239         host_disconnect_ie = kmalloc(sizeof(*host_disconnect_ie), GFP_KERNEL);
 240         if (host_disconnect_ie == NULL)
 241                 goto error_alloc;
 242         host_disconnect_ie->hdr.bLength       = sizeof(*host_disconnect_ie);
 243         host_disconnect_ie->hdr.bIEIdentifier = WUIE_ID_HOST_DISCONNECT;
 244         result = wusbhc_mmcie_set(wusbhc, 0, 0, &host_disconnect_ie->hdr);
 245         if (result < 0)
 246                 goto error_mmcie_set;
 247
 248         /* WUSB1.0[8.5.3.1 & 7.5.2] */
 249         msleep(100);
 250         wusbhc_mmcie_rm(wusbhc, &host_disconnect_ie->hdr);
 251 error_mmcie_set:
 252         kfree(host_disconnect_ie);
 253 error_alloc:
 254         return result;
 255 }
 256
 257 /*
 258  * wusbhc_stop - stop transmitting MMCs
 259  * @wusbhc: the HC to stop
 260  *
 261  * Send a Host Disconnect IE, wait, remove all the MMCs (stop sending MMCs).
 262  *
 263  * If we can't allocate a Host Stop IE, screw it, we don't notify the
 264  * devices we are disconnecting...
 265  */
 266 void wusbhc_stop(struct wusbhc *wusbhc)
 267 {
 268         if (wusbhc->active) {
 269                 wusbhc->active = 0;
 270                 wusbhc->stop(wusbhc);
 271                 wusbhc_sec_stop(wusbhc);
 272                 __wusbhc_host_disconnect_ie(wusbhc);
 273                 wusbhc_devconnect_stop(wusbhc);
 274                 wusbhc_rsv_terminate(wusbhc);
 275         }
 276 }
 277 EXPORT_SYMBOL_GPL(wusbhc_stop);
 278
 279 /*
 280  * Change the CHID in a WUSB Channel
 281  *
 282  * If it is just a new CHID, send a Host Disconnect IE and then change
 283  * the CHID IE.
 284  */
 285 static int __wusbhc_chid_change(struct wusbhc *wusbhc,
 286                                 const struct wusb_ckhdid *chid)
 287 {
 288         int result = -ENOSYS;
 289         struct device *dev = wusbhc->dev;
 290         dev_err(dev, "%s() not implemented yet\n", __func__);
 291         return result;
 292
 293         BUG_ON(wusbhc->wuie_host_info == NULL);
 294         __wusbhc_host_disconnect_ie(wusbhc);
 295         wusbhc->wuie_host_info->CHID = *chid;
 296         result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->wuie_host_info->hdr);
 297         if (result < 0)
 298                 dev_err(dev, "Can't update Host Info WUSB IE: %d\n", result);
 299         return result;
 300 }
 301
 302 /*
 303  * Set/reset/update a new CHID
 304  *
 305  * Depending on the previous state of the MMCs, start, stop or change
 306  * the sent MMC. This effectively switches the host controller on and
 307  * off (radio wise).
 308  */
 309 int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)
 310 {
 311         int result = 0;
 312
 313         if (memcmp(chid, &wusb_ckhdid_zero, sizeof(chid)) == 0)
 314                 chid = NULL;
 315
 316         mutex_lock(&wusbhc->mutex);
 317         if (wusbhc->active) {
 318                 if (chid)
 319                         result = __wusbhc_chid_change(wusbhc, chid);
 320                 else
 321                         wusbhc_stop(wusbhc);
 322         } else {
 323                 if (chid)
 324                         wusbhc_start(wusbhc, chid);
 325         }
 326         mutex_unlock(&wusbhc->mutex);
 327         return result;
 328 }
 329 EXPORT_SYMBOL_GPL(wusbhc_chid_set);