From patchwork Mon Feb 23 08:08:15 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gilad Broner X-Patchwork-Id: 5863301 Return-Path: X-Original-To: patchwork-linux-arm-msm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id E94B09F169 for ; Mon, 23 Feb 2015 08:11:26 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 176052062B for ; Mon, 23 Feb 2015 08:11:24 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E4D8520620 for ; Mon, 23 Feb 2015 08:11:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752243AbbBWIKZ (ORCPT ); Mon, 23 Feb 2015 03:10:25 -0500 Received: from smtp.codeaurora.org ([198.145.29.96]:51623 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751987AbbBWIKU (ORCPT ); Mon, 23 Feb 2015 03:10:20 -0500 Received: from smtp.codeaurora.org (localhost [127.0.0.1]) by smtp.codeaurora.org (Postfix) with ESMTP id 66758140187; Mon, 23 Feb 2015 08:10:19 +0000 (UTC) Received: by smtp.codeaurora.org (Postfix, from userid 486) id 5176A1401A3; Mon, 23 Feb 2015 08:10:19 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Spam-Level: X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 Received: from lx-gbroner1.mea.qualcomm.com (unknown [185.23.60.4]) (using TLSv1.1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) (Authenticated sender: gbroner@smtp.codeaurora.org) by smtp.codeaurora.org (Postfix) with ESMTPSA id 72732140195; Mon, 23 Feb 2015 08:10:13 +0000 (UTC) From: Gilad Broner To: James.Bottomley@HansenPartnership.com Cc: linux-kernel@vger.kernel.org, linux-scsi@vger.kernel.org, linux-arm-msm@vger.kernel.org, santoshsy@gmail.com, linux-scsi-owner@vger.kernel.org, subhashj@codeaurora.org, ygardi@codeaurora.org, draviv@codeaurora.org, Lee Susman , Raviv Shvili , Gilad Broner , Vinayak Holikatti , "James E.J. Bottomley" Subject: [PATCH v3 2/4] scsi: ufs: add debugfs for ufs Date: Mon, 23 Feb 2015 10:08:15 +0200 Message-Id: <1424678898-3723-3-git-send-email-gbroner@codeaurora.org> X-Mailer: git-send-email 1.8.5.2 In-Reply-To: <1424678898-3723-1-git-send-email-gbroner@codeaurora.org> References: <1424678898-3723-1-git-send-email-gbroner@codeaurora.org> X-Virus-Scanned: ClamAV using ClamSMTP Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Lee Susman Adding debugfs capability for ufshcd. debugfs attributes introduced in this patch: - View driver/controller runtime data - Command tag statistics for performance analisis - Dump device descriptor info - Track recoverable errors statistics during runtime - Change UFS power mode during runtime entry a string in the format 'GGLLMM' where: G - selected gear L - number of lanes M - power mode (1=fast mode, 2=slow mode, 4=fast-auto mode, 5=slow-auto mode) First letter is for RX, second is for TX. - Get/set DME attributes Signed-off-by: Lee Susman Signed-off-by: Dolev Raviv Signed-off-by: Yaniv Gardi Signed-off-by: Raviv Shvili Signed-off-by: Gilad Broner Reviewed-by: Dov Levenglick --- drivers/scsi/ufs/Makefile | 1 + drivers/scsi/ufs/ufs-debugfs.c | 902 +++++++++++++++++++++++++++++++++++++++++ drivers/scsi/ufs/ufs-debugfs.h | 38 ++ drivers/scsi/ufs/ufshcd.c | 225 +++++++++- drivers/scsi/ufs/ufshcd.h | 65 +++ drivers/scsi/ufs/ufshci.h | 2 + 6 files changed, 1221 insertions(+), 12 deletions(-) create mode 100644 drivers/scsi/ufs/ufs-debugfs.c create mode 100644 drivers/scsi/ufs/ufs-debugfs.h diff --git a/drivers/scsi/ufs/Makefile b/drivers/scsi/ufs/Makefile index 8303bcc..0692314 100644 --- a/drivers/scsi/ufs/Makefile +++ b/drivers/scsi/ufs/Makefile @@ -3,3 +3,4 @@ obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o obj-$(CONFIG_SCSI_UFSHCD) += ufshcd.o obj-$(CONFIG_SCSI_UFSHCD_PCI) += ufshcd-pci.o obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o +obj-$(CONFIG_DEBUG_FS) += ufs-debugfs.o diff --git a/drivers/scsi/ufs/ufs-debugfs.c b/drivers/scsi/ufs/ufs-debugfs.c new file mode 100644 index 0000000..d1eb4f8 --- /dev/null +++ b/drivers/scsi/ufs/ufs-debugfs.c @@ -0,0 +1,902 @@ +/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * UFS debugfs - add debugfs interface to the ufshcd. + * This is currently used for statistics collection and exporting from the + * UFS driver. + * This infrastructure can be used for debugging or direct tweaking + * of the driver from userspace. + * + */ + +#include "ufs-debugfs.h" +#include "unipro.h" + +enum field_width { + BYTE = 1, + WORD = 2, +}; + +struct desc_field_offset { + char *name; + int offset; + enum field_width width_byte; +}; + +#define UFS_ERR_STATS_PRINT(file, error_index, string, error_seen) \ + do { \ + if (err_stats[error_index]) { \ + seq_printf(file, string, \ + err_stats[error_index]); \ + error_seen = true; \ + } \ + } while (0) +#define DOORBELL_CLR_TOUT_US (1000 * 1000) /* 1 sec */ + +#define BUFF_LINE_CAPACITY 16 +#define TAB_CHARS 8 + +static int ufsdbg_tag_stats_show(struct seq_file *file, void *data) +{ + struct ufs_hba *hba = (struct ufs_hba *)file->private; + struct ufs_stats *ufs_stats; + int i, j; + int max_depth; + bool is_tag_empty = true; + unsigned long flags; + char *sep = " | * | "; + + if (!hba) + goto exit; + + ufs_stats = &hba->ufs_stats; + + if (!ufs_stats->enabled) { + pr_debug("%s: ufs statistics are disabled\n", __func__); + seq_puts(file, "ufs statistics are disabled"); + goto exit; + } + + max_depth = hba->nutrs; + + spin_lock_irqsave(hba->host->host_lock, flags); + /* Header */ + seq_printf(file, " Tag Stat\t\t%s Queue Fullness\n", sep); + for (i = 0; i < TAB_CHARS * (TS_NUM_STATS + 4); i++) { + seq_puts(file, "-"); + if (i == (TAB_CHARS * 3 - 1)) + seq_puts(file, sep); + } + seq_printf(file, + "\n #\tnum uses\t%s\t #\tAll\t Read\t Write\t Flush\n", + sep); + + /* values */ + for (i = 0; i < max_depth; i++) { + if (ufs_stats->tag_stats[i][0] <= 0 && + ufs_stats->tag_stats[i][1] <= 0 && + ufs_stats->tag_stats[i][2] <= 0 && + ufs_stats->tag_stats[i][3] <= 0) + continue; + + is_tag_empty = false; + seq_printf(file, " %d\t ", i); + for (j = 0; j < TS_NUM_STATS; j++) { + seq_printf(file, "%llu\t ", ufs_stats->tag_stats[i][j]); + if (j == 0) + seq_printf(file, "\t%s\t %d\t%llu\t ", sep, i, + ufs_stats->tag_stats[i][j+1] + + ufs_stats->tag_stats[i][j+2]); + } + seq_puts(file, "\n"); + } + spin_unlock_irqrestore(hba->host->host_lock, flags); + + if (is_tag_empty) + pr_debug("%s: All tags statistics are empty", __func__); + +exit: + return 0; +} + +static int ufsdbg_tag_stats_open(struct inode *inode, struct file *file) +{ + return single_open(file, ufsdbg_tag_stats_show, inode->i_private); +} + +static ssize_t ufsdbg_tag_stats_write(struct file *filp, + const char __user *ubuf, size_t cnt, + loff_t *ppos) +{ + struct ufs_hba *hba = filp->f_mapping->host->i_private; + struct ufs_stats *ufs_stats; + int val = 0; + int ret, bit = 0; + unsigned long flags; + + ret = kstrtoint_from_user(ubuf, cnt, 0, &val); + if (ret) { + dev_err(hba->dev, "%s: Invalid argument\n", __func__); + return ret; + } + + ufs_stats = &hba->ufs_stats; + spin_lock_irqsave(hba->host->host_lock, flags); + + if (!val) { + ufs_stats->enabled = false; + pr_debug("%s: Disabling UFS tag statistics", __func__); + } else { + ufs_stats->enabled = true; + pr_debug("%s: Enabling & Resetting UFS tag statistics", + __func__); + memset(hba->ufs_stats.tag_stats[0], 0, + sizeof(**hba->ufs_stats.tag_stats) * + TS_NUM_STATS * hba->nutrs); + + /* initialize current queue depth */ + ufs_stats->q_depth = 0; + for_each_set_bit_from(bit, &hba->outstanding_reqs, hba->nutrs) + ufs_stats->q_depth++; + pr_debug("%s: Enabled UFS tag statistics", __func__); + } + + spin_unlock_irqrestore(hba->host->host_lock, flags); + return cnt; +} + +static const struct file_operations ufsdbg_tag_stats_fops = { + .open = ufsdbg_tag_stats_open, + .read = seq_read, + .write = ufsdbg_tag_stats_write, +}; + +static int ufsdbg_err_stats_show(struct seq_file *file, void *data) +{ + struct ufs_hba *hba = (struct ufs_hba *)file->private; + int *err_stats; + unsigned long flags; + bool error_seen = false; + + if (!hba) + goto exit; + + err_stats = hba->ufs_stats.err_stats; + + spin_lock_irqsave(hba->host->host_lock, flags); + + seq_puts(file, "\n==UFS errors that caused controller reset==\n"); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_HIBERN8_EXIT, + "controller reset due to hibern8 exit error:\t %d\n", + error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_VOPS_SUSPEND, + "controller reset due to vops suspend error:\t\t %d\n", + error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_EH, + "controller reset due to error handling:\t\t %d\n", + error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_CLEAR_PEND_XFER_TM, + "controller reset due to clear xfer/tm regs:\t\t %d\n", + error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_INT_FATAL_ERRORS, + "controller reset due to fatal interrupt:\t %d\n", + error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_INT_UIC_ERROR, + "controller reset due to uic interrupt error:\t %d\n", + error_seen); + + if (error_seen) + error_seen = false; + else + seq_puts(file, + "so far, no errors that caused controller reset\n\n"); + + seq_puts(file, "\n\n==UFS other errors==\n"); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_HIBERN8_ENTER, + "hibern8 enter:\t\t %d\n", error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_RESUME, + "resume error:\t\t %d\n", error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_SUSPEND, + "suspend error:\t\t %d\n", error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_LINKSTARTUP, + "linkstartup error:\t\t %d\n", error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_POWER_MODE_CHANGE, + "power change error:\t %d\n", error_seen); + + UFS_ERR_STATS_PRINT(file, UFS_ERR_TASK_ABORT, + "abort callback:\t\t %d\n\n", error_seen); + + if (!error_seen) + seq_puts(file, + "so far, no other UFS related errors\n\n"); + + spin_unlock_irqrestore(hba->host->host_lock, flags); +exit: + return 0; +} + +static int ufsdbg_err_stats_open(struct inode *inode, struct file *file) +{ + return single_open(file, ufsdbg_err_stats_show, inode->i_private); +} + +static ssize_t ufsdbg_err_stats_write(struct file *filp, + const char __user *ubuf, size_t cnt, + loff_t *ppos) +{ + struct ufs_hba *hba = filp->f_mapping->host->i_private; + struct ufs_stats *ufs_stats; + unsigned long flags; + + ufs_stats = &hba->ufs_stats; + spin_lock_irqsave(hba->host->host_lock, flags); + + pr_debug("%s: Resetting UFS error statistics", __func__); + memset(ufs_stats->err_stats, 0, sizeof(hba->ufs_stats.err_stats)); + + spin_unlock_irqrestore(hba->host->host_lock, flags); + return cnt; +} + +static const struct file_operations ufsdbg_err_stats_fops = { + .open = ufsdbg_err_stats_open, + .read = seq_read, + .write = ufsdbg_err_stats_write, +}; + +static int ufshcd_init_statistics(struct ufs_hba *hba) +{ + struct ufs_stats *stats = &hba->ufs_stats; + int ret = 0; + int i; + + stats->enabled = false; + stats->tag_stats = kcalloc(hba->nutrs, sizeof(*stats->tag_stats), + GFP_KERNEL); + if (!hba->ufs_stats.tag_stats) + goto no_mem; + + stats->tag_stats[0] = kzalloc(sizeof(**stats->tag_stats) * + TS_NUM_STATS * hba->nutrs, GFP_KERNEL); + if (!stats->tag_stats[0]) + goto no_mem; + + for (i = 1; i < hba->nutrs; i++) + stats->tag_stats[i] = &stats->tag_stats[0][i * TS_NUM_STATS]; + + memset(stats->err_stats, 0, sizeof(hba->ufs_stats.err_stats)); + + goto exit; + +no_mem: + dev_err(hba->dev, "%s: Unable to allocate UFS tag_stats", __func__); + ret = -ENOMEM; +exit: + return ret; +} + +static void +ufsdbg_pr_buf_to_std(struct seq_file *file, void *buff, int size, char *str) +{ + int i; + char linebuf[38]; + int lines = size/BUFF_LINE_CAPACITY + + (size % BUFF_LINE_CAPACITY ? 1 : 0); + + for (i = 0; i < lines; i++) { + hex_dump_to_buffer(buff + i * BUFF_LINE_CAPACITY, + BUFF_LINE_CAPACITY, BUFF_LINE_CAPACITY, 4, + linebuf, sizeof(linebuf), false); + seq_printf(file, "%s [%x]: %s\n", str, i * BUFF_LINE_CAPACITY, + linebuf); + } +} + +static int ufsdbg_host_regs_show(struct seq_file *file, void *data) +{ + struct ufs_hba *hba = (struct ufs_hba *)file->private; + + ufshcd_hold(hba, false); + pm_runtime_get_sync(hba->dev); + ufsdbg_pr_buf_to_std(file, hba->mmio_base, UFSHCI_REG_SPACE_SIZE, + "host regs"); + pm_runtime_put_sync(hba->dev); + ufshcd_release(hba); + return 0; +} + +static int ufsdbg_host_regs_open(struct inode *inode, struct file *file) +{ + return single_open(file, ufsdbg_host_regs_show, inode->i_private); +} + +static const struct file_operations ufsdbg_host_regs_fops = { + .open = ufsdbg_host_regs_open, + .read = seq_read, +}; + +static int ufsdbg_dump_device_desc_show(struct seq_file *file, void *data) +{ + int err = 0; + int buff_len = QUERY_DESC_DEVICE_MAX_SIZE; + u8 desc_buf[QUERY_DESC_DEVICE_MAX_SIZE]; + struct ufs_hba *hba = (struct ufs_hba *)file->private; + + struct desc_field_offset device_desc_field_name[] = { + {"bLength", 0x00, BYTE}, + {"bDescriptorType", 0x01, BYTE}, + {"bDevice", 0x02, BYTE}, + {"bDeviceClass", 0x03, BYTE}, + {"bDeviceSubClass", 0x04, BYTE}, + {"bProtocol", 0x05, BYTE}, + {"bNumberLU", 0x06, BYTE}, + {"bNumberWLU", 0x07, BYTE}, + {"bBootEnable", 0x08, BYTE}, + {"bDescrAccessEn", 0x09, BYTE}, + {"bInitPowerMode", 0x0A, BYTE}, + {"bHighPriorityLUN", 0x0B, BYTE}, + {"bSecureRemovalType", 0x0C, BYTE}, + {"bSecurityLU", 0x0D, BYTE}, + {"Reserved", 0x0E, BYTE}, + {"bInitActiveICCLevel", 0x0F, BYTE}, + {"wSpecVersion", 0x10, WORD}, + {"wManufactureDate", 0x12, WORD}, + {"iManufactureName", 0x14, BYTE}, + {"iProductName", 0x15, BYTE}, + {"iSerialNumber", 0x16, BYTE}, + {"iOemID", 0x17, BYTE}, + {"wManufactureID", 0x18, WORD}, + {"bUD0BaseOffset", 0x1A, BYTE}, + {"bUDConfigPLength", 0x1B, BYTE}, + {"bDeviceRTTCap", 0x1C, BYTE}, + {"wPeriodicRTCUpdate", 0x1D, WORD} + }; + + pm_runtime_get_sync(hba->dev); + err = ufshcd_read_device_desc(hba, desc_buf, buff_len); + pm_runtime_put_sync(hba->dev); + + if (!err) { + int i; + struct desc_field_offset *tmp; + + for (i = 0; i < ARRAY_SIZE(device_desc_field_name); ++i) { + tmp = &device_desc_field_name[i]; + + if (tmp->width_byte == BYTE) { + seq_printf(file, + "Device Descriptor[Byte offset 0x%x]: %s = 0x%x\n", + tmp->offset, + tmp->name, + (u8)desc_buf[tmp->offset]); + } else if (tmp->width_byte == WORD) { + seq_printf(file, + "Device Descriptor[Byte offset 0x%x]: %s = 0x%x\n", + tmp->offset, + tmp->name, + *(u16 *)&desc_buf[tmp->offset]); + } else { + seq_printf(file, + "Device Descriptor[offset 0x%x]: %s. Wrong Width = %d", + tmp->offset, tmp->name, tmp->width_byte); + } + } + } else { + seq_printf(file, "Reading Device Descriptor failed. err = %d\n", + err); + } + + return err; +} + +static int ufsdbg_show_hba_show(struct seq_file *file, void *data) +{ + struct ufs_hba *hba = (struct ufs_hba *)file->private; + + seq_printf(file, "hba->outstanding_tasks = 0x%x\n", + (u32)hba->outstanding_tasks); + seq_printf(file, "hba->outstanding_reqs = 0x%x\n", + (u32)hba->outstanding_reqs); + + seq_printf(file, "hba->capabilities = 0x%x\n", hba->capabilities); + seq_printf(file, "hba->nutrs = %d\n", hba->nutrs); + seq_printf(file, "hba->nutmrs = %d\n", hba->nutmrs); + seq_printf(file, "hba->ufs_version = 0x%x\n", hba->ufs_version); + seq_printf(file, "hba->irq = 0x%x\n", hba->irq); + seq_printf(file, "hba->auto_bkops_enabled = %d\n", + hba->auto_bkops_enabled); + + seq_printf(file, "hba->ufshcd_state = 0x%x\n", hba->ufshcd_state); + seq_printf(file, "hba->clk_gating.state = 0x%x\n", + hba->clk_gating.state); + seq_printf(file, "hba->eh_flags = 0x%x\n", hba->eh_flags); + seq_printf(file, "hba->intr_mask = 0x%x\n", hba->intr_mask); + seq_printf(file, "hba->ee_ctrl_mask = 0x%x\n", hba->ee_ctrl_mask); + + /* HBA Errors */ + seq_printf(file, "hba->errors = 0x%x\n", hba->errors); + seq_printf(file, "hba->uic_error = 0x%x\n", hba->uic_error); + seq_printf(file, "hba->saved_err = 0x%x\n", hba->saved_err); + seq_printf(file, "hba->saved_uic_err = 0x%x\n", hba->saved_uic_err); + + return 0; +} + +static int ufsdbg_show_hba_open(struct inode *inode, struct file *file) +{ + return single_open(file, ufsdbg_show_hba_show, inode->i_private); +} + +static const struct file_operations ufsdbg_show_hba_fops = { + .open = ufsdbg_show_hba_open, + .read = seq_read, +}; + +static int ufsdbg_dump_device_desc_open(struct inode *inode, struct file *file) +{ + return single_open(file, + ufsdbg_dump_device_desc_show, inode->i_private); +} + +static const struct file_operations ufsdbg_dump_device_desc = { + .open = ufsdbg_dump_device_desc_open, + .read = seq_read, +}; + +static int ufsdbg_power_mode_show(struct seq_file *file, void *data) +{ + struct ufs_hba *hba = (struct ufs_hba *)file->private; + static const char * const names[] = { + "INVALID MODE", + "FAST MODE", + "SLOW MODE", + "INVALID MODE", + "FASTAUTO MODE", + "SLOWAUTO MODE", + "INVALID MODE", + }; + + /* Print current status */ + seq_puts(file, "UFS current power mode [RX, TX]:"); + seq_printf(file, "gear=[%d,%d], lane=[%d,%d], pwr=[%s,%s], rate = %c", + hba->pwr_info.gear_rx, hba->pwr_info.gear_tx, + hba->pwr_info.lane_rx, hba->pwr_info.lane_tx, + names[hba->pwr_info.pwr_rx], + names[hba->pwr_info.pwr_tx], + hba->pwr_info.hs_rate == PA_HS_MODE_B ? 'B' : 'A'); + seq_puts(file, "\n\n"); + + /* Print usage */ + seq_puts(file, + "To change power mode write 'GGLLMM' where:\n" + "G - selected gear\n" + "L - number of lanes\n" + "M - power mode:\n" + "\t1 = fast mode\n" + "\t2 = slow mode\n" + "\t4 = fast-auto mode\n" + "\t5 = slow-auto mode\n" + "first letter is for RX, second letter is for TX.\n\n"); + + return 0; +} + +static bool ufsdbg_power_mode_validate(struct ufs_pa_layer_attr *pwr_mode) +{ + if (pwr_mode->gear_rx < UFS_PWM_G1 || pwr_mode->gear_rx > UFS_PWM_G7 || + pwr_mode->gear_tx < UFS_PWM_G1 || pwr_mode->gear_tx > UFS_PWM_G7 || + pwr_mode->lane_rx < 1 || pwr_mode->lane_rx > 2 || + pwr_mode->lane_tx < 1 || pwr_mode->lane_tx > 2 || + (pwr_mode->pwr_rx != FAST_MODE && pwr_mode->pwr_rx != SLOW_MODE && + pwr_mode->pwr_rx != FASTAUTO_MODE && + pwr_mode->pwr_rx != SLOWAUTO_MODE) || + (pwr_mode->pwr_tx != FAST_MODE && pwr_mode->pwr_tx != SLOW_MODE && + pwr_mode->pwr_tx != FASTAUTO_MODE && + pwr_mode->pwr_tx != SLOWAUTO_MODE)) { + pr_err("%s: power parameters are not valid\n", __func__); + return false; + } + + return true; +} + +static int ufsdbg_cfg_pwr_param(struct ufs_hba *hba, + struct ufs_pa_layer_attr *new_pwr, + struct ufs_pa_layer_attr *final_pwr) +{ + int ret = 0; + bool is_dev_sup_hs = false; + bool is_new_pwr_hs = false; + int dev_pwm_max_rx_gear; + int dev_pwm_max_tx_gear; + + if (!hba->max_pwr_info.is_valid) { + dev_err(hba->dev, "%s: device max power is not valid. can't configure power\n", + __func__); + return -EINVAL; + } + + if (hba->max_pwr_info.info.pwr_rx == FAST_MODE) + is_dev_sup_hs = true; + + if (new_pwr->pwr_rx == FAST_MODE || new_pwr->pwr_rx == FASTAUTO_MODE) + is_new_pwr_hs = true; + + final_pwr->lane_rx = hba->max_pwr_info.info.lane_rx; + final_pwr->lane_tx = hba->max_pwr_info.info.lane_tx; + + /* device doesn't support HS but requested power is HS */ + if (!is_dev_sup_hs && is_new_pwr_hs) { + pr_err("%s: device doesn't support HS. requested power is HS\n", + __func__); + return -ENOTSUPP; + } else if ((is_dev_sup_hs && is_new_pwr_hs) || + (!is_dev_sup_hs && !is_new_pwr_hs)) { + /* + * If device and requested power mode are both HS or both PWM + * then dev_max->gear_xx are the gears to be assign to + * final_pwr->gear_xx + */ + final_pwr->gear_rx = hba->max_pwr_info.info.gear_rx; + final_pwr->gear_tx = hba->max_pwr_info.info.gear_tx; + } else if (is_dev_sup_hs && !is_new_pwr_hs) { + /* + * If device supports HS but requested power is PWM, then we + * need to find out what is the max gear in PWM the device + * supports + */ + + ufshcd_dme_get(hba, UIC_ARG_MIB(PA_MAXRXPWMGEAR), + &dev_pwm_max_rx_gear); + + if (!dev_pwm_max_rx_gear) { + pr_err("%s: couldn't get device max pwm rx gear\n", + __func__); + ret = -EINVAL; + goto out; + } + + ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_MAXRXPWMGEAR), + &dev_pwm_max_tx_gear); + + if (!dev_pwm_max_tx_gear) { + pr_err("%s: couldn't get device max pwm tx gear\n", + __func__); + ret = -EINVAL; + goto out; + } + + final_pwr->gear_rx = dev_pwm_max_rx_gear; + final_pwr->gear_tx = dev_pwm_max_tx_gear; + } + + if ((new_pwr->gear_rx > final_pwr->gear_rx) || + (new_pwr->gear_tx > final_pwr->gear_tx) || + (new_pwr->lane_rx > final_pwr->lane_rx) || + (new_pwr->lane_tx > final_pwr->lane_tx)) { + pr_err("%s: (RX,TX) GG,LL: in PWM/HS new pwr [%d%d,%d%d] exceeds device limitation [%d%d,%d%d]\n", + __func__, + new_pwr->gear_rx, new_pwr->gear_tx, + new_pwr->lane_rx, new_pwr->lane_tx, + final_pwr->gear_rx, final_pwr->gear_tx, + final_pwr->lane_rx, final_pwr->lane_tx); + return -ENOTSUPP; + } + + final_pwr->gear_rx = new_pwr->gear_rx; + final_pwr->gear_tx = new_pwr->gear_tx; + final_pwr->lane_rx = new_pwr->lane_rx; + final_pwr->lane_tx = new_pwr->lane_tx; + final_pwr->pwr_rx = new_pwr->pwr_rx; + final_pwr->pwr_tx = new_pwr->pwr_tx; + final_pwr->hs_rate = new_pwr->hs_rate; + +out: + return ret; +} + +static int ufsdbg_config_pwr_mode(struct ufs_hba *hba, + struct ufs_pa_layer_attr *desired_pwr_mode) +{ + int ret; + + pm_runtime_get_sync(hba->dev); + scsi_block_requests(hba->host); + ret = ufshcd_wait_for_doorbell_clr(hba, DOORBELL_CLR_TOUT_US); + if (!ret) + ret = ufshcd_change_power_mode(hba, desired_pwr_mode); + scsi_unblock_requests(hba->host); + pm_runtime_put_sync(hba->dev); + + return ret; +} + +static ssize_t ufsdbg_power_mode_write(struct file *file, + const char __user *ubuf, size_t cnt, + loff_t *ppos) +{ + struct ufs_hba *hba = file->f_mapping->host->i_private; + struct ufs_pa_layer_attr pwr_mode; + struct ufs_pa_layer_attr final_pwr_mode; + char pwr_mode_str[BUFF_LINE_CAPACITY] = {0}; + loff_t buff_pos = 0; + int ret; + int idx = 0; + + ret = simple_write_to_buffer(pwr_mode_str, BUFF_LINE_CAPACITY, + &buff_pos, ubuf, cnt); + + pwr_mode.gear_rx = pwr_mode_str[idx++] - '0'; + pwr_mode.gear_tx = pwr_mode_str[idx++] - '0'; + pwr_mode.lane_rx = pwr_mode_str[idx++] - '0'; + pwr_mode.lane_tx = pwr_mode_str[idx++] - '0'; + pwr_mode.pwr_rx = pwr_mode_str[idx++] - '0'; + pwr_mode.pwr_tx = pwr_mode_str[idx++] - '0'; + + /* + * Switching between rates is not currently supported so use the + * current rate. + * TODO: add rate switching if and when it is supported in the future + */ + pwr_mode.hs_rate = hba->pwr_info.hs_rate; + + /* Validate user input */ + if (!ufsdbg_power_mode_validate(&pwr_mode)) + return -EINVAL; + + pr_debug("%s: new power mode requested [RX,TX]: Gear=[%d,%d], Lane=[%d,%d], Mode=[%d,%d]\n", + __func__, + pwr_mode.gear_rx, pwr_mode.gear_tx, pwr_mode.lane_rx, + pwr_mode.lane_tx, pwr_mode.pwr_rx, pwr_mode.pwr_tx); + + ret = ufsdbg_cfg_pwr_param(hba, &pwr_mode, &final_pwr_mode); + if (ret) { + dev_err(hba->dev, + "%s: failed to configure new power parameters, ret = %d\n", + __func__, ret); + return cnt; + } + + ret = ufsdbg_config_pwr_mode(hba, &final_pwr_mode); + if (ret == -EBUSY) + dev_err(hba->dev, + "%s: ufshcd_config_pwr_mode failed: system is busy, try again\n", + __func__); + else if (ret) + dev_err(hba->dev, + "%s: ufshcd_config_pwr_mode failed, ret=%d\n", + __func__, ret); + + return cnt; +} + +static int ufsdbg_power_mode_open(struct inode *inode, struct file *file) +{ + return single_open(file, ufsdbg_power_mode_show, inode->i_private); +} + +static const struct file_operations ufsdbg_power_mode_desc = { + .open = ufsdbg_power_mode_open, + .read = seq_read, + .write = ufsdbg_power_mode_write, +}; + +static int ufsdbg_dme_read(void *data, u64 *attr_val, bool peer) +{ + int ret; + struct ufs_hba *hba = data; + u32 attr_id, read_val = 0; + int (*read_func)(struct ufs_hba *, u32, u32 *); + + if (!hba) + return -EINVAL; + + read_func = peer ? ufshcd_dme_peer_get : ufshcd_dme_get; + attr_id = peer ? hba->debugfs_files.dme_peer_attr_id : + hba->debugfs_files.dme_local_attr_id; + pm_runtime_get_sync(hba->dev); + scsi_block_requests(hba->host); + ret = ufshcd_wait_for_doorbell_clr(hba, DOORBELL_CLR_TOUT_US); + if (!ret) + ret = read_func(hba, UIC_ARG_MIB(attr_id), &read_val); + scsi_unblock_requests(hba->host); + pm_runtime_put_sync(hba->dev); + + if (!ret) + *attr_val = (u64)read_val; + + return ret; +} + +static int ufsdbg_dme_local_set_attr_id(void *data, u64 attr_id) +{ + struct ufs_hba *hba = data; + + if (!hba) + return -EINVAL; + + hba->debugfs_files.dme_local_attr_id = (u32)attr_id; + + return 0; +} + +static int ufsdbg_dme_local_read(void *data, u64 *attr_val) +{ + return ufsdbg_dme_read(data, attr_val, false); +} + +DEFINE_SIMPLE_ATTRIBUTE(ufsdbg_dme_local_read_ops, + ufsdbg_dme_local_read, + ufsdbg_dme_local_set_attr_id, + "%llu\n"); + +static int ufsdbg_dme_peer_read(void *data, u64 *attr_val) +{ + struct ufs_hba *hba = data; + + if (!hba) + return -EINVAL; + else + return ufsdbg_dme_read(data, attr_val, true); +} + +static int ufsdbg_dme_peer_set_attr_id(void *data, u64 attr_id) +{ + struct ufs_hba *hba = data; + + if (!hba) + return -EINVAL; + + hba->debugfs_files.dme_peer_attr_id = (u32)attr_id; + + return 0; +} + +DEFINE_SIMPLE_ATTRIBUTE(ufsdbg_dme_peer_read_ops, + ufsdbg_dme_peer_read, + ufsdbg_dme_peer_set_attr_id, + "%llu\n"); + +void ufsdbg_add_debugfs(struct ufs_hba *hba) +{ + char root_name[32]; + + if (!hba) { + pr_err("%s: NULL hba, exiting\n", __func__); + return; + } + + snprintf(root_name, 32, "%s%d", UFSHCD, hba->host->host_no); + + hba->debugfs_files.debugfs_root = debugfs_create_dir(root_name, NULL); + if (IS_ERR(hba->debugfs_files.debugfs_root)) + /* Don't complain -- debugfs just isn't enabled */ + goto err_no_root; + if (!hba->debugfs_files.debugfs_root) { + /* + * Complain -- debugfs is enabled, but it failed to + * create the directory + */ + dev_err(hba->dev, + "%s: NULL debugfs root directory, exiting", __func__); + goto err_no_root; + } + + hba->debugfs_files.tag_stats = + debugfs_create_file("tag_stats", S_IRUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_tag_stats_fops); + if (!hba->debugfs_files.tag_stats) { + dev_err(hba->dev, "%s: NULL tag stats file, exiting", + __func__); + goto err; + } + + hba->debugfs_files.err_stats = + debugfs_create_file("err_stats", S_IRUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_err_stats_fops); + if (!hba->debugfs_files.err_stats) { + dev_err(hba->dev, "%s: NULL err stats file, exiting", + __func__); + goto err; + } + + if (ufshcd_init_statistics(hba)) { + dev_err(hba->dev, "%s: Error initializing statistics", + __func__); + goto err; + } + + hba->debugfs_files.host_regs = debugfs_create_file("host_regs", S_IRUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_host_regs_fops); + if (!hba->debugfs_files.host_regs) { + dev_err(hba->dev, "%s: NULL hcd regs file, exiting", __func__); + goto err; + } + + hba->debugfs_files.show_hba = debugfs_create_file("show_hba", S_IRUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_show_hba_fops); + if (!hba->debugfs_files.show_hba) { + dev_err(hba->dev, "%s: NULL hba file, exiting", __func__); + goto err; + } + + hba->debugfs_files.dump_dev_desc = + debugfs_create_file("dump_device_desc", S_IRUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_dump_device_desc); + if (!hba->debugfs_files.dump_dev_desc) { + dev_err(hba->dev, + "%s: NULL dump_device_desc file, exiting", __func__); + goto err; + } + + hba->debugfs_files.power_mode = + debugfs_create_file("power_mode", S_IRUSR | S_IWUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_power_mode_desc); + if (!hba->debugfs_files.power_mode) { + dev_err(hba->dev, + "%s: NULL power_mode_desc file, exiting", __func__); + goto err; + } + + hba->debugfs_files.dme_local_read = + debugfs_create_file("dme_local_read", S_IRUSR | S_IWUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_dme_local_read_ops); + if (!hba->debugfs_files.dme_local_read) { + dev_err(hba->dev, + "%s: failed create dme_local_read debugfs entry\n", + __func__); + goto err; + } + + hba->debugfs_files.dme_peer_read = + debugfs_create_file("dme_peer_read", S_IRUSR | S_IWUSR, + hba->debugfs_files.debugfs_root, hba, + &ufsdbg_dme_peer_read_ops); + if (!hba->debugfs_files.dme_peer_read) { + dev_err(hba->dev, + "%s: failed create dme_peer_read debugfs entry\n", + __func__); + goto err; + } + + return; + +err: + debugfs_remove_recursive(hba->debugfs_files.debugfs_root); + hba->debugfs_files.debugfs_root = NULL; +err_no_root: + dev_err(hba->dev, "%s: failed to initialize debugfs\n", __func__); +} + +void ufsdbg_remove_debugfs(struct ufs_hba *hba) +{ + debugfs_remove_recursive(hba->debugfs_files.debugfs_root); + kfree(hba->ufs_stats.tag_stats); + +} diff --git a/drivers/scsi/ufs/ufs-debugfs.h b/drivers/scsi/ufs/ufs-debugfs.h new file mode 100644 index 0000000..7ed308d --- /dev/null +++ b/drivers/scsi/ufs/ufs-debugfs.h @@ -0,0 +1,38 @@ +/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * UFS debugfs - add debugfs interface to the ufshcd. + * This is currently used for statistics collection and exporting from the + * UFS driver. + * This infrastructure can be used for debugging or direct tweaking + * of the driver from userspace. + * + */ + +#ifndef _UFS_DEBUGFS_H +#define _UFS_DEBUGFS_H + +#include +#include "ufshcd.h" + +#ifdef CONFIG_DEBUG_FS +void ufsdbg_add_debugfs(struct ufs_hba *hba); +void ufsdbg_remove_debugfs(struct ufs_hba *hba); +#else +static inline void ufsdbg_add_debugfs(struct ufs_hba *hba) +{ +} +static inline void ufsdbg_remove_debugfs(struct ufs_hba *hba) +{ +} +#endif + +#endif /* End of Header */ diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c index cb357f8..84caf6d 100644 --- a/drivers/scsi/ufs/ufshcd.c +++ b/drivers/scsi/ufs/ufshcd.c @@ -43,6 +43,55 @@ #include "ufshcd.h" #include "unipro.h" +#include "ufs-debugfs.h" + +#ifdef CONFIG_DEBUG_FS + +#define UFSHCD_UPDATE_ERROR_STATS(hba, type) \ + do { \ + if (type < UFS_ERR_MAX) \ + hba->ufs_stats.err_stats[type]++; \ + } while (0) + +#define UFSHCD_UPDATE_TAG_STATS(hba, tag) \ + do { \ + struct request *rq = hba->lrb[task_tag].cmd ? \ + hba->lrb[task_tag].cmd->request : NULL; \ + u64 **tag_stats = hba->ufs_stats.tag_stats; \ + int rq_type = -1; \ + if (!hba->ufs_stats.enabled) \ + break; \ + tag_stats[tag][TS_TAG]++; \ + if (!rq) \ + break; \ + WARN_ON(hba->ufs_stats.q_depth > hba->nutrs); \ + if (rq_data_dir(rq) == READ) \ + rq_type = TS_READ; \ + else if (rq_data_dir(rq) == WRITE) \ + rq_type = TS_WRITE; \ + else if (rq->cmd_flags & REQ_FLUSH) \ + rq_type = TS_FLUSH; \ + else \ + break; \ + tag_stats[hba->ufs_stats.q_depth++][rq_type]++; \ + } while (0) + +#define UFSHCD_UPDATE_TAG_STATS_COMPLETION(hba, cmd) \ + do { \ + struct request *rq = cmd ? cmd->request : NULL; \ + if (cmd->request && \ + ((rq_data_dir(rq) == READ) || \ + (rq_data_dir(rq) == WRITE) || \ + (rq->cmd_flags & REQ_FLUSH))) \ + hba->ufs_stats.q_depth--; \ + } while (0) + +#else +#define UFSHCD_UPDATE_TAG_STATS(hba, tag) +#define UFSHCD_UPDATE_TAG_STATS_COMPLETION(hba, cmd) +#define UFSHCD_UPDATE_ERROR_STATS(hba, type) + +#endif #define UFSHCD_ENABLE_INTRS (UTP_TRANSFER_REQ_COMPL |\ UTP_TASK_REQ_COMPL |\ @@ -50,6 +99,9 @@ /* UIC command timeout, unit: ms */ #define UIC_CMD_TIMEOUT 500 +/* Retries waiting for doorbells to clear */ +#define POWER_MODE_RETRIES 10 + /* NOP OUT retries waiting for NOP IN response */ #define NOP_OUT_RETRIES 10 /* Timeout after 30 msecs if NOP OUT hangs without response */ @@ -189,8 +241,6 @@ static int ufshcd_uic_hibern8_exit(struct ufs_hba *hba); static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba); static int ufshcd_host_reset_and_restore(struct ufs_hba *hba); static irqreturn_t ufshcd_intr(int irq, void *__hba); -static int ufshcd_config_pwr_mode(struct ufs_hba *hba, - struct ufs_pa_layer_attr *desired_pwr_mode); static inline int ufshcd_enable_irq(struct ufs_hba *hba) { @@ -789,6 +839,7 @@ void ufshcd_send_command(struct ufs_hba *hba, unsigned int task_tag) ufshcd_clk_scaling_start_busy(hba); __set_bit(task_tag, &hba->outstanding_reqs); ufshcd_writel(hba, 1 << task_tag, REG_UTP_TRANSFER_REQ_DOOR_BELL); + UFSHCD_UPDATE_TAG_STATS(hba, task_tag); } /** @@ -975,6 +1026,7 @@ ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd) unsigned long flags; ufshcd_hold(hba, false); + pm_runtime_get_sync(hba->dev); mutex_lock(&hba->uic_cmd_mutex); spin_lock_irqsave(hba->host->host_lock, flags); ret = __ufshcd_send_uic_cmd(hba, uic_cmd); @@ -983,7 +1035,7 @@ ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd) ret = ufshcd_wait_for_uic_cmd(hba, uic_cmd); mutex_unlock(&hba->uic_cmd_mutex); - + pm_runtime_put_sync(hba->dev); ufshcd_release(hba); return ret; } @@ -1866,6 +1918,27 @@ static inline int ufshcd_read_power_desc(struct ufs_hba *hba, return ufshcd_read_desc(hba, QUERY_DESC_IDN_POWER, 0, buf, size); } +int ufshcd_read_device_desc(struct ufs_hba *hba, u8 *buf, u32 size) +{ + int err = 0; + int retries; + + for (retries = QUERY_REQ_RETRIES; retries > 0; retries--) { + /* Read descriptor*/ + err = ufshcd_read_desc(hba, + QUERY_DESC_IDN_DEVICE, 0, buf, size); + if (!err) + break; + dev_dbg(hba->dev, "%s: error %d retrying\n", __func__, err); + } + + if (err) + dev_err(hba->dev, "%s: reading Device Desc failed. err = %d\n", + __func__, err); + + return err; +} + /** * ufshcd_read_unit_desc_param - read the specified unit descriptor parameter * @hba: Pointer to adapter instance @@ -2158,11 +2231,42 @@ static int ufshcd_uic_pwr_ctrl(struct ufs_hba *hba, struct uic_command *cmd) unsigned long flags; u8 status; int ret; + u32 tm_doorbell; + u32 tr_doorbell; + bool uic_ready; + int retries = POWER_MODE_RETRIES; + ufshcd_hold(hba, false); + pm_runtime_get_sync(hba->dev); mutex_lock(&hba->uic_cmd_mutex); init_completion(&uic_async_done); - spin_lock_irqsave(hba->host->host_lock, flags); + /* + * Before changing the power mode there should be no outstanding + * tasks/transfer requests. Verify by checking the doorbell registers + * are clear. + */ + do { + spin_lock_irqsave(hba->host->host_lock, flags); + uic_ready = ufshcd_ready_for_uic_cmd(hba); + tm_doorbell = ufshcd_readl(hba, REG_UTP_TASK_REQ_DOOR_BELL); + tr_doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL); + if (!tm_doorbell && !tr_doorbell && uic_ready) + break; + + spin_unlock_irqrestore(hba->host->host_lock, flags); + schedule(); + retries--; + } while (retries && (tm_doorbell || tr_doorbell || !uic_ready)); + + if (!retries) { + dev_err(hba->dev, + "%s: too many retries waiting for doorbell to clear (tm=0x%x, tr=0x%x, uicrdy=%d)\n", + __func__, tm_doorbell, tr_doorbell, uic_ready); + ret = -EBUSY; + goto out; + } + hba->uic_async_done = &uic_async_done; ret = __ufshcd_send_uic_cmd(hba, cmd); spin_unlock_irqrestore(hba->host->host_lock, flags); @@ -2201,7 +2305,56 @@ out: hba->uic_async_done = NULL; spin_unlock_irqrestore(hba->host->host_lock, flags); mutex_unlock(&hba->uic_cmd_mutex); + pm_runtime_put_sync(hba->dev); + ufshcd_release(hba); + return ret; +} + +int ufshcd_wait_for_doorbell_clr(struct ufs_hba *hba, u64 wait_timeout_us) +{ + unsigned long flags; + int ret = 0; + u32 tm_doorbell; + u32 tr_doorbell; + bool timeout = false; + ktime_t start = ktime_get(); + + ufshcd_hold(hba, false); + spin_lock_irqsave(hba->host->host_lock, flags); + if (hba->ufshcd_state != UFSHCD_STATE_OPERATIONAL) { + ret = -EBUSY; + goto out; + } + /* + * Wait for all the outstanding tasks/transfer requests. + * Verify by checking the doorbell registers are clear. + */ + do { + tm_doorbell = ufshcd_readl(hba, REG_UTP_TASK_REQ_DOOR_BELL); + tr_doorbell = ufshcd_readl(hba, REG_UTP_TRANSFER_REQ_DOOR_BELL); + if (!tm_doorbell && !tr_doorbell) { + timeout = false; + break; + } + + spin_unlock_irqrestore(hba->host->host_lock, flags); + schedule(); + if (ktime_to_us(ktime_sub(ktime_get(), start)) > + wait_timeout_us) + timeout = true; + spin_lock_irqsave(hba->host->host_lock, flags); + } while (tm_doorbell || tr_doorbell); + + if (timeout) { + dev_err(hba->dev, + "%s: timedout waiting for doorbell to clear (tm=0x%x, tr=0x%x)\n", + __func__, tm_doorbell, tr_doorbell); + ret = -EBUSY; + } +out: + spin_unlock_irqrestore(hba->host->host_lock, flags); + ufshcd_release(hba); return ret; } @@ -2230,11 +2383,20 @@ static int ufshcd_uic_change_pwr_mode(struct ufs_hba *hba, u8 mode) static int ufshcd_uic_hibern8_enter(struct ufs_hba *hba) { + int ret; struct uic_command uic_cmd = {0}; uic_cmd.command = UIC_CMD_DME_HIBER_ENTER; - return ufshcd_uic_pwr_ctrl(hba, &uic_cmd); + ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd); + + if (ret) { + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_HIBERN8_ENTER); + dev_err(hba->dev, "%s: hibern8 enter failed. ret = %d", + __func__, ret); + } + + return ret; } static int ufshcd_uic_hibern8_exit(struct ufs_hba *hba) @@ -2246,6 +2408,9 @@ static int ufshcd_uic_hibern8_exit(struct ufs_hba *hba) ret = ufshcd_uic_pwr_ctrl(hba, &uic_cmd); if (ret) { ufshcd_set_link_off(hba); + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_HIBERN8_EXIT); + dev_err(hba->dev, "%s: hibern8 exit failed. ret = %d", + __func__, ret); ret = ufshcd_host_reset_and_restore(hba); } @@ -2279,8 +2444,8 @@ static int ufshcd_get_max_pwr_mode(struct ufs_hba *hba) if (hba->max_pwr_info.is_valid) return 0; - pwr_info->pwr_tx = FASTAUTO_MODE; - pwr_info->pwr_rx = FASTAUTO_MODE; + pwr_info->pwr_tx = FAST_MODE; + pwr_info->pwr_rx = FAST_MODE; pwr_info->hs_rate = PA_HS_MODE_B; /* Get the connected lane count */ @@ -2311,7 +2476,7 @@ static int ufshcd_get_max_pwr_mode(struct ufs_hba *hba) __func__, pwr_info->gear_rx); return -EINVAL; } - pwr_info->pwr_rx = SLOWAUTO_MODE; + pwr_info->pwr_rx = SLOW_MODE; } ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_MAXRXHSGEAR), @@ -2324,14 +2489,14 @@ static int ufshcd_get_max_pwr_mode(struct ufs_hba *hba) __func__, pwr_info->gear_tx); return -EINVAL; } - pwr_info->pwr_tx = SLOWAUTO_MODE; + pwr_info->pwr_tx = SLOW_MODE; } hba->max_pwr_info.is_valid = true; return 0; } -static int ufshcd_change_power_mode(struct ufs_hba *hba, +int ufshcd_change_power_mode(struct ufs_hba *hba, struct ufs_pa_layer_attr *pwr_mode) { int ret; @@ -2383,6 +2548,7 @@ static int ufshcd_change_power_mode(struct ufs_hba *hba, | pwr_mode->pwr_tx); if (ret) { + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_POWER_MODE_CHANGE); dev_err(hba->dev, "%s: power mode change failed %d\n", __func__, ret); } else { @@ -2613,9 +2779,12 @@ static int ufshcd_link_startup(struct ufs_hba *hba) hba->vops->link_startup_notify(hba, PRE_CHANGE); ret = ufshcd_dme_link_startup(hba); + if (ret) + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_LINKSTARTUP); /* check if device is detected by inter-connect layer */ if (!ret && !ufshcd_is_device_present(hba)) { + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_LINKSTARTUP); dev_err(hba->dev, "%s: Device not present\n", __func__); ret = -ENXIO; goto out; @@ -3051,6 +3220,7 @@ static void ufshcd_transfer_req_compl(struct ufs_hba *hba) lrbp = &hba->lrb[index]; cmd = lrbp->cmd; if (cmd) { + UFSHCD_UPDATE_TAG_STATS_COMPLETION(hba, cmd); result = ufshcd_transfer_rsp_status(hba, lrbp); scsi_dma_unmap(cmd); cmd->result = result; @@ -3382,6 +3552,19 @@ static void ufshcd_err_handler(struct work_struct *work) if (err_xfer || err_tm || (hba->saved_err & INT_FATAL_ERRORS) || ((hba->saved_err & UIC_ERROR) && (hba->saved_uic_err & UFSHCD_UIC_DL_PA_INIT_ERROR))) { + + if (hba->saved_err & INT_FATAL_ERRORS) + UFSHCD_UPDATE_ERROR_STATS(hba, + UFS_ERR_INT_FATAL_ERRORS); + + if (hba->saved_err & UIC_ERROR) + UFSHCD_UPDATE_ERROR_STATS(hba, + UFS_ERR_INT_UIC_ERROR); + + if (err_xfer || err_tm) + UFSHCD_UPDATE_ERROR_STATS(hba, + UFS_ERR_CLEAR_PEND_XFER_TM); + err = ufshcd_reset_and_restore(hba); if (err) { dev_err(hba->dev, "%s: reset and restore failed\n", @@ -3719,6 +3902,9 @@ static int ufshcd_abort(struct scsi_cmnd *cmd) hba = shost_priv(host); tag = cmd->request->tag; + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_TASK_ABORT); + + ufshcd_hold(hba, false); /* If command is already aborted/completed, return SUCCESS */ if (!(test_bit(tag, &hba->outstanding_reqs))) @@ -3903,6 +4089,7 @@ static int ufshcd_eh_host_reset_handler(struct scsi_cmnd *cmd) ufshcd_set_eh_in_progress(hba); spin_unlock_irqrestore(hba->host->host_lock, flags); + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_EH); err = ufshcd_reset_and_restore(hba); spin_lock_irqsave(hba->host->host_lock, flags); @@ -5188,10 +5375,12 @@ vops_resume: hba->vops->resume(hba, pm_op); set_link_active: ufshcd_vreg_set_hpm(hba); - if (ufshcd_is_link_hibern8(hba) && !ufshcd_uic_hibern8_exit(hba)) + if (ufshcd_is_link_hibern8(hba) && !ufshcd_uic_hibern8_exit(hba)) { ufshcd_set_link_active(hba); - else if (ufshcd_is_link_off(hba)) + } else if (ufshcd_is_link_off(hba)) { + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_VOPS_SUSPEND); ufshcd_host_reset_and_restore(hba); + } set_dev_active: if (!ufshcd_set_dev_pwr_mode(hba, UFS_ACTIVE_PWR_MODE)) ufshcd_disable_auto_bkops(hba); @@ -5200,6 +5389,10 @@ enable_gating: ufshcd_release(hba); out: hba->pm_op_in_progress = 0; + + if (ret) + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_SUSPEND); + return ret; } @@ -5295,6 +5488,10 @@ disable_irq_and_vops_clks: ufshcd_setup_clocks(hba, false); out: hba->pm_op_in_progress = 0; + + if (ret) + UFSHCD_UPDATE_ERROR_STATS(hba, UFS_ERR_RESUME); + return ret; } @@ -5466,6 +5663,7 @@ void ufshcd_remove(struct ufs_hba *hba) if (ufshcd_is_clkscaling_enabled(hba)) devfreq_remove_device(hba->devfreq); ufshcd_hba_exit(hba); + ufsdbg_remove_debugfs(hba); } EXPORT_SYMBOL_GPL(ufshcd_remove); @@ -5760,6 +5958,8 @@ int ufshcd_init(struct ufs_hba *hba, void __iomem *mmio_base, unsigned int irq) async_schedule(ufshcd_async_scan, hba); + ufsdbg_add_debugfs(hba); + return 0; out_remove_scsi_host: @@ -5769,6 +5969,7 @@ exit_gating: out_disable: hba->is_irq_enabled = false; scsi_host_put(host); + ufsdbg_remove_debugfs(hba); ufshcd_hba_exit(hba); out_error: return err; diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h index 4a574aa..d9b1251 100644 --- a/drivers/scsi/ufs/ufshcd.h +++ b/drivers/scsi/ufs/ufshcd.h @@ -3,6 +3,7 @@ * * This code is based on drivers/scsi/ufs/ufshcd.h * Copyright (C) 2011-2013 Samsung India Software Operations + * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. * * Authors: * Santosh Yaraganavi @@ -125,6 +126,25 @@ enum uic_link_state { #define ufshcd_set_link_hibern8(hba) ((hba)->uic_link_state = \ UIC_LINK_HIBERN8_STATE) +enum { + /* errors which require the host controller reset for recovery */ + UFS_ERR_HIBERN8_EXIT, + UFS_ERR_VOPS_SUSPEND, + UFS_ERR_EH, + UFS_ERR_CLEAR_PEND_XFER_TM, + UFS_ERR_INT_FATAL_ERRORS, + UFS_ERR_INT_UIC_ERROR, + + /* other errors */ + UFS_ERR_HIBERN8_ENTER, + UFS_ERR_RESUME, + UFS_ERR_SUSPEND, + UFS_ERR_LINKSTARTUP, + UFS_ERR_POWER_MODE_CHANGE, + UFS_ERR_TASK_ABORT, + UFS_ERR_MAX, +}; + /* * UFS Power management levels. * Each level is in increasing order of power savings. @@ -203,6 +223,39 @@ struct ufs_dev_cmd { struct ufs_query query; }; +#ifdef CONFIG_DEBUG_FS +struct ufs_stats { + bool enabled; + u64 **tag_stats; + int q_depth; + int err_stats[UFS_ERR_MAX]; +}; + +struct debugfs_files { + struct dentry *debugfs_root; + struct dentry *tag_stats; + struct dentry *err_stats; + struct dentry *show_hba; + struct dentry *host_regs; + struct dentry *dump_dev_desc; + struct dentry *power_mode; + struct dentry *dme_local_read; + struct dentry *dme_peer_read; + u32 dme_local_attr_id; + u32 dme_peer_attr_id; +}; + +/* tag stats statistics types */ +enum ts_types { + TS_NOT_SUPPORTED = -1, + TS_TAG = 0, + TS_READ = 1, + TS_WRITE = 2, + TS_FLUSH = 3, + TS_NUM_STATS = 4, +}; +#endif + /** * struct ufs_clk_info - UFS clock related info * @list: list headed by hba->clk_list_head @@ -371,6 +424,8 @@ struct ufs_init_prefetch { * @clk_list_head: UFS host controller clocks list node head * @pwr_info: holds current power mode * @max_pwr_info: keeps the device max valid pwm + * @ufs_stats: ufshcd statistics to be used via debugfs + * @debugfs_files: debugfs files associated with the ufs stats */ struct ufs_hba { void __iomem *mmio_base; @@ -473,6 +528,10 @@ struct ufs_hba { struct devfreq *devfreq; struct ufs_clk_scaling clk_scaling; bool is_sys_suspended; +#ifdef CONFIG_DEBUG_FS + struct ufs_stats ufs_stats; + struct debugfs_files debugfs_files; +#endif }; /* Returns true if clocks can be gated. Otherwise false */ @@ -593,4 +652,10 @@ static inline int ufshcd_dme_peer_get(struct ufs_hba *hba, int ufshcd_hold(struct ufs_hba *hba, bool async); void ufshcd_release(struct ufs_hba *hba); +int ufshcd_read_device_desc(struct ufs_hba *hba, u8 *buf, u32 size); + +/* Expose Query-Request API */ +int ufshcd_wait_for_doorbell_clr(struct ufs_hba *hba, u64 wait_timeout_us); +int ufshcd_change_power_mode(struct ufs_hba *hba, + struct ufs_pa_layer_attr *pwr_mode); #endif /* End of Header */ diff --git a/drivers/scsi/ufs/ufshci.h b/drivers/scsi/ufs/ufshci.h index d572119..c8b178f 100644 --- a/drivers/scsi/ufs/ufshci.h +++ b/drivers/scsi/ufs/ufshci.h @@ -72,6 +72,8 @@ enum { REG_UIC_COMMAND_ARG_1 = 0x94, REG_UIC_COMMAND_ARG_2 = 0x98, REG_UIC_COMMAND_ARG_3 = 0x9C, + + UFSHCI_REG_SPACE_SIZE = 0xA0, }; /* Controller capability masks */