drivers/staging/wilc1000/wlan_cfg.c

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