third_party/iwlwifi/mvm/fm-test.c

/******************************************************************************
 *
 * Copyright(c) 2013 - 2015 Intel Corporation. All rights reserved.
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Intel Corporation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *****************************************************************************/
#include <linux/debugfs.h>
#include <linux/fm/iui_fm.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>

/*
 * UT framework to debug Frequency Manager on any platform.
 *
 * The framework contains stub functions & debugfs entries so the iwlwifi driver
 * can run the FM code  without having an active FM in the background.
 *
 * FM--> iwlwifi driver API:
 * Done via debugfs entry: request the driver to mitigate its activity.
 * Through the debugfs the user can request driver to start tx power &
 * 2g coex mitigation.
 *
 * Iwlwfi driver-->FM API
 * Done via internal "stub" functions that will simulate the calls to the FM
 * If the debug mode is set, the calls to the real API functions are ignored,
 * and the stubs are called instead.
 *
 * To activate the FM debug mode you need to:
 * 1. Enable the IWLWIFI_FRQ_MGR_TEST config (it will enable by default the
 * IWLWIFI_FRQ_MGR config)
 * 2. add fm_debug_mode=0x1 in the file iwl-dbg-cfg.ini
 *
 * NOTE: If the platform does not have a FM then the ut will use the
 * include/linux/fm/iui_fm_test.h header file, otherwise it will use the
 * platform header file.
 */

/* pointer to callback function in debug mode */
static iui_fm_mitigation_cb fm_callback;
static struct iui_fm_wlan_info fm_notif;
static struct dentry* fm_debug_dir;

static ssize_t iwl_mvm_fm_debug_mitigate_write(struct file* file, const char __user* user_buf,
                                               size_t count, loff_t* ppos) {
  struct iui_fm_mitigation mitigation;
  struct iui_fm_wlan_mitigation wm;
  char buf[128];
  size_t buf_size = sizeof(buf);
  int mitigate_2g;
  int ret;
  int mitigate_dcdc;

  mitigation.info.wlan_mitigation = &wm;
  mitigation.type = IUI_FM_MITIGATION_TYPE_WLAN;

  if (copy_from_user(buf, user_buf, buf_size)) {
    return -EFAULT;
  }

  /* All platforms that are not xmm6321 & SOFIA 3G */
  if (IUI_FM_WLAN_MAX_CHANNELS == 4) {
    if (sscanf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", &wm.num_channels,
               &wm.channel_tx_pwr[0].frequency, &wm.channel_tx_pwr[0].max_tx_pwr,
               &wm.channel_tx_pwr[1].frequency, &wm.channel_tx_pwr[1].max_tx_pwr,
               &wm.channel_tx_pwr[2].frequency, &wm.channel_tx_pwr[2].max_tx_pwr,
               &wm.channel_tx_pwr[3].frequency, &wm.channel_tx_pwr[3].max_tx_pwr, &mitigate_dcdc,
               &wm.dcdc_div0, &wm.dcdc_div1, &mitigate_2g, &wm.wlan_2g_coex_enable) != 14) {
      return -EINVAL;
    }
  } else if (sscanf(buf, "%d,%d,%d,%d,%d", &wm.num_channels, &wm.channel_tx_pwr[0].frequency,
                    &wm.channel_tx_pwr[0].max_tx_pwr, &wm.channel_tx_pwr[1].frequency,
                    &wm.channel_tx_pwr[1].max_tx_pwr) != 5) {
    return -EINVAL;
  }

  if (IUI_FM_WLAN_MAX_CHANNELS < wm.num_channels) {
    return -EINVAL;
  }

  wm.wlan_adc_dac_freq = 0;
  wm.rx_gain_behavior = IUI_FM_WLAN_RX_GAIN_NORMAL;

  wm.bitmask = 0;

  /* Set bit bitmask to indicate the required mitigations */
  if (wm.num_channels || mitigate_2g) {
    wm.bitmask |= WLAN_MITI;
  }
  if (mitigate_dcdc) {
    wm.bitmask |= DCDC_MITI;
  }

  ret = fm_callback(IUI_FM_MACRO_ID_WLAN, &mitigation, 0);
  pr_info("FM[test-mode]: mitigation callback %s (bitmask = 0x%x)\n", ret ? "failed" : "succeeded",
          wm.bitmask);

  return count;
}

static ssize_t iwl_mvm_fm_debug_notify_read(struct file* file, char __user* userbuf, size_t count,
                                            loff_t* ppos) {
  char buf[512];
  int bufsz = sizeof(buf);
  int pos = 0;
  uint8_t i;

  pos += scnprintf(buf + pos, bufsz - pos, "num_channels=%d\n", fm_notif.num_channels);
  for (i = 0; i < fm_notif.num_channels; i++)
    pos += scnprintf(buf + pos, bufsz - pos, "channel=%d, bandwidth=%d\n",
                     fm_notif.channel_info[i].frequency, fm_notif.channel_info[i].bandwidth);

  pos += scnprintf(buf + pos, bufsz - pos, "dcdc_div0=%d\n", fm_notif.dcdc_div0);
  pos += scnprintf(buf + pos, bufsz - pos, "dcdc_div1=%d\n", fm_notif.dcdc_div1);

  return simple_read_from_buffer(userbuf, count, ppos, buf, pos);
}

static const struct file_operations fm_debug_mitigate_ops = {
    .write = iwl_mvm_fm_debug_mitigate_write,
    .open = simple_open,
    .llseek = generic_file_llseek,
};

static const struct file_operations fm_debug_notify_ops = {
    .read = iwl_mvm_fm_debug_notify_read,
    .open = simple_open,
    .llseek = generic_file_llseek,
};

static int iwl_mvm_fm_create_debugfs(void) {
  struct dentry* entry;

  fm_debug_dir = debugfs_create_dir("frq_mgr", NULL);

  if (!fm_debug_dir) {
    goto err;
  }

  entry = debugfs_create_file("mitigate", S_IWUSR, fm_debug_dir, NULL, &fm_debug_mitigate_ops);
  if (!entry) {
    goto err;
  }

  entry = debugfs_create_file("notify", S_IRUSR, fm_debug_dir, NULL, &fm_debug_notify_ops);
  if (!entry) {
    goto err;
  }

  return 0;
err:
  pr_info("FM: Could not create debugfs entries\n");
  debugfs_remove_recursive(fm_debug_dir);
  return -1;
}

int32_t iwl_mvm_fm_test_register_callback(const enum iui_fm_macro_id macro_id,
                                          const iui_fm_mitigation_cb mitigation_cb) {
  int ret = 0;

  fm_callback = mitigation_cb;

  /* Unregister fm callback */
  if (!mitigation_cb) {
    debugfs_remove_recursive(fm_debug_dir);
    goto end;
  }

  /* Register fm callback */
  if (iwl_mvm_fm_create_debugfs()) {
    ret = -1;
    goto end;
  }

end:
  pr_info("FM[test-mode]: %sregistering fm callback function (fail = %d)\n", ret ? "un" : "", ret);
  return ret;
}

int32_t iwl_mvm_fm_test_notify_frequency(
    const enum iui_fm_macro_id macro_id,
    const struct iui_fm_freq_notification* const notification) {
  /* Platform does not have a FM or test mode was requested */
  memcpy(&fm_notif, notification->info.wlan_info, sizeof(struct iui_fm_wlan_info));

  pr_info("FM[test-mode]: notifying fm about change (mask = 0x%x)\n",
          notification->info.wlan_info->bitmask);

  return 0;
}