1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2017 - 2019 Pensando Systems, Inc */ 3 4 #include <linux/pci.h> 5 #include <linux/netdevice.h> 6 7 #include "ionic.h" 8 #include "ionic_bus.h" 9 #include "ionic_lif.h" 10 #include "ionic_debugfs.h" 11 12 #ifdef CONFIG_DEBUG_FS 13 14 static struct dentry *ionic_dir; 15 16 void ionic_debugfs_create(void) 17 { 18 ionic_dir = debugfs_create_dir(IONIC_DRV_NAME, NULL); 19 } 20 21 void ionic_debugfs_destroy(void) 22 { 23 debugfs_remove_recursive(ionic_dir); 24 } 25 26 void ionic_debugfs_add_dev(struct ionic *ionic) 27 { 28 ionic->dentry = debugfs_create_dir(ionic_bus_info(ionic), ionic_dir); 29 } 30 31 void ionic_debugfs_del_dev(struct ionic *ionic) 32 { 33 debugfs_remove_recursive(ionic->dentry); 34 ionic->dentry = NULL; 35 } 36 37 static int identity_show(struct seq_file *seq, void *v) 38 { 39 struct ionic *ionic = seq->private; 40 struct ionic_identity *ident; 41 42 ident = &ionic->ident; 43 44 seq_printf(seq, "nlifs: %d\n", ident->dev.nlifs); 45 seq_printf(seq, "nintrs: %d\n", ident->dev.nintrs); 46 seq_printf(seq, "ndbpgs_per_lif: %d\n", ident->dev.ndbpgs_per_lif); 47 seq_printf(seq, "intr_coal_mult: %d\n", ident->dev.intr_coal_mult); 48 seq_printf(seq, "intr_coal_div: %d\n", ident->dev.intr_coal_div); 49 50 seq_printf(seq, "max_ucast_filters: %d\n", ident->lif.eth.max_ucast_filters); 51 seq_printf(seq, "max_mcast_filters: %d\n", ident->lif.eth.max_mcast_filters); 52 53 return 0; 54 } 55 DEFINE_SHOW_ATTRIBUTE(identity); 56 57 void ionic_debugfs_add_ident(struct ionic *ionic) 58 { 59 debugfs_create_file("identity", 0400, ionic->dentry, 60 ionic, &identity_fops); 61 } 62 63 void ionic_debugfs_add_sizes(struct ionic *ionic) 64 { 65 debugfs_create_u32("nlifs", 0400, ionic->dentry, 66 (u32 *)&ionic->ident.dev.nlifs); 67 debugfs_create_u32("nintrs", 0400, ionic->dentry, &ionic->nintrs); 68 69 debugfs_create_u32("ntxqs_per_lif", 0400, ionic->dentry, 70 (u32 *)&ionic->ident.lif.eth.config.queue_count[IONIC_QTYPE_TXQ]); 71 debugfs_create_u32("nrxqs_per_lif", 0400, ionic->dentry, 72 (u32 *)&ionic->ident.lif.eth.config.queue_count[IONIC_QTYPE_RXQ]); 73 } 74 75 static int q_tail_show(struct seq_file *seq, void *v) 76 { 77 struct ionic_queue *q = seq->private; 78 79 seq_printf(seq, "%d\n", q->tail_idx); 80 81 return 0; 82 } 83 DEFINE_SHOW_ATTRIBUTE(q_tail); 84 85 static int q_head_show(struct seq_file *seq, void *v) 86 { 87 struct ionic_queue *q = seq->private; 88 89 seq_printf(seq, "%d\n", q->head_idx); 90 91 return 0; 92 } 93 DEFINE_SHOW_ATTRIBUTE(q_head); 94 95 static int cq_tail_show(struct seq_file *seq, void *v) 96 { 97 struct ionic_cq *cq = seq->private; 98 99 seq_printf(seq, "%d\n", cq->tail_idx); 100 101 return 0; 102 } 103 DEFINE_SHOW_ATTRIBUTE(cq_tail); 104 105 static const struct debugfs_reg32 intr_ctrl_regs[] = { 106 { .name = "coal_init", .offset = 0, }, 107 { .name = "mask", .offset = 4, }, 108 { .name = "credits", .offset = 8, }, 109 { .name = "mask_on_assert", .offset = 12, }, 110 { .name = "coal_timer", .offset = 16, }, 111 }; 112 113 void ionic_debugfs_add_qcq(struct ionic_lif *lif, struct ionic_qcq *qcq) 114 { 115 struct dentry *qcq_dentry, *q_dentry, *cq_dentry; 116 struct ionic_dev *idev = &lif->ionic->idev; 117 struct dentry *intr_dentry, *stats_dentry; 118 struct debugfs_regset32 *intr_ctrl_regset; 119 struct ionic_intr_info *intr = &qcq->intr; 120 struct debugfs_blob_wrapper *desc_blob; 121 struct device *dev = lif->ionic->dev; 122 struct ionic_queue *q = &qcq->q; 123 struct ionic_cq *cq = &qcq->cq; 124 125 qcq_dentry = debugfs_create_dir(q->name, lif->dentry); 126 if (IS_ERR(qcq_dentry)) 127 return; 128 qcq->dentry = qcq_dentry; 129 130 debugfs_create_x64("q_base_pa", 0400, qcq_dentry, &qcq->q_base_pa); 131 debugfs_create_x32("q_size", 0400, qcq_dentry, &qcq->q_size); 132 debugfs_create_x64("cq_base_pa", 0400, qcq_dentry, &qcq->cq_base_pa); 133 debugfs_create_x32("cq_size", 0400, qcq_dentry, &qcq->cq_size); 134 debugfs_create_x64("sg_base_pa", 0400, qcq_dentry, &qcq->sg_base_pa); 135 debugfs_create_x32("sg_size", 0400, qcq_dentry, &qcq->sg_size); 136 137 q_dentry = debugfs_create_dir("q", qcq->dentry); 138 139 debugfs_create_u32("index", 0400, q_dentry, &q->index); 140 debugfs_create_u32("num_descs", 0400, q_dentry, &q->num_descs); 141 debugfs_create_u32("desc_size", 0400, q_dentry, &q->desc_size); 142 debugfs_create_u32("pid", 0400, q_dentry, &q->pid); 143 debugfs_create_u32("qid", 0400, q_dentry, &q->hw_index); 144 debugfs_create_u32("qtype", 0400, q_dentry, &q->hw_type); 145 debugfs_create_u64("drop", 0400, q_dentry, &q->drop); 146 147 debugfs_create_file("tail", 0400, q_dentry, q, &q_tail_fops); 148 debugfs_create_file("head", 0400, q_dentry, q, &q_head_fops); 149 150 desc_blob = devm_kzalloc(dev, sizeof(*desc_blob), GFP_KERNEL); 151 if (!desc_blob) 152 return; 153 desc_blob->data = q->base; 154 desc_blob->size = (unsigned long)q->num_descs * q->desc_size; 155 debugfs_create_blob("desc_blob", 0400, q_dentry, desc_blob); 156 157 if (qcq->flags & IONIC_QCQ_F_SG) { 158 desc_blob = devm_kzalloc(dev, sizeof(*desc_blob), GFP_KERNEL); 159 if (!desc_blob) 160 return; 161 desc_blob->data = q->sg_base; 162 desc_blob->size = (unsigned long)q->num_descs * q->sg_desc_size; 163 debugfs_create_blob("sg_desc_blob", 0400, q_dentry, 164 desc_blob); 165 } 166 167 cq_dentry = debugfs_create_dir("cq", qcq->dentry); 168 169 debugfs_create_x64("base_pa", 0400, cq_dentry, &cq->base_pa); 170 debugfs_create_u32("num_descs", 0400, cq_dentry, &cq->num_descs); 171 debugfs_create_u32("desc_size", 0400, cq_dentry, &cq->desc_size); 172 debugfs_create_bool("done_color", 0400, cq_dentry, &cq->done_color); 173 174 debugfs_create_file("tail", 0400, cq_dentry, cq, &cq_tail_fops); 175 176 desc_blob = devm_kzalloc(dev, sizeof(*desc_blob), GFP_KERNEL); 177 if (!desc_blob) 178 return; 179 desc_blob->data = cq->base; 180 desc_blob->size = (unsigned long)cq->num_descs * cq->desc_size; 181 debugfs_create_blob("desc_blob", 0400, cq_dentry, desc_blob); 182 183 if (qcq->flags & IONIC_QCQ_F_INTR) { 184 intr_dentry = debugfs_create_dir("intr", qcq->dentry); 185 186 debugfs_create_u32("index", 0400, intr_dentry, 187 &intr->index); 188 debugfs_create_u32("vector", 0400, intr_dentry, 189 &intr->vector); 190 debugfs_create_u32("dim_coal_hw", 0400, intr_dentry, 191 &intr->dim_coal_hw); 192 193 intr_ctrl_regset = devm_kzalloc(dev, sizeof(*intr_ctrl_regset), 194 GFP_KERNEL); 195 if (!intr_ctrl_regset) 196 return; 197 intr_ctrl_regset->regs = intr_ctrl_regs; 198 intr_ctrl_regset->nregs = ARRAY_SIZE(intr_ctrl_regs); 199 intr_ctrl_regset->base = &idev->intr_ctrl[intr->index]; 200 201 debugfs_create_regset32("intr_ctrl", 0400, intr_dentry, 202 intr_ctrl_regset); 203 } 204 205 if (qcq->flags & IONIC_QCQ_F_NOTIFYQ) { 206 stats_dentry = debugfs_create_dir("notifyblock", qcq->dentry); 207 208 debugfs_create_u64("eid", 0400, stats_dentry, 209 (u64 *)&lif->info->status.eid); 210 debugfs_create_u16("link_status", 0400, stats_dentry, 211 (u16 *)&lif->info->status.link_status); 212 debugfs_create_u32("link_speed", 0400, stats_dentry, 213 (u32 *)&lif->info->status.link_speed); 214 debugfs_create_u16("link_down_count", 0400, stats_dentry, 215 (u16 *)&lif->info->status.link_down_count); 216 } 217 } 218 219 static int netdev_show(struct seq_file *seq, void *v) 220 { 221 struct net_device *netdev = seq->private; 222 223 seq_printf(seq, "%s\n", netdev_name(netdev)); 224 225 return 0; 226 } 227 DEFINE_SHOW_ATTRIBUTE(netdev); 228 229 static int lif_filters_show(struct seq_file *seq, void *v) 230 { 231 struct ionic_lif *lif = seq->private; 232 struct ionic_rx_filter *f; 233 struct hlist_head *head; 234 struct hlist_node *tmp; 235 unsigned int i; 236 237 seq_puts(seq, "id flow state type filter\n"); 238 spin_lock_bh(&lif->rx_filters.lock); 239 for (i = 0; i < IONIC_RX_FILTER_HLISTS; i++) { 240 head = &lif->rx_filters.by_id[i]; 241 hlist_for_each_entry_safe(f, tmp, head, by_id) { 242 switch (le16_to_cpu(f->cmd.match)) { 243 case IONIC_RX_FILTER_MATCH_VLAN: 244 seq_printf(seq, "0x%04x 0x%08x 0x%02x vlan 0x%04x\n", 245 f->filter_id, f->flow_id, f->state, 246 le16_to_cpu(f->cmd.vlan.vlan)); 247 break; 248 case IONIC_RX_FILTER_MATCH_MAC: 249 seq_printf(seq, "0x%04x 0x%08x 0x%02x mac %pM\n", 250 f->filter_id, f->flow_id, f->state, 251 f->cmd.mac.addr); 252 break; 253 case IONIC_RX_FILTER_MATCH_MAC_VLAN: 254 seq_printf(seq, "0x%04x 0x%08x 0x%02x macvl 0x%04x %pM\n", 255 f->filter_id, f->flow_id, f->state, 256 le16_to_cpu(f->cmd.vlan.vlan), 257 f->cmd.mac.addr); 258 break; 259 case IONIC_RX_FILTER_STEER_PKTCLASS: 260 seq_printf(seq, "0x%04x 0x%08x 0x%02x rxstr 0x%llx\n", 261 f->filter_id, f->flow_id, f->state, 262 le64_to_cpu(f->cmd.pkt_class)); 263 break; 264 } 265 } 266 } 267 spin_unlock_bh(&lif->rx_filters.lock); 268 269 return 0; 270 } 271 DEFINE_SHOW_ATTRIBUTE(lif_filters); 272 273 void ionic_debugfs_add_lif(struct ionic_lif *lif) 274 { 275 struct dentry *lif_dentry; 276 277 lif_dentry = debugfs_create_dir(lif->name, lif->ionic->dentry); 278 if (IS_ERR_OR_NULL(lif_dentry)) 279 return; 280 lif->dentry = lif_dentry; 281 282 debugfs_create_file("netdev", 0400, lif->dentry, 283 lif->netdev, &netdev_fops); 284 debugfs_create_file("filters", 0400, lif->dentry, 285 lif, &lif_filters_fops); 286 } 287 288 void ionic_debugfs_del_lif(struct ionic_lif *lif) 289 { 290 if (!lif->dentry) 291 return; 292 293 debugfs_remove_recursive(lif->dentry); 294 lif->dentry = NULL; 295 } 296 297 void ionic_debugfs_del_qcq(struct ionic_qcq *qcq) 298 { 299 debugfs_remove_recursive(qcq->dentry); 300 qcq->dentry = NULL; 301 } 302 303 #endif 304