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
24static 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
55static 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: 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
70static 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: addr + reg);
75 rc = opal_xscom_write(chip, reg, value);
76 if (rc)
77 return -EIO;
78 return 0;
79}
80
81struct scom_debug_entry {
82 u32 chip;
83 struct debugfs_blob_wrapper path;
84 char name[16];
85};
86
87static 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(chip: ent->chip, addr: reg_base, reg, value: &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
118static 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(chip: ent->chip, addr: reg_base, reg, value: val);
137 if (rc) {
138 if (!done)
139 done = rc;
140 break;
141 }
142 ubuf64++;
143 done += 8;
144 }
145 return done;
146}
147
148static 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
155static 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(buf: ent->name, size: 16, fmt: "%08x", chip);
167 ent->path.data = (void *)kasprintf(GFP_KERNEL, fmt: "%pOF", dn);
168 if (!ent->path.data) {
169 kfree(objp: ent);
170 return -ENOMEM;
171 }
172
173 ent->path.size = strlen((char *)ent->path.data);
174
175 dir = debugfs_create_dir(name: ent->name, parent: root);
176 if (IS_ERR(ptr: dir)) {
177 kfree(objp: ent->path.data);
178 kfree(objp: ent);
179 return -1;
180 }
181
182 debugfs_create_blob(name: "devspec", mode: 0400, parent: dir, blob: &ent->path);
183 debugfs_create_file("access", 0600, dir, ent, &scom_debug_fops);
184
185 return 0;
186}
187
188static 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(name: "scom", parent: arch_debugfs_dir);
198 if (IS_ERR(ptr: 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}
210device_initcall(scom_debug_init);
211

source code of linux/arch/powerpc/platforms/powernv/opal-xscom.c