drivers/net/wireless/intel/iwlwifi/iwl-phy-db.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2005-2014, 2020-2021 Intel Corporation
   4  * Copyright (C) 2016 Intel Deutschland GmbH
   5  */
   6 #include <linux/slab.h>
   7 #include <linux/string.h>
   8 #include <linux/export.h>
   9
  10 #include "iwl-drv.h"
  11 #include "iwl-phy-db.h"
  12 #include "iwl-debug.h"
  13 #include "iwl-op-mode.h"
  14 #include "iwl-trans.h"
  15
  16 struct iwl_phy_db_entry {
  17         u16     size;
  18         u8      *data;
  19 };
  20
  21 /**
  22  * struct iwl_phy_db - stores phy configuration and calibration data.
  23  *
  24  * @cfg: phy configuration.
  25  * @calib_nch: non channel specific calibration data.
  26  * @n_group_papd: number of entries in papd channel group.
  27  * @calib_ch_group_papd: calibration data related to papd channel group.
  28  * @n_group_txp: number of entries in tx power channel group.
  29  * @calib_ch_group_txp: calibration data related to tx power chanel group.
  30  * @trans: transport layer
  31  */
  32 struct iwl_phy_db {
  33         struct iwl_phy_db_entry cfg;
  34         struct iwl_phy_db_entry calib_nch;
  35         int n_group_papd;
  36         struct iwl_phy_db_entry *calib_ch_group_papd;
  37         int n_group_txp;
  38         struct iwl_phy_db_entry *calib_ch_group_txp;
  39
  40         struct iwl_trans *trans;
  41 };
  42
  43 enum iwl_phy_db_section_type {
  44         IWL_PHY_DB_CFG = 1,
  45         IWL_PHY_DB_CALIB_NCH,
  46         IWL_PHY_DB_UNUSED,
  47         IWL_PHY_DB_CALIB_CHG_PAPD,
  48         IWL_PHY_DB_CALIB_CHG_TXP,
  49         IWL_PHY_DB_MAX
  50 };
  51
  52 #define PHY_DB_CMD 0x6c
  53
  54 /* for parsing of tx power channel group data that comes from the firmware*/
  55 struct iwl_phy_db_chg_txp {
  56         __le32 space;
  57         __le16 max_channel_idx;
  58 } __packed;
  59
  60 struct iwl_phy_db *iwl_phy_db_init(struct iwl_trans *trans)
  61 {
  62         struct iwl_phy_db *phy_db = kzalloc(sizeof(struct iwl_phy_db),
  63                                             GFP_KERNEL);
  64
  65         if (!phy_db)
  66                 return phy_db;
  67
  68         phy_db->trans = trans;
  69
  70         phy_db->n_group_txp = -1;
  71         phy_db->n_group_papd = -1;
  72
  73         /* TODO: add default values of the phy db. */
  74         return phy_db;
  75 }
  76 IWL_EXPORT_SYMBOL(iwl_phy_db_init);
  77
  78 /*
  79  * get phy db section: returns a pointer to a phy db section specified by
  80  * type and channel group id.
  81  */
  82 static struct iwl_phy_db_entry *
  83 iwl_phy_db_get_section(struct iwl_phy_db *phy_db,
  84                        enum iwl_phy_db_section_type type,
  85                        u16 chg_id)
  86 {
  87         if (!phy_db || type >= IWL_PHY_DB_MAX)
  88                 return NULL;
  89
  90         switch (type) {
  91         case IWL_PHY_DB_CFG:
  92                 return &phy_db->cfg;
  93         case IWL_PHY_DB_CALIB_NCH:
  94                 return &phy_db->calib_nch;
  95         case IWL_PHY_DB_CALIB_CHG_PAPD:
  96                 if (chg_id >= phy_db->n_group_papd)
  97                         return NULL;
  98                 return &phy_db->calib_ch_group_papd[chg_id];
  99         case IWL_PHY_DB_CALIB_CHG_TXP:
 100                 if (chg_id >= phy_db->n_group_txp)
 101                         return NULL;
 102                 return &phy_db->calib_ch_group_txp[chg_id];
 103         default:
 104                 return NULL;
 105         }
 106         return NULL;
 107 }
 108
 109 static void iwl_phy_db_free_section(struct iwl_phy_db *phy_db,
 110                                     enum iwl_phy_db_section_type type,
 111                                     u16 chg_id)
 112 {
 113         struct iwl_phy_db_entry *entry =
 114                                 iwl_phy_db_get_section(phy_db, type, chg_id);
 115         if (!entry)
 116                 return;
 117
 118         kfree(entry->data);
 119         entry->data = NULL;
 120         entry->size = 0;
 121 }
 122
 123 void iwl_phy_db_free(struct iwl_phy_db *phy_db)
 124 {
 125         int i;
 126
 127         if (!phy_db)
 128                 return;
 129
 130         iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CFG, 0);
 131         iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CALIB_NCH, 0);
 132
 133         for (i = 0; i < phy_db->n_group_papd; i++)
 134                 iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CALIB_CHG_PAPD, i);
 135         kfree(phy_db->calib_ch_group_papd);
 136
 137         for (i = 0; i < phy_db->n_group_txp; i++)
 138                 iwl_phy_db_free_section(phy_db, IWL_PHY_DB_CALIB_CHG_TXP, i);
 139         kfree(phy_db->calib_ch_group_txp);
 140
 141         kfree(phy_db);
 142 }
 143 IWL_EXPORT_SYMBOL(iwl_phy_db_free);
 144
 145 int iwl_phy_db_set_section(struct iwl_phy_db *phy_db,
 146                            struct iwl_rx_packet *pkt)
 147 {
 148         unsigned int pkt_len = iwl_rx_packet_payload_len(pkt);
 149         struct iwl_calib_res_notif_phy_db *phy_db_notif =
 150                         (struct iwl_calib_res_notif_phy_db *)pkt->data;
 151         enum iwl_phy_db_section_type type;
 152         u16 size;
 153         struct iwl_phy_db_entry *entry;
 154         u16 chg_id = 0;
 155
 156         if (pkt_len < sizeof(*phy_db_notif))
 157                 return -EINVAL;
 158
 159         type = le16_to_cpu(phy_db_notif->type);
 160         size = le16_to_cpu(phy_db_notif->length);
 161
 162         if (pkt_len < sizeof(*phy_db_notif) + size)
 163                 return -EINVAL;
 164
 165         if (!phy_db)
 166                 return -EINVAL;
 167
 168         if (type == IWL_PHY_DB_CALIB_CHG_PAPD) {
 169                 chg_id = le16_to_cpup((__le16 *)phy_db_notif->data);
 170                 if (phy_db && !phy_db->calib_ch_group_papd) {
 171                         /*
 172                          * Firmware sends the largest index first, so we can use
 173                          * it to know how much we should allocate.
 174                          */
 175                         phy_db->calib_ch_group_papd = kcalloc(chg_id + 1,
 176                                                               sizeof(struct iwl_phy_db_entry),
 177                                                               GFP_ATOMIC);
 178                         if (!phy_db->calib_ch_group_papd)
 179                                 return -ENOMEM;
 180                         phy_db->n_group_papd = chg_id + 1;
 181                 }
 182         } else if (type == IWL_PHY_DB_CALIB_CHG_TXP) {
 183                 chg_id = le16_to_cpup((__le16 *)phy_db_notif->data);
 184                 if (phy_db && !phy_db->calib_ch_group_txp) {
 185                         /*
 186                          * Firmware sends the largest index first, so we can use
 187                          * it to know how much we should allocate.
 188                          */
 189                         phy_db->calib_ch_group_txp = kcalloc(chg_id + 1,
 190                                                              sizeof(struct iwl_phy_db_entry),
 191                                                              GFP_ATOMIC);
 192                         if (!phy_db->calib_ch_group_txp)
 193                                 return -ENOMEM;
 194                         phy_db->n_group_txp = chg_id + 1;
 195                 }
 196         }
 197
 198         entry = iwl_phy_db_get_section(phy_db, type, chg_id);
 199         if (!entry)
 200                 return -EINVAL;
 201
 202         kfree(entry->data);
 203         entry->data = kmemdup(phy_db_notif->data, size, GFP_ATOMIC);
 204         if (!entry->data) {
 205                 entry->size = 0;
 206                 return -ENOMEM;
 207         }
 208
 209         entry->size = size;
 210
 211         IWL_DEBUG_INFO(phy_db->trans,
 212                        "%s(%d): [PHYDB]SET: Type %d , Size: %d\n",
 213                        __func__, __LINE__, type, size);
 214
 215         return 0;
 216 }
 217 IWL_EXPORT_SYMBOL(iwl_phy_db_set_section);
 218
 219 static int is_valid_channel(u16 ch_id)
 220 {
 221         if (ch_id <= 14 ||
 222             (36 <= ch_id && ch_id <= 64 && ch_id % 4 == 0) ||
 223             (100 <= ch_id && ch_id <= 140 && ch_id % 4 == 0) ||
 224             (145 <= ch_id && ch_id <= 165 && ch_id % 4 == 1))
 225                 return 1;
 226         return 0;
 227 }
 228
 229 static u8 ch_id_to_ch_index(u16 ch_id)
 230 {
 231         if (WARN_ON(!is_valid_channel(ch_id)))
 232                 return 0xff;
 233
 234         if (ch_id <= 14)
 235                 return ch_id - 1;
 236         if (ch_id <= 64)
 237                 return (ch_id + 20) / 4;
 238         if (ch_id <= 140)
 239                 return (ch_id - 12) / 4;
 240         return (ch_id - 13) / 4;
 241 }
 242
 243
 244 static u16 channel_id_to_papd(u16 ch_id)
 245 {
 246         if (WARN_ON(!is_valid_channel(ch_id)))
 247                 return 0xff;
 248
 249         if (1 <= ch_id && ch_id <= 14)
 250                 return 0;
 251         if (36 <= ch_id && ch_id <= 64)
 252                 return 1;
 253         if (100 <= ch_id && ch_id <= 140)
 254                 return 2;
 255         return 3;
 256 }
 257
 258 static u16 channel_id_to_txp(struct iwl_phy_db *phy_db, u16 ch_id)
 259 {
 260         struct iwl_phy_db_chg_txp *txp_chg;
 261         int i;
 262         u8 ch_index = ch_id_to_ch_index(ch_id);
 263         if (ch_index == 0xff)
 264                 return 0xff;
 265
 266         for (i = 0; i < phy_db->n_group_txp; i++) {
 267                 txp_chg = (void *)phy_db->calib_ch_group_txp[i].data;
 268                 if (!txp_chg)
 269                         return 0xff;
 270                 /*
 271                  * Looking for the first channel group that its max channel is
 272                  * higher then wanted channel.
 273                  */
 274                 if (le16_to_cpu(txp_chg->max_channel_idx) >= ch_index)
 275                         return i;
 276         }
 277         return 0xff;
 278 }
 279 static
 280 int iwl_phy_db_get_section_data(struct iwl_phy_db *phy_db,
 281                                 u32 type, u8 **data, u16 *size, u16 ch_id)
 282 {
 283         struct iwl_phy_db_entry *entry;
 284         u16 ch_group_id = 0;
 285
 286         if (!phy_db)
 287                 return -EINVAL;
 288
 289         /* find wanted channel group */
 290         if (type == IWL_PHY_DB_CALIB_CHG_PAPD)
 291                 ch_group_id = channel_id_to_papd(ch_id);
 292         else if (type == IWL_PHY_DB_CALIB_CHG_TXP)
 293                 ch_group_id = channel_id_to_txp(phy_db, ch_id);
 294
 295         entry = iwl_phy_db_get_section(phy_db, type, ch_group_id);
 296         if (!entry)
 297                 return -EINVAL;
 298
 299         *data = entry->data;
 300         *size = entry->size;
 301
 302         IWL_DEBUG_INFO(phy_db->trans,
 303                        "%s(%d): [PHYDB] GET: Type %d , Size: %d\n",
 304                        __func__, __LINE__, type, *size);
 305
 306         return 0;
 307 }
 308
 309 static int iwl_send_phy_db_cmd(struct iwl_phy_db *phy_db, u16 type,
 310                                u16 length, void *data)
 311 {
 312         struct iwl_phy_db_cmd phy_db_cmd;
 313         struct iwl_host_cmd cmd = {
 314                 .id = PHY_DB_CMD,
 315         };
 316
 317         IWL_DEBUG_INFO(phy_db->trans,
 318                        "Sending PHY-DB hcmd of type %d, of length %d\n",
 319                        type, length);
 320
 321         /* Set phy db cmd variables */
 322         phy_db_cmd.type = cpu_to_le16(type);
 323         phy_db_cmd.length = cpu_to_le16(length);
 324
 325         /* Set hcmd variables */
 326         cmd.data[0] = &phy_db_cmd;
 327         cmd.len[0] = sizeof(struct iwl_phy_db_cmd);
 328         cmd.data[1] = data;
 329         cmd.len[1] = length;
 330         cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
 331
 332         return iwl_trans_send_cmd(phy_db->trans, &cmd);
 333 }
 334
 335 static int iwl_phy_db_send_all_channel_groups(
 336                                         struct iwl_phy_db *phy_db,
 337                                         enum iwl_phy_db_section_type type,
 338                                         u8 max_ch_groups)
 339 {
 340         u16 i;
 341         int err;
 342         struct iwl_phy_db_entry *entry;
 343
 344         /* Send all the  channel specific groups to operational fw */
 345         for (i = 0; i < max_ch_groups; i++) {
 346                 entry = iwl_phy_db_get_section(phy_db,
 347                                                type,
 348                                                i);
 349                 if (!entry)
 350                         return -EINVAL;
 351
 352                 if (!entry->size)
 353                         continue;
 354
 355                 /* Send the requested PHY DB section */
 356                 err = iwl_send_phy_db_cmd(phy_db,
 357                                           type,
 358                                           entry->size,
 359                                           entry->data);
 360                 if (err) {
 361                         IWL_ERR(phy_db->trans,
 362                                 "Can't SEND phy_db section %d (%d), err %d\n",
 363                                 type, i, err);
 364                         return err;
 365                 }
 366
 367                 IWL_DEBUG_INFO(phy_db->trans,
 368                                "Sent PHY_DB HCMD, type = %d num = %d\n",
 369                                type, i);
 370         }
 371
 372         return 0;
 373 }
 374
 375 int iwl_send_phy_db_data(struct iwl_phy_db *phy_db)
 376 {
 377         u8 *data = NULL;
 378         u16 size = 0;
 379         int err;
 380
 381         IWL_DEBUG_INFO(phy_db->trans,
 382                        "Sending phy db data and configuration to runtime image\n");
 383
 384         /* Send PHY DB CFG section */
 385         err = iwl_phy_db_get_section_data(phy_db, IWL_PHY_DB_CFG,
 386                                           &data, &size, 0);
 387         if (err) {
 388                 IWL_ERR(phy_db->trans, "Cannot get Phy DB cfg section\n");
 389                 return err;
 390         }
 391
 392         err = iwl_send_phy_db_cmd(phy_db, IWL_PHY_DB_CFG, size, data);
 393         if (err) {
 394                 IWL_ERR(phy_db->trans,
 395                         "Cannot send HCMD of  Phy DB cfg section\n");
 396                 return err;
 397         }
 398
 399         err = iwl_phy_db_get_section_data(phy_db, IWL_PHY_DB_CALIB_NCH,
 400                                           &data, &size, 0);
 401         if (err) {
 402                 IWL_ERR(phy_db->trans,
 403                         "Cannot get Phy DB non specific channel section\n");
 404                 return err;
 405         }
 406
 407         err = iwl_send_phy_db_cmd(phy_db, IWL_PHY_DB_CALIB_NCH, size, data);
 408         if (err) {
 409                 IWL_ERR(phy_db->trans,
 410                         "Cannot send HCMD of Phy DB non specific channel section\n");
 411                 return err;
 412         }
 413
 414         /* Send all the TXP channel specific data */
 415         err = iwl_phy_db_send_all_channel_groups(phy_db,
 416                                                  IWL_PHY_DB_CALIB_CHG_PAPD,
 417                                                  phy_db->n_group_papd);
 418         if (err) {
 419                 IWL_ERR(phy_db->trans,
 420                         "Cannot send channel specific PAPD groups\n");
 421                 return err;
 422         }
 423
 424         /* Send all the TXP channel specific data */
 425         err = iwl_phy_db_send_all_channel_groups(phy_db,
 426                                                  IWL_PHY_DB_CALIB_CHG_TXP,
 427                                                  phy_db->n_group_txp);
 428         if (err) {
 429                 IWL_ERR(phy_db->trans,
 430                         "Cannot send channel specific TX power groups\n");
 431                 return err;
 432         }
 433
 434         IWL_DEBUG_INFO(phy_db->trans,
 435                        "Finished sending phy db non channel data\n");
 436         return 0;
 437 }
 438 IWL_EXPORT_SYMBOL(iwl_send_phy_db_data);