1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * PowerNV SCOM bus debugfs interface 4 * 5 * Copyright 2010 Benjamin Herrenschmidt, IBM Corp 6 * <benh@kernel.crashing.org> 7 * and David Gibson, IBM Corporation. 8 * Copyright 2013 IBM Corp. 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/of.h> 13 #include <linux/bug.h> 14 #include <linux/gfp.h> 15 #include <linux/slab.h> 16 #include <linux/uaccess.h> 17 #include <linux/debugfs.h> 18 19 #include <asm/machdep.h> 20 #include <asm/firmware.h> 21 #include <asm/opal.h> 22 #include <asm/prom.h> 23 24 static u64 opal_scom_unmangle(u64 addr) 25 { 26 u64 tmp; 27 28 /* 29 * XSCOM addresses use the top nibble to set indirect mode and 30 * its form. Bits 4-11 are always 0. 31 * 32 * Because the debugfs interface uses signed offsets and shifts 33 * the address left by 3, we basically cannot use the top 4 bits 34 * of the 64-bit address, and thus cannot use the indirect bit. 35 * 36 * To deal with that, we support the indirect bits being in 37 * bits 4-7 (IBM notation) instead of bit 0-3 in this API, we 38 * do the conversion here. 39 * 40 * For in-kernel use, we don't need to do this mangling. In 41 * kernel won't have bits 4-7 set. 42 * 43 * So: 44 * debugfs will always set 0-3 = 0 and clear 4-7 45 * kernel will always clear 0-3 = 0 and set 4-7 46 */ 47 tmp = addr; 48 tmp &= 0x0f00000000000000; 49 addr &= 0xf0ffffffffffffff; 50 addr |= tmp << 4; 51 52 return addr; 53 } 54 55 static int opal_scom_read(uint32_t chip, uint64_t addr, u64 reg, u64 *value) 56 { 57 int64_t rc; 58 __be64 v; 59 60 reg = opal_scom_unmangle(addr + reg); 61 rc = opal_xscom_read(chip, reg, (__be64 *)__pa(&v)); 62 if (rc) { 63 *value = 0xfffffffffffffffful; 64 return -EIO; 65 } 66 *value = be64_to_cpu(v); 67 return 0; 68 } 69 70 static int opal_scom_write(uint32_t chip, uint64_t addr, u64 reg, u64 value) 71 { 72 int64_t rc; 73 74 reg = opal_scom_unmangle(addr + reg); 75 rc = opal_xscom_write(chip, reg, value); 76 if (rc) 77 return -EIO; 78 return 0; 79 } 80 81 struct scom_debug_entry { 82 u32 chip; 83 struct debugfs_blob_wrapper path; 84 char name[16]; 85 }; 86 87 static ssize_t scom_debug_read(struct file *filp, char __user *ubuf, 88 size_t count, loff_t *ppos) 89 { 90 struct scom_debug_entry *ent = filp->private_data; 91 u64 __user *ubuf64 = (u64 __user *)ubuf; 92 loff_t off = *ppos; 93 ssize_t done = 0; 94 u64 reg, reg_base, reg_cnt, val; 95 int rc; 96 97 if (off < 0 || (off & 7) || (count & 7)) 98 return -EINVAL; 99 reg_base = off >> 3; 100 reg_cnt = count >> 3; 101 102 for (reg = 0; reg < reg_cnt; reg++) { 103 rc = opal_scom_read(ent->chip, reg_base, reg, &val); 104 if (!rc) 105 rc = put_user(val, ubuf64); 106 if (rc) { 107 if (!done) 108 done = rc; 109 break; 110 } 111 ubuf64++; 112 *ppos += 8; 113 done += 8; 114 } 115 return done; 116 } 117 118 static ssize_t scom_debug_write(struct file *filp, const char __user *ubuf, 119 size_t count, loff_t *ppos) 120 { 121 struct scom_debug_entry *ent = filp->private_data; 122 u64 __user *ubuf64 = (u64 __user *)ubuf; 123 loff_t off = *ppos; 124 ssize_t done = 0; 125 u64 reg, reg_base, reg_cnt, val; 126 int rc; 127 128 if (off < 0 || (off & 7) || (count & 7)) 129 return -EINVAL; 130 reg_base = off >> 3; 131 reg_cnt = count >> 3; 132 133 for (reg = 0; reg < reg_cnt; reg++) { 134 rc = get_user(val, ubuf64); 135 if (!rc) 136 rc = opal_scom_write(ent->chip, reg_base, reg, val); 137 if (rc) { 138 if (!done) 139 done = rc; 140 break; 141 } 142 ubuf64++; 143 done += 8; 144 } 145 return done; 146 } 147 148 static const struct file_operations scom_debug_fops = { 149 .read = scom_debug_read, 150 .write = scom_debug_write, 151 .open = simple_open, 152 .llseek = default_llseek, 153 }; 154 155 static int scom_debug_init_one(struct dentry *root, struct device_node *dn, 156 int chip) 157 { 158 struct scom_debug_entry *ent; 159 struct dentry *dir; 160 161 ent = kzalloc(sizeof(*ent), GFP_KERNEL); 162 if (!ent) 163 return -ENOMEM; 164 165 ent->chip = chip; 166 snprintf(ent->name, 16, "%08x", chip); 167 ent->path.data = (void *)kasprintf(GFP_KERNEL, "%pOF", dn); 168 if (!ent->path.data) { 169 kfree(ent); 170 return -ENOMEM; 171 } 172 173 ent->path.size = strlen((char *)ent->path.data); 174 175 dir = debugfs_create_dir(ent->name, root); 176 if (IS_ERR(dir)) { 177 kfree(ent->path.data); 178 kfree(ent); 179 return -1; 180 } 181 182 debugfs_create_blob("devspec", 0400, dir, &ent->path); 183 debugfs_create_file("access", 0600, dir, ent, &scom_debug_fops); 184 185 return 0; 186 } 187 188 static int scom_debug_init(void) 189 { 190 struct device_node *dn; 191 struct dentry *root; 192 int chip, rc; 193 194 if (!firmware_has_feature(FW_FEATURE_OPAL)) 195 return 0; 196 197 root = debugfs_create_dir("scom", arch_debugfs_dir); 198 if (IS_ERR(root)) 199 return -1; 200 201 rc = 0; 202 for_each_node_with_property(dn, "scom-controller") { 203 chip = of_get_ibm_chip_id(dn); 204 WARN_ON(chip == -1); 205 rc |= scom_debug_init_one(root, dn, chip); 206 } 207 208 return rc; 209 } 210 device_initcall(scom_debug_init); 211