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/kernel.h> 19#include <linux/init.h> 20#include <linux/uwb/umc.h> 21 22#include "../../wusbcore/wusbhc.h" 23 24#include "whcd.h" 25 26static int whc_update_di(struct whc *whc, int idx) 27{ 28 int offset = idx / 32; 29 u32 bit = 1 << (idx % 32); 30 31 le_writel(bit, whc->base + WUSBDIBUPDATED + offset); 32 33 return whci_wait_for(&whc->umc->dev, 34 whc->base + WUSBDIBUPDATED + offset, bit, 0, 35 100, "DI update"); 36} 37 38/* 39 * WHCI starts MMCs based on there being a valid GTK so these need 40 * only start/stop the asynchronous and periodic schedules and send a 41 * channel stop command. 42 */ 43 44int whc_wusbhc_start(struct wusbhc *wusbhc) 45{ 46 struct whc *whc = wusbhc_to_whc(wusbhc); 47 48 asl_start(whc); 49 pzl_start(whc); 50 51 return 0; 52} 53 54void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay) 55{ 56 struct whc *whc = wusbhc_to_whc(wusbhc); 57 u32 stop_time, now_time; 58 int ret; 59 60 pzl_stop(whc); 61 asl_stop(whc); 62 63 now_time = le_readl(whc->base + WUSBTIME) & WUSBTIME_CHANNEL_TIME_MASK; 64 stop_time = (now_time + ((delay * 8) << 7)) & 0x00ffffff; 65 ret = whc_do_gencmd(whc, WUSBGENCMDSTS_CHAN_STOP, stop_time, NULL, 0); 66 if (ret == 0) 67 msleep(delay); 68} 69 70int whc_mmcie_add(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt, 71 u8 handle, struct wuie_hdr *wuie) 72{ 73 struct whc *whc = wusbhc_to_whc(wusbhc); 74 u32 params; 75 76 params = (interval << 24) 77 | (repeat_cnt << 16) 78 | (wuie->bLength << 8) 79 | handle; 80 81 return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_ADD, params, wuie, wuie->bLength); 82} 83 84int whc_mmcie_rm(struct wusbhc *wusbhc, u8 handle) 85{ 86 struct whc *whc = wusbhc_to_whc(wusbhc); 87 u32 params; 88 89 params = handle; 90 91 return whc_do_gencmd(whc, WUSBGENCMDSTS_MMCIE_RM, params, NULL, 0); 92} 93 94int whc_bwa_set(struct wusbhc *wusbhc, s8 stream_index, const struct uwb_mas_bm *mas_bm) 95{ 96 struct whc *whc = wusbhc_to_whc(wusbhc); 97 98 if (stream_index >= 0) 99 whc_write_wusbcmd(whc, WUSBCMD_WUSBSI_MASK, WUSBCMD_WUSBSI(stream_index)); 100 101 return whc_do_gencmd(whc, WUSBGENCMDSTS_SET_MAS, 0, (void *)mas_bm, sizeof(*mas_bm)); 102} 103 104int whc_dev_info_set(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev) 105{ 106 struct whc *whc = wusbhc_to_whc(wusbhc); 107 int idx = wusb_dev->port_idx; 108 struct di_buf_entry *di = &whc->di_buf[idx]; 109 int ret; 110 111 mutex_lock(&whc->mutex); 112 113 uwb_mas_bm_copy_le(di->availability_info, &wusb_dev->availability); 114 di->addr_sec_info &= ~(WHC_DI_DISABLE | WHC_DI_DEV_ADDR_MASK); 115 di->addr_sec_info |= WHC_DI_DEV_ADDR(wusb_dev->addr); 116 117 ret = whc_update_di(whc, idx); 118 119 mutex_unlock(&whc->mutex); 120 121 return ret; 122} 123 124/* 125 * Set the number of Device Notification Time Slots (DNTS) and enable 126 * device notifications. 127 */ 128int whc_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots) 129{ 130 struct whc *whc = wusbhc_to_whc(wusbhc); 131 u32 dntsctrl; 132 133 dntsctrl = WUSBDNTSCTRL_ACTIVE 134 | WUSBDNTSCTRL_INTERVAL(interval) 135 | WUSBDNTSCTRL_SLOTS(slots); 136 137 le_writel(dntsctrl, whc->base + WUSBDNTSCTRL); 138 139 return 0; 140} 141 142static int whc_set_key(struct whc *whc, u8 key_index, uint32_t tkid, 143 const void *key, size_t key_size, bool is_gtk) 144{ 145 uint32_t setkeycmd; 146 uint32_t seckey[4]; 147 int i; 148 int ret; 149 150 memcpy(seckey, key, key_size); 151 setkeycmd = WUSBSETSECKEYCMD_SET | WUSBSETSECKEYCMD_IDX(key_index); 152 if (is_gtk) 153 setkeycmd |= WUSBSETSECKEYCMD_GTK; 154 155 le_writel(tkid, whc->base + WUSBTKID); 156 for (i = 0; i < 4; i++) 157 le_writel(seckey[i], whc->base + WUSBSECKEY + 4*i); 158 le_writel(setkeycmd, whc->base + WUSBSETSECKEYCMD); 159 160 ret = whci_wait_for(&whc->umc->dev, whc->base + WUSBSETSECKEYCMD, 161 WUSBSETSECKEYCMD_SET, 0, 100, "set key"); 162 163 return ret; 164} 165 166/** 167 * whc_set_ptk - set the PTK to use for a device. 168 * 169 * The index into the key table for this PTK is the same as the 170 * device's port index. 171 */ 172int whc_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid, 173 const void *ptk, size_t key_size) 174{ 175 struct whc *whc = wusbhc_to_whc(wusbhc); 176 struct di_buf_entry *di = &whc->di_buf[port_idx]; 177 int ret; 178 179 mutex_lock(&whc->mutex); 180 181 if (ptk) { 182 ret = whc_set_key(whc, port_idx, tkid, ptk, key_size, false); 183 if (ret) 184 goto out; 185 186 di->addr_sec_info &= ~WHC_DI_KEY_IDX_MASK; 187 di->addr_sec_info |= WHC_DI_SECURE | WHC_DI_KEY_IDX(port_idx); 188 } else 189 di->addr_sec_info &= ~WHC_DI_SECURE; 190 191 ret = whc_update_di(whc, port_idx); 192out: 193 mutex_unlock(&whc->mutex); 194 return ret; 195} 196 197/** 198 * whc_set_gtk - set the GTK for subsequent broadcast packets 199 * 200 * The GTK is stored in the last entry in the key table (the previous 201 * N_DEVICES entries are for the per-device PTKs). 202 */ 203int whc_set_gtk(struct wusbhc *wusbhc, u32 tkid, 204 const void *gtk, size_t key_size) 205{ 206 struct whc *whc = wusbhc_to_whc(wusbhc); 207 int ret; 208 209 mutex_lock(&whc->mutex); 210 211 ret = whc_set_key(whc, whc->n_devices, tkid, gtk, key_size, true); 212 213 mutex_unlock(&whc->mutex); 214 215 return ret; 216} 217 218int whc_set_cluster_id(struct whc *whc, u8 bcid) 219{ 220 whc_write_wusbcmd(whc, WUSBCMD_BCID_MASK, WUSBCMD_BCID(bcid)); 221 return 0; 222} 223