| /****************************************************************************** |
| * |
| * Copyright(c) 2014 Intel Corporation. All rights reserved. |
| * Copyright(c) 2014 Intel Mobile Communications GmbH |
| * Copyright(c) 2016-2017 Intel Deutschland 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/export.h> |
| #include <linux/kthread.h> |
| #include <linux/module.h> |
| #include <linux/types.h> |
| |
| #include "iwl-config.h" |
| #include "iwl-debug.h" |
| #include "iwl-dnt-cfg.h" |
| #include "iwl-dnt-dev-if.h" |
| #include "iwl-dnt-dispatch.h" |
| #include "iwl-drv.h" |
| #include "iwl-tm-gnl.h" |
| |
| #ifdef CPTCFG_IWLWIFI_DEBUGFS |
| |
| /* |
| * iwl_dnt_debugfs_log_read - returns ucodeMessages to the user. |
| * The logs are returned in binary format until the buffer of debugfs is |
| * exhausted. If a log can't be copied to user (due to general error, not |
| * a size problem) it is totally discarded and lost. |
| */ |
| static ssize_t iwl_dnt_debugfs_log_read(struct file* file, char __user* user_buf, size_t count, |
| loff_t* ppos) { |
| struct iwl_trans* trans = file->private_data; |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| struct dnt_collect_db* db = dnt->dispatch.um_db; |
| unsigned char* temp_buf; |
| int ret = 0; |
| |
| temp_buf = kzalloc(count, GFP_KERNEL); |
| if (!temp_buf) { return -ENOMEM; } |
| |
| dnt->debugfs_counter++; |
| do { |
| /* wait for new logs */ |
| ret = wait_event_interruptible_timeout(db->waitq, |
| (!trans->op_mode || db->read_ptr != db->wr_ptr), HZ); |
| if (ret < 0 || !trans->op_mode) { |
| /* we reached EOF */ |
| ret = 0; |
| break; |
| } |
| if (ret == 0) { |
| /* |
| * temp_buf is zeroed at this point, so if we set the |
| * size to non-zero we'll return zeroes to userspace, |
| * which the trace viewer will ignore (outside of a |
| * specific trace item/event) |
| */ |
| ret = sizeof(uint32_t); |
| break; |
| } |
| |
| ret = iwl_dnt_dispatch_pull(trans, temp_buf, count, UCODE_MESSAGES); |
| if (ret < 0) { |
| IWL_DEBUG_INFO(trans, "Failed to retrieve debug data\n"); |
| goto free_buf; |
| } |
| } while (!ret); |
| |
| *ppos = 0; |
| ret = simple_read_from_buffer(user_buf, ret, ppos, temp_buf, count); |
| free_buf: |
| kfree(temp_buf); |
| dnt->debugfs_counter--; |
| wake_up(&dnt->debugfs_waitq); |
| return ret; |
| } |
| |
| static const struct file_operations iwl_dnt_debugfs_log_ops = { |
| .read = iwl_dnt_debugfs_log_read, |
| .open = simple_open, |
| .llseek = generic_file_llseek, |
| }; |
| |
| static bool iwl_dnt_register_debugfs_entries(struct iwl_trans* trans, struct dentry* dbgfs_dir) { |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| |
| dnt->debugfs_entry = debugfs_create_dir("dbgm", dbgfs_dir); |
| if (!dnt->debugfs_entry) { return false; } |
| |
| if (!debugfs_create_file("log", S_IRUSR, dnt->debugfs_entry, trans, &iwl_dnt_debugfs_log_ops)) { |
| return false; |
| } |
| return true; |
| } |
| #endif |
| |
| static bool iwl_dnt_configure_prepare_dma(struct iwl_dnt* dnt, struct iwl_trans* trans) { |
| struct iwl_dbg_cfg* dbg_cfg = &trans->dbg_cfg; |
| |
| if (dbg_cfg->dbm_destination_path != DMA || !dbg_cfg->dbgm_mem_power) { return true; } |
| |
| dnt->mon_buf_size = 0x800 << dbg_cfg->dbgm_mem_power; |
| dnt->mon_buf_cpu_addr = |
| dma_alloc_coherent(trans->dev, dnt->mon_buf_size, &dnt->mon_dma_addr, GFP_KERNEL); |
| if (!dnt->mon_buf_cpu_addr) { return false; } |
| |
| dnt->mon_base_addr = (uint64_t)dnt->mon_dma_addr; |
| dnt->mon_end_addr = dnt->mon_base_addr + dnt->mon_buf_size; |
| dnt->iwl_dnt_status |= IWL_DNT_STATUS_DMA_BUFFER_ALLOCATED; |
| |
| return true; |
| } |
| |
| static bool iwl_dnt_validate_configuration(struct iwl_trans* trans) { |
| struct iwl_dbg_cfg* dbg_cfg = &trans->dbg_cfg; |
| |
| if (!strcmp(trans->dev->bus->name, BUS_TYPE_PCI)) |
| return dbg_cfg->dbm_destination_path == DMA || dbg_cfg->dbm_destination_path == MARBH_ADC || |
| dbg_cfg->dbm_destination_path == MARBH_DBG || dbg_cfg->dbm_destination_path == MIPI; |
| else if (!strcmp(trans->dev->bus->name, BUS_TYPE_SDIO)) |
| return dbg_cfg->dbm_destination_path == MARBH_ADC || |
| dbg_cfg->dbm_destination_path == MARBH_DBG || dbg_cfg->dbm_destination_path == MIPI; |
| |
| return false; |
| } |
| |
| static int iwl_dnt_conf_monitor(struct iwl_trans* trans, uint32_t output, uint32_t monitor_type, |
| uint32_t target_mon_mode) { |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| |
| if (dnt->cur_input_mask & MONITOR_INPUT_MODE_MASK) { |
| IWL_INFO(trans, "DNT: Resetting deivce configuration\n"); |
| return iwl_dnt_dev_if_configure_monitor(dnt, trans); |
| } |
| |
| dnt->cur_input_mask |= MONITOR; |
| dnt->dispatch.mon_output = output; |
| dnt->cur_mon_type = monitor_type; |
| dnt->cur_mon_mode = target_mon_mode; |
| if (monitor_type == INTERFACE) { |
| if (output == NETLINK || output == FTRACE) { |
| /* setting PUSH out mode */ |
| dnt->dispatch.mon_out_mode = PUSH; |
| dnt->dispatch.mon_in_mode = COLLECT; |
| } else { |
| dnt->dispatch.dbgm_db = iwl_dnt_dispatch_allocate_collect_db(dnt); |
| if (!dnt->dispatch.dbgm_db) { return -ENOMEM; } |
| dnt->dispatch.mon_in_mode = RETRIEVE; |
| } |
| } else { |
| dnt->dispatch.mon_out_mode = PULL; |
| dnt->dispatch.mon_in_mode = RETRIEVE; |
| |
| /* |
| * If we're running a device that supports DBGC and monitor |
| * was given value as MARBH, it should be interpreted as SMEM |
| */ |
| if (trans->cfg->dbgc_supported && |
| (monitor_type == MARBH_ADC || monitor_type == MARBH_DBG)) { |
| dnt->cur_mon_type = SMEM; |
| } |
| } |
| return iwl_dnt_dev_if_configure_monitor(dnt, trans); |
| } |
| |
| void iwl_dnt_start(struct iwl_trans* trans) { |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| struct iwl_dbg_cfg* dbg_cfg = &trans->dbg_cfg; |
| |
| if (!dnt) { return; } |
| |
| if ((dnt->iwl_dnt_status & IWL_DNT_STATUS_MON_CONFIGURED) && dbg_cfg->dbg_conf_monitor_cmd_id) { |
| iwl_dnt_dev_if_start_monitor(dnt, trans); |
| } |
| |
| if ((dnt->iwl_dnt_status & IWL_DNT_STATUS_UCODE_MSGS_CONFIGURED) && dbg_cfg->log_level_cmd_id) { |
| iwl_dnt_dev_if_set_log_level(dnt, trans); |
| } |
| } |
| IWL_EXPORT_SYMBOL(iwl_dnt_start); |
| |
| #ifdef CPTCFG_IWLWIFI_DEBUGFS |
| static int iwl_dnt_conf_ucode_msgs_via_rx(struct iwl_trans* trans, uint32_t output) { |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| |
| dnt->cur_input_mask |= UCODE_MESSAGES; |
| dnt->dispatch.ucode_msgs_output = output; |
| |
| if (output == NETLINK || output == FTRACE) { |
| /* setting PUSH out mode */ |
| dnt->dispatch.ucode_msgs_out_mode = PUSH; |
| } else { |
| dnt->dispatch.um_db = iwl_dnt_dispatch_allocate_collect_db(dnt); |
| if (!dnt->dispatch.um_db) { return -ENOMEM; } |
| dnt->dispatch.ucode_msgs_out_mode = RETRIEVE; |
| } |
| /* setting COLLECT in mode */ |
| dnt->dispatch.ucode_msgs_in_mode = COLLECT; |
| dnt->iwl_dnt_status |= IWL_DNT_STATUS_UCODE_MSGS_CONFIGURED; |
| |
| return 0; |
| } |
| #endif |
| |
| void iwl_dnt_init(struct iwl_trans* trans, struct dentry* dbgfs_dir) { |
| struct iwl_dnt* dnt; |
| bool __maybe_unused ret; |
| int __maybe_unused err; |
| |
| dnt = kzalloc(sizeof(struct iwl_dnt), GFP_KERNEL); |
| if (!dnt) { return; } |
| |
| trans->tmdev->dnt = dnt; |
| |
| dnt->dev = trans->dev; |
| |
| #ifdef CPTCFG_IWLWIFI_DEBUGFS |
| ret = iwl_dnt_register_debugfs_entries(trans, dbgfs_dir); |
| if (!ret) { |
| IWL_ERR(trans, "Failed to create dnt debugfs entries\n"); |
| return; |
| } |
| err = iwl_dnt_conf_ucode_msgs_via_rx(trans, DEBUGFS); |
| if (err) { IWL_DEBUG_INFO(trans, "Failed to configure uCodeMessages\n"); } |
| init_waitqueue_head(&dnt->debugfs_waitq); |
| #endif |
| |
| if (!iwl_dnt_validate_configuration(trans)) { |
| dnt->iwl_dnt_status |= IWL_DNT_STATUS_INVALID_MONITOR_CONF; |
| return; |
| } |
| /* allocate DMA if needed */ |
| if (!iwl_dnt_configure_prepare_dma(dnt, trans)) { |
| IWL_ERR(trans, "Failed to prepare DMA\n"); |
| dnt->iwl_dnt_status |= IWL_DNT_STATUS_FAILED_TO_ALLOCATE_DMA; |
| } |
| } |
| IWL_EXPORT_SYMBOL(iwl_dnt_init); |
| |
| void iwl_dnt_free(struct iwl_trans* trans) { |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| |
| if (!dnt) { return; } |
| |
| #ifdef CPTCFG_IWLWIFI_DEBUGFS |
| debugfs_remove_recursive(dnt->debugfs_entry); |
| if (dnt->debugfs_counter) { |
| IWL_INFO(trans, "waiting for dnt debugfs release (cnt=%d)\n", dnt->debugfs_counter); |
| wake_up_interruptible(&dnt->dispatch.um_db->waitq); |
| wait_event(dnt->debugfs_waitq, dnt->debugfs_counter == 0); |
| } |
| #endif |
| iwl_dnt_dispatch_free(dnt, trans); |
| kfree(dnt); |
| } |
| IWL_EXPORT_SYMBOL(iwl_dnt_free); |
| |
| void iwl_dnt_configure(struct iwl_trans* trans, const struct fw_img* image) { |
| struct iwl_dnt* dnt = trans->tmdev->dnt; |
| struct iwl_dbg_cfg* dbg_cfg = &trans->dbg_cfg; |
| bool is_conf_invalid; |
| |
| if (!dnt) { return; } |
| |
| dnt->image = image; |
| |
| is_conf_invalid = (dnt->iwl_dnt_status & IWL_DNT_STATUS_INVALID_MONITOR_CONF); |
| |
| if (is_conf_invalid) { return; } |
| |
| switch (dbg_cfg->dbm_destination_path) { |
| case DMA: |
| if (!dnt->mon_buf_cpu_addr) { |
| IWL_ERR(trans, "DMA buffer wasn't allocated\n"); |
| return; |
| } |
| case NO_MONITOR: |
| case MIPI: |
| case INTERFACE: |
| case MARBH_ADC: |
| case MARBH_DBG: |
| iwl_dnt_conf_monitor(trans, dbg_cfg->dnt_out_mode, dbg_cfg->dbm_destination_path, |
| dbg_cfg->dbgm_enable_mode); |
| break; |
| default: |
| IWL_INFO(trans, "Invalid monitor type\n"); |
| return; |
| } |
| |
| dnt->dispatch.crash_out_mode |= dbg_cfg->dnt_out_mode; |
| } |
