1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
4 * All rights reserved.
5 */
6
7 #include <linux/bitfield.h>
8 #include "wlan_if.h"
9 #include "wlan.h"
10 #include "wlan_cfg.h"
11 #include "netdev.h"
12
13 enum cfg_cmd_type {
14 CFG_BYTE_CMD = 0,
15 CFG_HWORD_CMD = 1,
16 CFG_WORD_CMD = 2,
17 CFG_STR_CMD = 3,
18 CFG_BIN_CMD = 4
19 };
20
21 static const struct wilc_cfg_byte g_cfg_byte[] = {
22 {WID_STATUS, 0},
23 {WID_RSSI, 0},
24 {WID_LINKSPEED, 0},
25 {WID_WOWLAN_TRIGGER, 0},
26 {WID_NIL, 0}
27 };
28
29 static const struct wilc_cfg_hword g_cfg_hword[] = {
30 {WID_NIL, 0}
31 };
32
33 static const struct wilc_cfg_word g_cfg_word[] = {
34 {WID_FAILED_COUNT, 0},
35 {WID_RECEIVED_FRAGMENT_COUNT, 0},
36 {WID_SUCCESS_FRAME_COUNT, 0},
37 {WID_GET_INACTIVE_TIME, 0},
38 {WID_NIL, 0}
39
40 };
41
42 static const struct wilc_cfg_str g_cfg_str[] = {
43 {WID_FIRMWARE_VERSION, NULL},
44 {WID_MAC_ADDR, NULL},
45 {WID_ASSOC_RES_INFO, NULL},
46 {WID_NIL, NULL}
47 };
48
49 #define WILC_RESP_MSG_TYPE_CONFIG_REPLY 'R'
50 #define WILC_RESP_MSG_TYPE_STATUS_INFO 'I'
51 #define WILC_RESP_MSG_TYPE_NETWORK_INFO 'N'
52 #define WILC_RESP_MSG_TYPE_SCAN_COMPLETE 'S'
53
54 /********************************************
55 *
56 * Configuration Functions
57 *
58 ********************************************/
59
wilc_wlan_cfg_set_byte(u8 * frame,u32 offset,u16 id,u8 val8)60 static int wilc_wlan_cfg_set_byte(u8 *frame, u32 offset, u16 id, u8 val8)
61 {
62 if ((offset + 4) >= WILC_MAX_CFG_FRAME_SIZE)
63 return 0;
64
65 put_unaligned_le16(id, &frame[offset]);
66 put_unaligned_le16(1, &frame[offset + 2]);
67 frame[offset + 4] = val8;
68 return 5;
69 }
70
wilc_wlan_cfg_set_hword(u8 * frame,u32 offset,u16 id,u16 val16)71 static int wilc_wlan_cfg_set_hword(u8 *frame, u32 offset, u16 id, u16 val16)
72 {
73 if ((offset + 5) >= WILC_MAX_CFG_FRAME_SIZE)
74 return 0;
75
76 put_unaligned_le16(id, &frame[offset]);
77 put_unaligned_le16(2, &frame[offset + 2]);
78 put_unaligned_le16(val16, &frame[offset + 4]);
79
80 return 6;
81 }
82
wilc_wlan_cfg_set_word(u8 * frame,u32 offset,u16 id,u32 val32)83 static int wilc_wlan_cfg_set_word(u8 *frame, u32 offset, u16 id, u32 val32)
84 {
85 if ((offset + 7) >= WILC_MAX_CFG_FRAME_SIZE)
86 return 0;
87
88 put_unaligned_le16(id, &frame[offset]);
89 put_unaligned_le16(4, &frame[offset + 2]);
90 put_unaligned_le32(val32, &frame[offset + 4]);
91
92 return 8;
93 }
94
wilc_wlan_cfg_set_str(u8 * frame,u32 offset,u16 id,u8 * str,u32 size)95 static int wilc_wlan_cfg_set_str(u8 *frame, u32 offset, u16 id, u8 *str,
96 u32 size)
97 {
98 if ((offset + size + 4) >= WILC_MAX_CFG_FRAME_SIZE)
99 return 0;
100
101 put_unaligned_le16(id, &frame[offset]);
102 put_unaligned_le16(size, &frame[offset + 2]);
103 if (str && size != 0)
104 memcpy(&frame[offset + 4], str, size);
105
106 return (size + 4);
107 }
108
wilc_wlan_cfg_set_bin(u8 * frame,u32 offset,u16 id,u8 * b,u32 size)109 static int wilc_wlan_cfg_set_bin(u8 *frame, u32 offset, u16 id, u8 *b, u32 size)
110 {
111 u32 i;
112 u8 checksum = 0;
113
114 if ((offset + size + 5) >= WILC_MAX_CFG_FRAME_SIZE)
115 return 0;
116
117 put_unaligned_le16(id, &frame[offset]);
118 put_unaligned_le16(size, &frame[offset + 2]);
119
120 if ((b) && size != 0) {
121 memcpy(&frame[offset + 4], b, size);
122 for (i = 0; i < size; i++)
123 checksum += frame[offset + i + 4];
124 }
125
126 frame[offset + size + 4] = checksum;
127
128 return (size + 5);
129 }
130
131 /********************************************
132 *
133 * Configuration Response Functions
134 *
135 ********************************************/
136
wilc_wlan_parse_response_frame(struct wilc * wl,u8 * info,int size)137 static void wilc_wlan_parse_response_frame(struct wilc *wl, u8 *info, int size)
138 {
139 u16 wid;
140 u32 len = 0, i = 0;
141 struct wilc_cfg *cfg = &wl->cfg;
142
143 while (size > 0) {
144 i = 0;
145 wid = get_unaligned_le16(info);
146
147 switch (FIELD_GET(WILC_WID_TYPE, wid)) {
148 case WID_CHAR:
149 while (cfg->b[i].id != WID_NIL && cfg->b[i].id != wid)
150 i++;
151
152 if (cfg->b[i].id == wid)
153 cfg->b[i].val = info[4];
154
155 len = 3;
156 break;
157
158 case WID_SHORT:
159 while (cfg->hw[i].id != WID_NIL && cfg->hw[i].id != wid)
160 i++;
161
162 if (cfg->hw[i].id == wid)
163 cfg->hw[i].val = get_unaligned_le16(&info[4]);
164
165 len = 4;
166 break;
167
168 case WID_INT:
169 while (cfg->w[i].id != WID_NIL && cfg->w[i].id != wid)
170 i++;
171
172 if (cfg->w[i].id == wid)
173 cfg->w[i].val = get_unaligned_le32(&info[4]);
174
175 len = 6;
176 break;
177
178 case WID_STR:
179 while (cfg->s[i].id != WID_NIL && cfg->s[i].id != wid)
180 i++;
181
182 if (cfg->s[i].id == wid)
183 memcpy(cfg->s[i].str, &info[2], info[2] + 2);
184
185 len = 2 + info[2];
186 break;
187
188 default:
189 break;
190 }
191 size -= (2 + len);
192 info += (2 + len);
193 }
194 }
195
wilc_wlan_parse_info_frame(struct wilc * wl,u8 * info)196 static void wilc_wlan_parse_info_frame(struct wilc *wl, u8 *info)
197 {
198 u32 wid, len;
199
200 wid = get_unaligned_le16(info);
201
202 len = info[2];
203
204 if (len == 1 && wid == WID_STATUS) {
205 int i = 0;
206
207 while (wl->cfg.b[i].id != WID_NIL &&
208 wl->cfg.b[i].id != wid)
209 i++;
210
211 if (wl->cfg.b[i].id == wid)
212 wl->cfg.b[i].val = info[3];
213 }
214 }
215
216 /********************************************
217 *
218 * Configuration Exported Functions
219 *
220 ********************************************/
221
wilc_wlan_cfg_set_wid(u8 * frame,u32 offset,u16 id,u8 * buf,int size)222 int wilc_wlan_cfg_set_wid(u8 *frame, u32 offset, u16 id, u8 *buf, int size)
223 {
224 u8 type = FIELD_GET(WILC_WID_TYPE, id);
225 int ret = 0;
226
227 switch (type) {
228 case CFG_BYTE_CMD:
229 if (size >= 1)
230 ret = wilc_wlan_cfg_set_byte(frame, offset, id, *buf);
231 break;
232
233 case CFG_HWORD_CMD:
234 if (size >= 2)
235 ret = wilc_wlan_cfg_set_hword(frame, offset, id,
236 *((u16 *)buf));
237 break;
238
239 case CFG_WORD_CMD:
240 if (size >= 4)
241 ret = wilc_wlan_cfg_set_word(frame, offset, id,
242 *((u32 *)buf));
243 break;
244
245 case CFG_STR_CMD:
246 ret = wilc_wlan_cfg_set_str(frame, offset, id, buf, size);
247 break;
248
249 case CFG_BIN_CMD:
250 ret = wilc_wlan_cfg_set_bin(frame, offset, id, buf, size);
251 break;
252 }
253
254 return ret;
255 }
256
wilc_wlan_cfg_get_wid(u8 * frame,u32 offset,u16 id)257 int wilc_wlan_cfg_get_wid(u8 *frame, u32 offset, u16 id)
258 {
259 if ((offset + 2) >= WILC_MAX_CFG_FRAME_SIZE)
260 return 0;
261
262 put_unaligned_le16(id, &frame[offset]);
263
264 return 2;
265 }
266
wilc_wlan_cfg_get_val(struct wilc * wl,u16 wid,u8 * buffer,u32 buffer_size)267 int wilc_wlan_cfg_get_val(struct wilc *wl, u16 wid, u8 *buffer,
268 u32 buffer_size)
269 {
270 u8 type = FIELD_GET(WILC_WID_TYPE, wid);
271 int i, ret = 0;
272 struct wilc_cfg *cfg = &wl->cfg;
273
274 i = 0;
275 if (type == CFG_BYTE_CMD) {
276 while (cfg->b[i].id != WID_NIL && cfg->b[i].id != wid)
277 i++;
278
279 if (cfg->b[i].id == wid) {
280 memcpy(buffer, &cfg->b[i].val, 1);
281 ret = 1;
282 }
283 } else if (type == CFG_HWORD_CMD) {
284 while (cfg->hw[i].id != WID_NIL && cfg->hw[i].id != wid)
285 i++;
286
287 if (cfg->hw[i].id == wid) {
288 memcpy(buffer, &cfg->hw[i].val, 2);
289 ret = 2;
290 }
291 } else if (type == CFG_WORD_CMD) {
292 while (cfg->w[i].id != WID_NIL && cfg->w[i].id != wid)
293 i++;
294
295 if (cfg->w[i].id == wid) {
296 memcpy(buffer, &cfg->w[i].val, 4);
297 ret = 4;
298 }
299 } else if (type == CFG_STR_CMD) {
300 while (cfg->s[i].id != WID_NIL && cfg->s[i].id != wid)
301 i++;
302
303 if (cfg->s[i].id == wid) {
304 u16 size = get_unaligned_le16(cfg->s[i].str);
305
306 if (buffer_size >= size) {
307 memcpy(buffer, &cfg->s[i].str[2], size);
308 ret = size;
309 }
310 }
311 }
312 return ret;
313 }
314
wilc_wlan_cfg_indicate_rx(struct wilc * wilc,u8 * frame,int size,struct wilc_cfg_rsp * rsp)315 void wilc_wlan_cfg_indicate_rx(struct wilc *wilc, u8 *frame, int size,
316 struct wilc_cfg_rsp *rsp)
317 {
318 u8 msg_type;
319 u8 msg_id;
320
321 msg_type = frame[0];
322 msg_id = frame[1]; /* seq no */
323 frame += 4;
324 size -= 4;
325 rsp->type = 0;
326
327 switch (msg_type) {
328 case WILC_RESP_MSG_TYPE_CONFIG_REPLY:
329 wilc_wlan_parse_response_frame(wilc, frame, size);
330 rsp->type = WILC_CFG_RSP;
331 rsp->seq_no = msg_id;
332 break;
333
334 case WILC_RESP_MSG_TYPE_STATUS_INFO:
335 wilc_wlan_parse_info_frame(wilc, frame);
336 rsp->type = WILC_CFG_RSP_STATUS;
337 rsp->seq_no = msg_id;
338 /* call host interface info parse as well */
339 wilc_gnrl_async_info_received(wilc, frame - 4, size + 4);
340 break;
341
342 case WILC_RESP_MSG_TYPE_NETWORK_INFO:
343 wilc_network_info_received(wilc, frame - 4, size + 4);
344 break;
345
346 case WILC_RESP_MSG_TYPE_SCAN_COMPLETE:
347 wilc_scan_complete_received(wilc, frame - 4, size + 4);
348 break;
349
350 default:
351 rsp->seq_no = msg_id;
352 break;
353 }
354 }
355
wilc_wlan_cfg_init(struct wilc * wl)356 int wilc_wlan_cfg_init(struct wilc *wl)
357 {
358 struct wilc_cfg_str_vals *str_vals;
359 int i = 0;
360
361 wl->cfg.b = kmemdup(g_cfg_byte, sizeof(g_cfg_byte), GFP_KERNEL);
362 if (!wl->cfg.b)
363 return -ENOMEM;
364
365 wl->cfg.hw = kmemdup(g_cfg_hword, sizeof(g_cfg_hword), GFP_KERNEL);
366 if (!wl->cfg.hw)
367 goto out_b;
368
369 wl->cfg.w = kmemdup(g_cfg_word, sizeof(g_cfg_word), GFP_KERNEL);
370 if (!wl->cfg.w)
371 goto out_hw;
372
373 wl->cfg.s = kmemdup(g_cfg_str, sizeof(g_cfg_str), GFP_KERNEL);
374 if (!wl->cfg.s)
375 goto out_w;
376
377 str_vals = kzalloc(sizeof(*str_vals), GFP_KERNEL);
378 if (!str_vals)
379 goto out_s;
380
381 wl->cfg.str_vals = str_vals;
382 /* store the string cfg parameters */
383 wl->cfg.s[i].id = WID_FIRMWARE_VERSION;
384 wl->cfg.s[i].str = str_vals->firmware_version;
385 i++;
386 wl->cfg.s[i].id = WID_MAC_ADDR;
387 wl->cfg.s[i].str = str_vals->mac_address;
388 i++;
389 wl->cfg.s[i].id = WID_ASSOC_RES_INFO;
390 wl->cfg.s[i].str = str_vals->assoc_rsp;
391 i++;
392 wl->cfg.s[i].id = WID_NIL;
393 wl->cfg.s[i].str = NULL;
394 return 0;
395
396 out_s:
397 kfree(wl->cfg.s);
398 out_w:
399 kfree(wl->cfg.w);
400 out_hw:
401 kfree(wl->cfg.hw);
402 out_b:
403 kfree(wl->cfg.b);
404 return -ENOMEM;
405 }
406
wilc_wlan_cfg_deinit(struct wilc * wl)407 void wilc_wlan_cfg_deinit(struct wilc *wl)
408 {
409 kfree(wl->cfg.b);
410 kfree(wl->cfg.hw);
411 kfree(wl->cfg.w);
412 kfree(wl->cfg.s);
413 kfree(wl->cfg.str_vals);
414 }
415