git.oblomov.eu Git - linux-2.6/blob - drivers/usb/host/whci/wusb.c

   1 /*
   2  * Wireless Host Controller (WHC) WUSB operations.
   3  *
   4  * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version
   8  * 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #include <linux/version.h>
  19 #include <linux/kernel.h>
  20 #include <linux/init.h>
  21 #include <linux/uwb/umc.h>
  22 #define D_LOCAL 1
  23 #include <linux/uwb/debug.h>
  24
  25 #include "../../wusbcore/wusbhc.h"
  26
  27 #include "whcd.h"
  28
  29 #if D_LOCAL >= 1
  30 static void dump_di(struct whc *whc, int idx)
  31 {
  32         struct di_buf_entry *di = &whc->di_buf[idx];
  33         struct device *dev = &whc->umc->dev;
  34         char buf[128];
  35
  36         bitmap_scnprintf(buf, sizeof(buf), (unsigned long *)di->availability_info, UWB_NUM_MAS);
  37
  38         d_printf(1, dev, "DI[%d]\n", idx);
  39         d_printf(1, dev, "  availability: %s\n", buf);
  40         d_printf(1, dev, "  %c%c key idx: %d dev addr: %d\n",
  41                  (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
  42                  (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
  43                  (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
  44                  (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
  45 }
  46 #else
  47 static inline void dump_di(struct whc *whc, int idx)
  48 {
  49 }
  50 #endif
  51
  52 static int whc_update_di(struct whc *whc, int idx)
  53 {
  54         int offset = idx / 32;
  55         u32 bit = 1 << (idx % 32);
  56
  57         dump_di(whc, idx);
  58
  59         le_writel(bit, whc->base + WUSBDIBUPDATED + offset);
  60
  61         return whci_wait_for(&whc->umc->dev,
  62                              whc->base + WUSBDIBUPDATED + offset, bit, 0,
  63                              100, "DI update");
  64 }
  65
  66 /*
  67  * WHCI starts MMCs based on there being a valid GTK so these need
  68  * only start/stop the asynchronous and periodic schedules and send a
  69  * channel stop command.
  70  */
  71
  72 int whc_wusbhc_start(struct wusbhc *wusbhc)
  73 {
  74         struct whc *whc = wusbhc_to_whc(wusbhc);
  75
  76         asl_start(whc);
  77         pzl_start(whc);
  78
  79         return 0;
  80 }
  81
  82 void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay)
  83 {
  84         struct whc *whc = wusbhc_to_whc(wusbhc);
  85         u32 stop_time, now_time;
  86         int ret;
  87
  88         pzl_stop(whc);
  89         asl_stop(whc);
  90
  91         now_time = le_readl(whc->base + WUSBTIME) & WUSBTIME_CHANNEL_TIME_MASK;
  92         stop_time = (now_time + ((delay * 8) << 7)) & 0x00ffffff;
  93         ret = whc_do_gencmd(whc, WUSBGENCMDSTS_CHAN_STOP, stop_time, NULL, 0);
  94         if (ret == 0)
  95                 msleep(delay);
  96 }
  97
  98 int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
  99                   u8 handle, struct wuie_hdr *wuie)
 100 {
 101         struct whc *whc = wusbhc_to_whc(wusbhc);
 102         u32 params;
 103
 104         params = (interval << 24)
 105                 | (repeat_cnt << 16)
 106                 | (wuie->bLength << 8)
 107                 | handle;
 108
 109         return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_ADD, params, wuie, wuie->bLength);
 110 }
 111
 112 int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle)
 113 {
 114         struct whc *whc = wusbhc_to_whc(wusbhc);
 115         u32 params;
 116
 117         params = handle;
 118
 119         return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_RM, params, NULL, 0);
 120 }
 121
 122 int whc_bwa_set(struct wusbhc *wusbhc, s8 stream_index, const struct uwb_mas_bm *mas_bm)
 123 {
 124         struct whc *whc = wusbhc_to_whc(wusbhc);
 125
 126         if (stream_index >= 0)
 127                 whc_write_wusbcmd(whc, WUSBCMD_WUSBSI_MASK, WUSBCMD_WUSBSI(stream_index));
 128
 129         return whc_do_gencmd(whc, WUSBGENCMDSTS_SET_MAS, 0, (void *)mas_bm, sizeof(*mas_bm));
 130 }
 131
 132 int whc_dev_info_set(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 133 {
 134         struct whc *whc = wusbhc_to_whc(wusbhc);
 135         int idx = wusb_dev->port_idx;
 136         struct di_buf_entry *di = &whc->di_buf[idx];
 137         int ret;
 138
 139         mutex_lock(&whc->mutex);
 140
 141         uwb_mas_bm_copy_le(di->availability_info, &wusb_dev->availability);
 142         di->addr_sec_info &= ~(WHC_DI_DISABLE | WHC_DI_DEV_ADDR_MASK);
 143         di->addr_sec_info |= WHC_DI_DEV_ADDR(wusb_dev->addr);
 144
 145         ret = whc_update_di(whc, idx);
 146
 147         mutex_unlock(&whc->mutex);
 148
 149         return ret;
 150 }
 151
 152 /*
 153  * Set the number of Device Notification Time Slots (DNTS) and enable
 154  * device notifications.
 155  */
 156 int whc_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots)
 157 {
 158         struct whc *whc = wusbhc_to_whc(wusbhc);
 159         u32 dntsctrl;
 160
 161         dntsctrl = WUSBDNTSCTRL_ACTIVE
 162                 | WUSBDNTSCTRL_INTERVAL(interval)
 163                 | WUSBDNTSCTRL_SLOTS(slots);
 164
 165         le_writel(dntsctrl, whc->base + WUSBDNTSCTRL);
 166
 167         return 0;
 168 }
 169
 170 static int whc_set_key(struct whc *whc, u8 key_index, uint32_t tkid,
 171                        const void *key, size_t key_size, bool is_gtk)
 172 {
 173         uint32_t setkeycmd;
 174         uint32_t seckey[4];
 175         int i;
 176         int ret;
 177
 178         memcpy(seckey, key, key_size);
 179         setkeycmd = WUSBSETSECKEYCMD_SET | WUSBSETSECKEYCMD_IDX(key_index);
 180         if (is_gtk)
 181                 setkeycmd |= WUSBSETSECKEYCMD_GTK;
 182
 183         le_writel(tkid, whc->base + WUSBTKID);
 184         for (i = 0; i < 4; i++)
 185                 le_writel(seckey[i], whc->base + WUSBSECKEY + 4*i);
 186         le_writel(setkeycmd, whc->base + WUSBSETSECKEYCMD);
 187
 188         ret = whci_wait_for(&whc->umc->dev, whc->base + WUSBSETSECKEYCMD,
 189                             WUSBSETSECKEYCMD_SET, 0, 100, "set key");
 190
 191         return ret;
 192 }
 193
 194 /**
 195  * whc_set_ptk - set the PTK to use for a device.
 196  *
 197  * The index into the key table for this PTK is the same as the
 198  * device's port index.
 199  */
 200 int whc_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
 201                 const void *ptk, size_t key_size)
 202 {
 203         struct whc *whc = wusbhc_to_whc(wusbhc);
 204         struct di_buf_entry *di = &whc->di_buf[port_idx];
 205         int ret;
 206
 207         mutex_lock(&whc->mutex);
 208
 209         if (ptk) {
 210                 ret = whc_set_key(whc, port_idx, tkid, ptk, key_size, false);
 211                 if (ret)
 212                         goto out;
 213
 214                 di->addr_sec_info &= ~WHC_DI_KEY_IDX_MASK;
 215                 di->addr_sec_info |= WHC_DI_SECURE | WHC_DI_KEY_IDX(port_idx);
 216         } else
 217                 di->addr_sec_info &= ~WHC_DI_SECURE;
 218
 219         ret = whc_update_di(whc, port_idx);
 220 out:
 221         mutex_unlock(&whc->mutex);
 222         return ret;
 223 }
 224
 225 /**
 226  * whc_set_gtk - set the GTK for subsequent broadcast packets
 227  *
 228  * The GTK is stored in the last entry in the key table (the previous
 229  * N_DEVICES entries are for the per-device PTKs).
 230  */
 231 int whc_set_gtk(struct wusbhc *wusbhc, u32 tkid,
 232                 const void *gtk, size_t key_size)
 233 {
 234         struct whc *whc = wusbhc_to_whc(wusbhc);
 235         int ret;
 236
 237         mutex_lock(&whc->mutex);
 238
 239         ret = whc_set_key(whc, whc->n_devices, tkid, gtk, key_size, true);
 240
 241         mutex_unlock(&whc->mutex);
 242
 243         return ret;
 244 }
 245
 246 int whc_set_cluster_id(struct whc *whc, u8 bcid)
 247 {
 248         whc_write_wusbcmd(whc, WUSBCMD_BCID_MASK, WUSBCMD_BCID(bcid));
 249         return 0;
 250 }