microchip/wilc1000/wlan_cfg.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
0004  * All rights reserved.
0005  */
0006
0007 #include <linux/bitfield.h>
0008 #include "wlan_if.h"
0009 #include "wlan.h"
0010 #include "wlan_cfg.h"
0011 #include "netdev.h"
0012
0013 enum cfg_cmd_type {
0014     CFG_BYTE_CMD    = 0,
0015     CFG_HWORD_CMD   = 1,
0016     CFG_WORD_CMD    = 2,
0017     CFG_STR_CMD = 3,
0018     CFG_BIN_CMD = 4
0019 };
0020
0021 static const struct wilc_cfg_byte g_cfg_byte[] = {
0022     {WID_STATUS, 0},
0023     {WID_RSSI, 0},
0024     {WID_LINKSPEED, 0},
0025     {WID_TX_POWER, 0},
0026     {WID_WOWLAN_TRIGGER, 0},
0027     {WID_NIL, 0}
0028 };
0029
0030 static const struct wilc_cfg_hword g_cfg_hword[] = {
0031     {WID_NIL, 0}
0032 };
0033
0034 static const struct wilc_cfg_word g_cfg_word[] = {
0035     {WID_FAILED_COUNT, 0},
0036     {WID_RECEIVED_FRAGMENT_COUNT, 0},
0037     {WID_SUCCESS_FRAME_COUNT, 0},
0038     {WID_GET_INACTIVE_TIME, 0},
0039     {WID_NIL, 0}
0040
0041 };
0042
0043 static const struct wilc_cfg_str g_cfg_str[] = {
0044     {WID_FIRMWARE_VERSION, NULL},
0045     {WID_MAC_ADDR, NULL},
0046     {WID_ASSOC_RES_INFO, NULL},
0047     {WID_NIL, NULL}
0048 };
0049
0050 #define WILC_RESP_MSG_TYPE_CONFIG_REPLY     'R'
0051 #define WILC_RESP_MSG_TYPE_STATUS_INFO      'I'
0052 #define WILC_RESP_MSG_TYPE_NETWORK_INFO     'N'
0053 #define WILC_RESP_MSG_TYPE_SCAN_COMPLETE    'S'
0054
0055 /********************************************
0056  *
0057  *      Configuration Functions
0058  *
0059  ********************************************/
0060
0061 static int wilc_wlan_cfg_set_byte(u8 *frame, u32 offset, u16 id, u8 val8)
0062 {
0063     if ((offset + 4) >= WILC_MAX_CFG_FRAME_SIZE)
0064         return 0;
0065
0066     put_unaligned_le16(id, &frame[offset]);
0067     put_unaligned_le16(1, &frame[offset + 2]);
0068     frame[offset + 4] = val8;
0069     return 5;
0070 }
0071
0072 static int wilc_wlan_cfg_set_hword(u8 *frame, u32 offset, u16 id, u16 val16)
0073 {
0074     if ((offset + 5) >= WILC_MAX_CFG_FRAME_SIZE)
0075         return 0;
0076
0077     put_unaligned_le16(id, &frame[offset]);
0078     put_unaligned_le16(2, &frame[offset + 2]);
0079     put_unaligned_le16(val16, &frame[offset + 4]);
0080
0081     return 6;
0082 }
0083
0084 static int wilc_wlan_cfg_set_word(u8 *frame, u32 offset, u16 id, u32 val32)
0085 {
0086     if ((offset + 7) >= WILC_MAX_CFG_FRAME_SIZE)
0087         return 0;
0088
0089     put_unaligned_le16(id, &frame[offset]);
0090     put_unaligned_le16(4, &frame[offset + 2]);
0091     put_unaligned_le32(val32, &frame[offset + 4]);
0092
0093     return 8;
0094 }
0095
0096 static int wilc_wlan_cfg_set_str(u8 *frame, u32 offset, u16 id, u8 *str,
0097                  u32 size)
0098 {
0099     if ((offset + size + 4) >= WILC_MAX_CFG_FRAME_SIZE)
0100         return 0;
0101
0102     put_unaligned_le16(id, &frame[offset]);
0103     put_unaligned_le16(size, &frame[offset + 2]);
0104     if (str && size != 0)
0105         memcpy(&frame[offset + 4], str, size);
0106
0107     return (size + 4);
0108 }
0109
0110 static int wilc_wlan_cfg_set_bin(u8 *frame, u32 offset, u16 id, u8 *b, u32 size)
0111 {
0112     u32 i;
0113     u8 checksum = 0;
0114
0115     if ((offset + size + 5) >= WILC_MAX_CFG_FRAME_SIZE)
0116         return 0;
0117
0118     put_unaligned_le16(id, &frame[offset]);
0119     put_unaligned_le16(size, &frame[offset + 2]);
0120
0121     if ((b) && size != 0) {
0122         memcpy(&frame[offset + 4], b, size);
0123         for (i = 0; i < size; i++)
0124             checksum += frame[offset + i + 4];
0125     }
0126
0127     frame[offset + size + 4] = checksum;
0128
0129     return (size + 5);
0130 }
0131
0132 /********************************************
0133  *
0134  *      Configuration Response Functions
0135  *
0136  ********************************************/
0137
0138 static void wilc_wlan_parse_response_frame(struct wilc *wl, u8 *info, int size)
0139 {
0140     u16 wid;
0141     u32 len = 0, i = 0;
0142     struct wilc_cfg *cfg = &wl->cfg;
0143
0144     while (size > 0) {
0145         i = 0;
0146         wid = get_unaligned_le16(info);
0147
0148         switch (FIELD_GET(WILC_WID_TYPE, wid)) {
0149         case WID_CHAR:
0150             while (cfg->b[i].id != WID_NIL && cfg->b[i].id != wid)
0151                 i++;
0152
0153             if (cfg->b[i].id == wid)
0154                 cfg->b[i].val = info[4];
0155
0156             len = 3;
0157             break;
0158
0159         case WID_SHORT:
0160             while (cfg->hw[i].id != WID_NIL && cfg->hw[i].id != wid)
0161                 i++;
0162
0163             if (cfg->hw[i].id == wid)
0164                 cfg->hw[i].val = get_unaligned_le16(&info[4]);
0165
0166             len = 4;
0167             break;
0168
0169         case WID_INT:
0170             while (cfg->w[i].id != WID_NIL && cfg->w[i].id != wid)
0171                 i++;
0172
0173             if (cfg->w[i].id == wid)
0174                 cfg->w[i].val = get_unaligned_le32(&info[4]);
0175
0176             len = 6;
0177             break;
0178
0179         case WID_STR:
0180             while (cfg->s[i].id != WID_NIL && cfg->s[i].id != wid)
0181                 i++;
0182
0183             if (cfg->s[i].id == wid)
0184                 memcpy(cfg->s[i].str, &info[2],
0185                        get_unaligned_le16(&info[2]) + 2);
0186
0187             len = 2 + get_unaligned_le16(&info[2]);
0188             break;
0189
0190         default:
0191             break;
0192         }
0193         size -= (2 + len);
0194         info += (2 + len);
0195     }
0196 }
0197
0198 static void wilc_wlan_parse_info_frame(struct wilc *wl, u8 *info)
0199 {
0200     u32 wid, len;
0201
0202     wid = get_unaligned_le16(info);
0203
0204     len = info[2];
0205
0206     if (len == 1 && wid == WID_STATUS) {
0207         int i = 0;
0208
0209         while (wl->cfg.b[i].id != WID_NIL &&
0210                wl->cfg.b[i].id != wid)
0211             i++;
0212
0213         if (wl->cfg.b[i].id == wid)
0214             wl->cfg.b[i].val = info[3];
0215     }
0216 }
0217
0218 /********************************************
0219  *
0220  *      Configuration Exported Functions
0221  *
0222  ********************************************/
0223
0224 int wilc_wlan_cfg_set_wid(u8 *frame, u32 offset, u16 id, u8 *buf, int size)
0225 {
0226     u8 type = FIELD_GET(WILC_WID_TYPE, id);
0227     int ret = 0;
0228
0229     switch (type) {
0230     case CFG_BYTE_CMD:
0231         if (size >= 1)
0232             ret = wilc_wlan_cfg_set_byte(frame, offset, id, *buf);
0233         break;
0234
0235     case CFG_HWORD_CMD:
0236         if (size >= 2)
0237             ret = wilc_wlan_cfg_set_hword(frame, offset, id,
0238                               *((u16 *)buf));
0239         break;
0240
0241     case CFG_WORD_CMD:
0242         if (size >= 4)
0243             ret = wilc_wlan_cfg_set_word(frame, offset, id,
0244                              *((u32 *)buf));
0245         break;
0246
0247     case CFG_STR_CMD:
0248         ret = wilc_wlan_cfg_set_str(frame, offset, id, buf, size);
0249         break;
0250
0251     case CFG_BIN_CMD:
0252         ret = wilc_wlan_cfg_set_bin(frame, offset, id, buf, size);
0253         break;
0254     }
0255
0256     return ret;
0257 }
0258
0259 int wilc_wlan_cfg_get_wid(u8 *frame, u32 offset, u16 id)
0260 {
0261     if ((offset + 2) >= WILC_MAX_CFG_FRAME_SIZE)
0262         return 0;
0263
0264     put_unaligned_le16(id, &frame[offset]);
0265
0266     return 2;
0267 }
0268
0269 int wilc_wlan_cfg_get_val(struct wilc *wl, u16 wid, u8 *buffer,
0270               u32 buffer_size)
0271 {
0272     u8 type = FIELD_GET(WILC_WID_TYPE, wid);
0273     int i, ret = 0;
0274     struct wilc_cfg *cfg = &wl->cfg;
0275
0276     i = 0;
0277     if (type == CFG_BYTE_CMD) {
0278         while (cfg->b[i].id != WID_NIL && cfg->b[i].id != wid)
0279             i++;
0280
0281         if (cfg->b[i].id == wid) {
0282             memcpy(buffer, &cfg->b[i].val, 1);
0283             ret = 1;
0284         }
0285     } else if (type == CFG_HWORD_CMD) {
0286         while (cfg->hw[i].id != WID_NIL && cfg->hw[i].id != wid)
0287             i++;
0288
0289         if (cfg->hw[i].id == wid) {
0290             memcpy(buffer, &cfg->hw[i].val, 2);
0291             ret = 2;
0292         }
0293     } else if (type == CFG_WORD_CMD) {
0294         while (cfg->w[i].id != WID_NIL && cfg->w[i].id != wid)
0295             i++;
0296
0297         if (cfg->w[i].id == wid) {
0298             memcpy(buffer, &cfg->w[i].val, 4);
0299             ret = 4;
0300         }
0301     } else if (type == CFG_STR_CMD) {
0302         while (cfg->s[i].id != WID_NIL && cfg->s[i].id != wid)
0303             i++;
0304
0305         if (cfg->s[i].id == wid) {
0306             u16 size = get_unaligned_le16(cfg->s[i].str);
0307
0308             if (buffer_size >= size) {
0309                 memcpy(buffer, &cfg->s[i].str[2], size);
0310                 ret = size;
0311             }
0312         }
0313     }
0314     return ret;
0315 }
0316
0317 void wilc_wlan_cfg_indicate_rx(struct wilc *wilc, u8 *frame, int size,
0318                    struct wilc_cfg_rsp *rsp)
0319 {
0320     u8 msg_type;
0321     u8 msg_id;
0322
0323     msg_type = frame[0];
0324     msg_id = frame[1];      /* seq no */
0325     frame += 4;
0326     size -= 4;
0327     rsp->type = 0;
0328
0329     switch (msg_type) {
0330     case WILC_RESP_MSG_TYPE_CONFIG_REPLY:
0331         wilc_wlan_parse_response_frame(wilc, frame, size);
0332         rsp->type = WILC_CFG_RSP;
0333         rsp->seq_no = msg_id;
0334         break;
0335
0336     case WILC_RESP_MSG_TYPE_STATUS_INFO:
0337         wilc_wlan_parse_info_frame(wilc, frame);
0338         rsp->type = WILC_CFG_RSP_STATUS;
0339         rsp->seq_no = msg_id;
0340         /* call host interface info parse as well */
0341         wilc_gnrl_async_info_received(wilc, frame - 4, size + 4);
0342         break;
0343
0344     case WILC_RESP_MSG_TYPE_NETWORK_INFO:
0345         wilc_network_info_received(wilc, frame - 4, size + 4);
0346         break;
0347
0348     case WILC_RESP_MSG_TYPE_SCAN_COMPLETE:
0349         wilc_scan_complete_received(wilc, frame - 4, size + 4);
0350         break;
0351
0352     default:
0353         rsp->seq_no = msg_id;
0354         break;
0355     }
0356 }
0357
0358 int wilc_wlan_cfg_init(struct wilc *wl)
0359 {
0360     struct wilc_cfg_str_vals *str_vals;
0361     int i = 0;
0362
0363     wl->cfg.b = kmemdup(g_cfg_byte, sizeof(g_cfg_byte), GFP_KERNEL);
0364     if (!wl->cfg.b)
0365         return -ENOMEM;
0366
0367     wl->cfg.hw = kmemdup(g_cfg_hword, sizeof(g_cfg_hword), GFP_KERNEL);
0368     if (!wl->cfg.hw)
0369         goto out_b;
0370
0371     wl->cfg.w = kmemdup(g_cfg_word, sizeof(g_cfg_word), GFP_KERNEL);
0372     if (!wl->cfg.w)
0373         goto out_hw;
0374
0375     wl->cfg.s = kmemdup(g_cfg_str, sizeof(g_cfg_str), GFP_KERNEL);
0376     if (!wl->cfg.s)
0377         goto out_w;
0378
0379     str_vals = kzalloc(sizeof(*str_vals), GFP_KERNEL);
0380     if (!str_vals)
0381         goto out_s;
0382
0383     wl->cfg.str_vals = str_vals;
0384     /* store the string cfg parameters */
0385     wl->cfg.s[i].id = WID_FIRMWARE_VERSION;
0386     wl->cfg.s[i].str = str_vals->firmware_version;
0387     i++;
0388     wl->cfg.s[i].id = WID_MAC_ADDR;
0389     wl->cfg.s[i].str = str_vals->mac_address;
0390     i++;
0391     wl->cfg.s[i].id = WID_ASSOC_RES_INFO;
0392     wl->cfg.s[i].str = str_vals->assoc_rsp;
0393     i++;
0394     wl->cfg.s[i].id = WID_NIL;
0395     wl->cfg.s[i].str = NULL;
0396     return 0;
0397
0398 out_s:
0399     kfree(wl->cfg.s);
0400 out_w:
0401     kfree(wl->cfg.w);
0402 out_hw:
0403     kfree(wl->cfg.hw);
0404 out_b:
0405     kfree(wl->cfg.b);
0406     return -ENOMEM;
0407 }
0408
0409 void wilc_wlan_cfg_deinit(struct wilc *wl)
0410 {
0411     kfree(wl->cfg.b);
0412     kfree(wl->cfg.hw);
0413     kfree(wl->cfg.w);
0414     kfree(wl->cfg.s);
0415     kfree(wl->cfg.str_vals);
0416 }