1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/kernel.h>
14#include <linux/rio.h>
15#include <linux/rio_drv.h>
16#include <linux/stat.h>
17#include <linux/capability.h>
18
19#include "rio.h"
20
21
22#define rio_config_attr(field, format_string) \
23static ssize_t \
24field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
25{ \
26 struct rio_dev *rdev = to_rio_dev(dev); \
27 \
28 return sprintf(buf, format_string, rdev->field); \
29} \
30
31rio_config_attr(did, "0x%04x\n");
32rio_config_attr(vid, "0x%04x\n");
33rio_config_attr(device_rev, "0x%08x\n");
34rio_config_attr(asm_did, "0x%04x\n");
35rio_config_attr(asm_vid, "0x%04x\n");
36rio_config_attr(asm_rev, "0x%04x\n");
37rio_config_attr(destid, "0x%04x\n");
38rio_config_attr(hopcount, "0x%02x\n");
39
40static ssize_t routes_show(struct device *dev, struct device_attribute *attr, char *buf)
41{
42 struct rio_dev *rdev = to_rio_dev(dev);
43 char *str = buf;
44 int i;
45
46 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
47 i++) {
48 if (rdev->rswitch->route_table[i] == RIO_INVALID_ROUTE)
49 continue;
50 str +=
51 sprintf(str, "%04x %02x\n", i,
52 rdev->rswitch->route_table[i]);
53 }
54
55 return (str - buf);
56}
57
58static ssize_t lprev_show(struct device *dev,
59 struct device_attribute *attr, char *buf)
60{
61 struct rio_dev *rdev = to_rio_dev(dev);
62
63 return sprintf(buf, "%s\n",
64 (rdev->prev) ? rio_name(rdev->prev) : "root");
65}
66
67static ssize_t lnext_show(struct device *dev,
68 struct device_attribute *attr, char *buf)
69{
70 struct rio_dev *rdev = to_rio_dev(dev);
71 char *str = buf;
72 int i;
73
74 if (rdev->pef & RIO_PEF_SWITCH) {
75 for (i = 0; i < RIO_GET_TOTAL_PORTS(rdev->swpinfo); i++) {
76 if (rdev->rswitch->nextdev[i])
77 str += sprintf(str, "%s\n",
78 rio_name(rdev->rswitch->nextdev[i]));
79 else
80 str += sprintf(str, "null\n");
81 }
82 }
83
84 return str - buf;
85}
86
87static ssize_t modalias_show(struct device *dev,
88 struct device_attribute *attr, char *buf)
89{
90 struct rio_dev *rdev = to_rio_dev(dev);
91
92 return sprintf(buf, "rapidio:v%04Xd%04Xav%04Xad%04X\n",
93 rdev->vid, rdev->did, rdev->asm_vid, rdev->asm_did);
94}
95
96struct device_attribute rio_dev_attrs[] = {
97 __ATTR_RO(did),
98 __ATTR_RO(vid),
99 __ATTR_RO(device_rev),
100 __ATTR_RO(asm_did),
101 __ATTR_RO(asm_vid),
102 __ATTR_RO(asm_rev),
103 __ATTR_RO(lprev),
104 __ATTR_RO(destid),
105 __ATTR_RO(modalias),
106 __ATTR_NULL,
107};
108
109static DEVICE_ATTR(routes, S_IRUGO, routes_show, NULL);
110static DEVICE_ATTR(lnext, S_IRUGO, lnext_show, NULL);
111static DEVICE_ATTR(hopcount, S_IRUGO, hopcount_show, NULL);
112
113static ssize_t
114rio_read_config(struct file *filp, struct kobject *kobj,
115 struct bin_attribute *bin_attr,
116 char *buf, loff_t off, size_t count)
117{
118 struct rio_dev *dev =
119 to_rio_dev(container_of(kobj, struct device, kobj));
120 unsigned int size = 0x100;
121 loff_t init_off = off;
122 u8 *data = (u8 *) buf;
123
124
125 if (capable(CAP_SYS_ADMIN))
126 size = RIO_MAINT_SPACE_SZ;
127
128 if (off >= size)
129 return 0;
130 if (off + count > size) {
131 size -= off;
132 count = size;
133 } else {
134 size = count;
135 }
136
137 if ((off & 1) && size) {
138 u8 val;
139 rio_read_config_8(dev, off, &val);
140 data[off - init_off] = val;
141 off++;
142 size--;
143 }
144
145 if ((off & 3) && size > 2) {
146 u16 val;
147 rio_read_config_16(dev, off, &val);
148 data[off - init_off] = (val >> 8) & 0xff;
149 data[off - init_off + 1] = val & 0xff;
150 off += 2;
151 size -= 2;
152 }
153
154 while (size > 3) {
155 u32 val;
156 rio_read_config_32(dev, off, &val);
157 data[off - init_off] = (val >> 24) & 0xff;
158 data[off - init_off + 1] = (val >> 16) & 0xff;
159 data[off - init_off + 2] = (val >> 8) & 0xff;
160 data[off - init_off + 3] = val & 0xff;
161 off += 4;
162 size -= 4;
163 }
164
165 if (size >= 2) {
166 u16 val;
167 rio_read_config_16(dev, off, &val);
168 data[off - init_off] = (val >> 8) & 0xff;
169 data[off - init_off + 1] = val & 0xff;
170 off += 2;
171 size -= 2;
172 }
173
174 if (size > 0) {
175 u8 val;
176 rio_read_config_8(dev, off, &val);
177 data[off - init_off] = val;
178 off++;
179 --size;
180 }
181
182 return count;
183}
184
185static ssize_t
186rio_write_config(struct file *filp, struct kobject *kobj,
187 struct bin_attribute *bin_attr,
188 char *buf, loff_t off, size_t count)
189{
190 struct rio_dev *dev =
191 to_rio_dev(container_of(kobj, struct device, kobj));
192 unsigned int size = count;
193 loff_t init_off = off;
194 u8 *data = (u8 *) buf;
195
196 if (off >= RIO_MAINT_SPACE_SZ)
197 return 0;
198 if (off + count > RIO_MAINT_SPACE_SZ) {
199 size = RIO_MAINT_SPACE_SZ - off;
200 count = size;
201 }
202
203 if ((off & 1) && size) {
204 rio_write_config_8(dev, off, data[off - init_off]);
205 off++;
206 size--;
207 }
208
209 if ((off & 3) && (size > 2)) {
210 u16 val = data[off - init_off + 1];
211 val |= (u16) data[off - init_off] << 8;
212 rio_write_config_16(dev, off, val);
213 off += 2;
214 size -= 2;
215 }
216
217 while (size > 3) {
218 u32 val = data[off - init_off + 3];
219 val |= (u32) data[off - init_off + 2] << 8;
220 val |= (u32) data[off - init_off + 1] << 16;
221 val |= (u32) data[off - init_off] << 24;
222 rio_write_config_32(dev, off, val);
223 off += 4;
224 size -= 4;
225 }
226
227 if (size >= 2) {
228 u16 val = data[off - init_off + 1];
229 val |= (u16) data[off - init_off] << 8;
230 rio_write_config_16(dev, off, val);
231 off += 2;
232 size -= 2;
233 }
234
235 if (size) {
236 rio_write_config_8(dev, off, data[off - init_off]);
237 off++;
238 --size;
239 }
240
241 return count;
242}
243
244static struct bin_attribute rio_config_attr = {
245 .attr = {
246 .name = "config",
247 .mode = S_IRUGO | S_IWUSR,
248 },
249 .size = RIO_MAINT_SPACE_SZ,
250 .read = rio_read_config,
251 .write = rio_write_config,
252};
253
254
255
256
257
258
259
260int rio_create_sysfs_dev_files(struct rio_dev *rdev)
261{
262 int err = 0;
263
264 err = device_create_bin_file(&rdev->dev, &rio_config_attr);
265
266 if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
267 err |= device_create_file(&rdev->dev, &dev_attr_routes);
268 err |= device_create_file(&rdev->dev, &dev_attr_lnext);
269 err |= device_create_file(&rdev->dev, &dev_attr_hopcount);
270 }
271
272 if (err)
273 pr_warning("RIO: Failed to create attribute file(s) for %s\n",
274 rio_name(rdev));
275
276 return err;
277}
278
279
280
281
282
283
284
285void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
286{
287 device_remove_bin_file(&rdev->dev, &rio_config_attr);
288 if (rdev->pef & RIO_PEF_SWITCH) {
289 device_remove_file(&rdev->dev, &dev_attr_routes);
290 device_remove_file(&rdev->dev, &dev_attr_lnext);
291 device_remove_file(&rdev->dev, &dev_attr_hopcount);
292 }
293}
294
295static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
296 size_t count)
297{
298 long val;
299 int rc;
300
301 if (kstrtol(buf, 0, &val) < 0)
302 return -EINVAL;
303
304 if (val == RIO_MPORT_ANY) {
305 rc = rio_init_mports();
306 goto exit;
307 }
308
309 if (val < 0 || val >= RIO_MAX_MPORTS)
310 return -EINVAL;
311
312 rc = rio_mport_scan((int)val);
313exit:
314 if (!rc)
315 rc = count;
316
317 return rc;
318}
319
320struct bus_attribute rio_bus_attrs[] = {
321 __ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store),
322 __ATTR_NULL
323};
324
