PageRenderTime 29ms CodeModel.GetById 10ms app.highlight 16ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/usb/host/whci/wusb.c

https://gitlab.com/stalker-android/linux-omap3
C | 222 lines | 137 code | 47 blank | 38 comment | 7 complexity | f78c81ca70a2b5a59e16629db6e20679 MD5 | raw file
  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}