1 /* 2 * Qualcomm Technologies HIDMA debug file 3 * 4 * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 and 8 * only version 2 as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 16 #include <linux/debugfs.h> 17 #include <linux/device.h> 18 #include <linux/list.h> 19 #include <linux/pm_runtime.h> 20 21 #include "hidma.h" 22 23 static void hidma_ll_chstats(struct seq_file *s, void *llhndl, u32 tre_ch) 24 { 25 struct hidma_lldev *lldev = llhndl; 26 struct hidma_tre *tre; 27 u32 length; 28 dma_addr_t src_start; 29 dma_addr_t dest_start; 30 u32 *tre_local; 31 32 if (tre_ch >= lldev->nr_tres) { 33 dev_err(lldev->dev, "invalid TRE number in chstats:%d", tre_ch); 34 return; 35 } 36 tre = &lldev->trepool[tre_ch]; 37 seq_printf(s, "------Channel %d -----\n", tre_ch); 38 seq_printf(s, "allocated=%d\n", atomic_read(&tre->allocated)); 39 seq_printf(s, "queued = 0x%x\n", tre->queued); 40 seq_printf(s, "err_info = 0x%x\n", tre->err_info); 41 seq_printf(s, "err_code = 0x%x\n", tre->err_code); 42 seq_printf(s, "status = 0x%x\n", tre->status); 43 seq_printf(s, "idx = 0x%x\n", tre->idx); 44 seq_printf(s, "dma_sig = 0x%x\n", tre->dma_sig); 45 seq_printf(s, "dev_name=%s\n", tre->dev_name); 46 seq_printf(s, "callback=%p\n", tre->callback); 47 seq_printf(s, "data=%p\n", tre->data); 48 seq_printf(s, "tre_index = 0x%x\n", tre->tre_index); 49 50 tre_local = &tre->tre_local[0]; 51 src_start = tre_local[HIDMA_TRE_SRC_LOW_IDX]; 52 src_start = ((u64) (tre_local[HIDMA_TRE_SRC_HI_IDX]) << 32) + src_start; 53 dest_start = tre_local[HIDMA_TRE_DEST_LOW_IDX]; 54 dest_start += ((u64) (tre_local[HIDMA_TRE_DEST_HI_IDX]) << 32); 55 length = tre_local[HIDMA_TRE_LEN_IDX]; 56 57 seq_printf(s, "src=%pap\n", &src_start); 58 seq_printf(s, "dest=%pap\n", &dest_start); 59 seq_printf(s, "length = 0x%x\n", length); 60 } 61 62 static void hidma_ll_devstats(struct seq_file *s, void *llhndl) 63 { 64 struct hidma_lldev *lldev = llhndl; 65 66 seq_puts(s, "------Device -----\n"); 67 seq_printf(s, "lldev init = 0x%x\n", lldev->initialized); 68 seq_printf(s, "trch_state = 0x%x\n", lldev->trch_state); 69 seq_printf(s, "evch_state = 0x%x\n", lldev->evch_state); 70 seq_printf(s, "chidx = 0x%x\n", lldev->chidx); 71 seq_printf(s, "nr_tres = 0x%x\n", lldev->nr_tres); 72 seq_printf(s, "trca=%p\n", lldev->trca); 73 seq_printf(s, "tre_ring=%p\n", lldev->tre_ring); 74 seq_printf(s, "tre_ring_handle=%pap\n", &lldev->tre_dma); 75 seq_printf(s, "tre_ring_size = 0x%x\n", lldev->tre_ring_size); 76 seq_printf(s, "tre_processed_off = 0x%x\n", lldev->tre_processed_off); 77 seq_printf(s, "pending_tre_count=%d\n", lldev->pending_tre_count); 78 seq_printf(s, "evca=%p\n", lldev->evca); 79 seq_printf(s, "evre_ring=%p\n", lldev->evre_ring); 80 seq_printf(s, "evre_ring_handle=%pap\n", &lldev->evre_dma); 81 seq_printf(s, "evre_ring_size = 0x%x\n", lldev->evre_ring_size); 82 seq_printf(s, "evre_processed_off = 0x%x\n", lldev->evre_processed_off); 83 seq_printf(s, "tre_write_offset = 0x%x\n", lldev->tre_write_offset); 84 } 85 86 /* 87 * hidma_chan_stats: display HIDMA channel statistics 88 * 89 * Display the statistics for the current HIDMA virtual channel device. 90 */ 91 static int hidma_chan_stats(struct seq_file *s, void *unused) 92 { 93 struct hidma_chan *mchan = s->private; 94 struct hidma_desc *mdesc; 95 struct hidma_dev *dmadev = mchan->dmadev; 96 97 pm_runtime_get_sync(dmadev->ddev.dev); 98 seq_printf(s, "paused=%u\n", mchan->paused); 99 seq_printf(s, "dma_sig=%u\n", mchan->dma_sig); 100 seq_puts(s, "prepared\n"); 101 list_for_each_entry(mdesc, &mchan->prepared, node) 102 hidma_ll_chstats(s, mchan->dmadev->lldev, mdesc->tre_ch); 103 104 seq_puts(s, "active\n"); 105 list_for_each_entry(mdesc, &mchan->active, node) 106 hidma_ll_chstats(s, mchan->dmadev->lldev, mdesc->tre_ch); 107 108 seq_puts(s, "completed\n"); 109 list_for_each_entry(mdesc, &mchan->completed, node) 110 hidma_ll_chstats(s, mchan->dmadev->lldev, mdesc->tre_ch); 111 112 hidma_ll_devstats(s, mchan->dmadev->lldev); 113 pm_runtime_mark_last_busy(dmadev->ddev.dev); 114 pm_runtime_put_autosuspend(dmadev->ddev.dev); 115 return 0; 116 } 117 118 /* 119 * hidma_dma_info: display HIDMA device info 120 * 121 * Display the info for the current HIDMA device. 122 */ 123 static int hidma_dma_info(struct seq_file *s, void *unused) 124 { 125 struct hidma_dev *dmadev = s->private; 126 resource_size_t sz; 127 128 seq_printf(s, "nr_descriptors=%d\n", dmadev->nr_descriptors); 129 seq_printf(s, "dev_trca=%p\n", &dmadev->dev_trca); 130 seq_printf(s, "dev_trca_phys=%pa\n", &dmadev->trca_resource->start); 131 sz = resource_size(dmadev->trca_resource); 132 seq_printf(s, "dev_trca_size=%pa\n", &sz); 133 seq_printf(s, "dev_evca=%p\n", &dmadev->dev_evca); 134 seq_printf(s, "dev_evca_phys=%pa\n", &dmadev->evca_resource->start); 135 sz = resource_size(dmadev->evca_resource); 136 seq_printf(s, "dev_evca_size=%pa\n", &sz); 137 return 0; 138 } 139 140 static int hidma_chan_stats_open(struct inode *inode, struct file *file) 141 { 142 return single_open(file, hidma_chan_stats, inode->i_private); 143 } 144 145 static int hidma_dma_info_open(struct inode *inode, struct file *file) 146 { 147 return single_open(file, hidma_dma_info, inode->i_private); 148 } 149 150 static const struct file_operations hidma_chan_fops = { 151 .open = hidma_chan_stats_open, 152 .read = seq_read, 153 .llseek = seq_lseek, 154 .release = single_release, 155 }; 156 157 static const struct file_operations hidma_dma_fops = { 158 .open = hidma_dma_info_open, 159 .read = seq_read, 160 .llseek = seq_lseek, 161 .release = single_release, 162 }; 163 164 void hidma_debug_uninit(struct hidma_dev *dmadev) 165 { 166 debugfs_remove_recursive(dmadev->debugfs); 167 debugfs_remove_recursive(dmadev->stats); 168 } 169 170 int hidma_debug_init(struct hidma_dev *dmadev) 171 { 172 int rc = 0; 173 int chidx = 0; 174 struct list_head *position = NULL; 175 176 dmadev->debugfs = debugfs_create_dir(dev_name(dmadev->ddev.dev), NULL); 177 if (!dmadev->debugfs) { 178 rc = -ENODEV; 179 return rc; 180 } 181 182 /* walk through the virtual channel list */ 183 list_for_each(position, &dmadev->ddev.channels) { 184 struct hidma_chan *chan; 185 186 chan = list_entry(position, struct hidma_chan, 187 chan.device_node); 188 sprintf(chan->dbg_name, "chan%d", chidx); 189 chan->debugfs = debugfs_create_dir(chan->dbg_name, 190 dmadev->debugfs); 191 if (!chan->debugfs) { 192 rc = -ENOMEM; 193 goto cleanup; 194 } 195 chan->stats = debugfs_create_file("stats", S_IRUGO, 196 chan->debugfs, chan, 197 &hidma_chan_fops); 198 if (!chan->stats) { 199 rc = -ENOMEM; 200 goto cleanup; 201 } 202 chidx++; 203 } 204 205 dmadev->stats = debugfs_create_file("stats", S_IRUGO, 206 dmadev->debugfs, dmadev, 207 &hidma_dma_fops); 208 if (!dmadev->stats) { 209 rc = -ENOMEM; 210 goto cleanup; 211 } 212 213 return 0; 214 cleanup: 215 hidma_debug_uninit(dmadev); 216 return rc; 217 } 218