]>
Commit | Line | Data |
---|---|---|
5fd54ace | 1 | // SPDX-License-Identifier: GPL-2.0 |
7e6133aa DV |
2 | /* |
3 | * Wireless Host Controller (WHC) WUSB operations. | |
4 | * | |
5 | * Copyright (C) 2007 Cambridge Silicon Radio Ltd. | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License version | |
9 | * 2 as published by the Free Software Foundation. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
7e6133aa | 19 | #include <linux/kernel.h> |
7e6133aa | 20 | #include <linux/uwb/umc.h> |
7e6133aa DV |
21 | |
22 | #include "../../wusbcore/wusbhc.h" | |
23 | ||
24 | #include "whcd.h" | |
25 | ||
7e6133aa DV |
26 | static int whc_update_di(struct whc *whc, int idx) |
27 | { | |
28 | int offset = idx / 32; | |
29 | u32 bit = 1 << (idx % 32); | |
30 | ||
7e6133aa DV |
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 | /* | |
4d2bea4c DV |
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. | |
7e6133aa DV |
42 | */ |
43 | ||
44 | int 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 | ||
4d2bea4c | 54 | void whc_wusbhc_stop(struct wusbhc *wusbhc, int delay) |
7e6133aa DV |
55 | { |
56 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
4d2bea4c DV |
57 | u32 stop_time, now_time; |
58 | int ret; | |
7e6133aa DV |
59 | |
60 | pzl_stop(whc); | |
61 | asl_stop(whc); | |
4d2bea4c DV |
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); | |
7e6133aa DV |
68 | } |
69 | ||
70 | int 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 | ||
84 | int 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 | ||
94 | int 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 | ||
104 | int 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 | */ | |
128 | int 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 | ||
142 | static 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 | */ | |
172 | int 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); | |
192 | out: | |
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 | */ | |
203 | int 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 | ||
218 | int 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 | } |