perf bench futex: Cache align the worker struct
[linux/fpc-iii.git] / drivers / rapidio / rio-sysfs.c
blobeda41563d06d8a1f0e1fa65267fb9441bdf75b30
1 /*
2 * RapidIO sysfs attributes and support
4 * Copyright 2005 MontaVista Software, Inc.
5 * Matt Porter <mporter@kernel.crashing.org>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
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>
19 #include "rio.h"
21 /* Sysfs support */
22 #define rio_config_attr(field, format_string) \
23 static ssize_t \
24 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
25 { \
26 struct rio_dev *rdev = to_rio_dev(dev); \
28 return sprintf(buf, format_string, rdev->field); \
29 } \
30 static DEVICE_ATTR_RO(field);
32 rio_config_attr(did, "0x%04x\n");
33 rio_config_attr(vid, "0x%04x\n");
34 rio_config_attr(device_rev, "0x%08x\n");
35 rio_config_attr(asm_did, "0x%04x\n");
36 rio_config_attr(asm_vid, "0x%04x\n");
37 rio_config_attr(asm_rev, "0x%04x\n");
38 rio_config_attr(destid, "0x%04x\n");
39 rio_config_attr(hopcount, "0x%02x\n");
41 static ssize_t routes_show(struct device *dev, struct device_attribute *attr, char *buf)
43 struct rio_dev *rdev = to_rio_dev(dev);
44 char *str = buf;
45 int i;
47 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
48 i++) {
49 if (rdev->rswitch->route_table[i] == RIO_INVALID_ROUTE)
50 continue;
51 str +=
52 sprintf(str, "%04x %02x\n", i,
53 rdev->rswitch->route_table[i]);
56 return (str - buf);
58 static DEVICE_ATTR_RO(routes);
60 static ssize_t lprev_show(struct device *dev,
61 struct device_attribute *attr, char *buf)
63 struct rio_dev *rdev = to_rio_dev(dev);
65 return sprintf(buf, "%s\n",
66 (rdev->prev) ? rio_name(rdev->prev) : "root");
68 static DEVICE_ATTR_RO(lprev);
70 static ssize_t lnext_show(struct device *dev,
71 struct device_attribute *attr, char *buf)
73 struct rio_dev *rdev = to_rio_dev(dev);
74 char *str = buf;
75 int i;
77 if (rdev->pef & RIO_PEF_SWITCH) {
78 for (i = 0; i < RIO_GET_TOTAL_PORTS(rdev->swpinfo); i++) {
79 if (rdev->rswitch->nextdev[i])
80 str += sprintf(str, "%s\n",
81 rio_name(rdev->rswitch->nextdev[i]));
82 else
83 str += sprintf(str, "null\n");
87 return str - buf;
89 static DEVICE_ATTR_RO(lnext);
91 static ssize_t modalias_show(struct device *dev,
92 struct device_attribute *attr, char *buf)
94 struct rio_dev *rdev = to_rio_dev(dev);
96 return sprintf(buf, "rapidio:v%04Xd%04Xav%04Xad%04X\n",
97 rdev->vid, rdev->did, rdev->asm_vid, rdev->asm_did);
99 static DEVICE_ATTR_RO(modalias);
101 static struct attribute *rio_dev_attrs[] = {
102 &dev_attr_did.attr,
103 &dev_attr_vid.attr,
104 &dev_attr_device_rev.attr,
105 &dev_attr_asm_did.attr,
106 &dev_attr_asm_vid.attr,
107 &dev_attr_asm_rev.attr,
108 &dev_attr_lprev.attr,
109 &dev_attr_destid.attr,
110 &dev_attr_modalias.attr,
111 NULL,
114 static const struct attribute_group rio_dev_group = {
115 .attrs = rio_dev_attrs,
118 const struct attribute_group *rio_dev_groups[] = {
119 &rio_dev_group,
120 NULL,
123 static ssize_t
124 rio_read_config(struct file *filp, struct kobject *kobj,
125 struct bin_attribute *bin_attr,
126 char *buf, loff_t off, size_t count)
128 struct rio_dev *dev = to_rio_dev(kobj_to_dev(kobj));
129 unsigned int size = 0x100;
130 loff_t init_off = off;
131 u8 *data = (u8 *) buf;
133 /* Several chips lock up trying to read undefined config space */
134 if (capable(CAP_SYS_ADMIN))
135 size = RIO_MAINT_SPACE_SZ;
137 if (off >= size)
138 return 0;
139 if (off + count > size) {
140 size -= off;
141 count = size;
142 } else {
143 size = count;
146 if ((off & 1) && size) {
147 u8 val;
148 rio_read_config_8(dev, off, &val);
149 data[off - init_off] = val;
150 off++;
151 size--;
154 if ((off & 3) && size > 2) {
155 u16 val;
156 rio_read_config_16(dev, off, &val);
157 data[off - init_off] = (val >> 8) & 0xff;
158 data[off - init_off + 1] = val & 0xff;
159 off += 2;
160 size -= 2;
163 while (size > 3) {
164 u32 val;
165 rio_read_config_32(dev, off, &val);
166 data[off - init_off] = (val >> 24) & 0xff;
167 data[off - init_off + 1] = (val >> 16) & 0xff;
168 data[off - init_off + 2] = (val >> 8) & 0xff;
169 data[off - init_off + 3] = val & 0xff;
170 off += 4;
171 size -= 4;
174 if (size >= 2) {
175 u16 val;
176 rio_read_config_16(dev, off, &val);
177 data[off - init_off] = (val >> 8) & 0xff;
178 data[off - init_off + 1] = val & 0xff;
179 off += 2;
180 size -= 2;
183 if (size > 0) {
184 u8 val;
185 rio_read_config_8(dev, off, &val);
186 data[off - init_off] = val;
187 off++;
188 --size;
191 return count;
194 static ssize_t
195 rio_write_config(struct file *filp, struct kobject *kobj,
196 struct bin_attribute *bin_attr,
197 char *buf, loff_t off, size_t count)
199 struct rio_dev *dev = to_rio_dev(kobj_to_dev(kobj));
200 unsigned int size = count;
201 loff_t init_off = off;
202 u8 *data = (u8 *) buf;
204 if (off >= RIO_MAINT_SPACE_SZ)
205 return 0;
206 if (off + count > RIO_MAINT_SPACE_SZ) {
207 size = RIO_MAINT_SPACE_SZ - off;
208 count = size;
211 if ((off & 1) && size) {
212 rio_write_config_8(dev, off, data[off - init_off]);
213 off++;
214 size--;
217 if ((off & 3) && (size > 2)) {
218 u16 val = data[off - init_off + 1];
219 val |= (u16) data[off - init_off] << 8;
220 rio_write_config_16(dev, off, val);
221 off += 2;
222 size -= 2;
225 while (size > 3) {
226 u32 val = data[off - init_off + 3];
227 val |= (u32) data[off - init_off + 2] << 8;
228 val |= (u32) data[off - init_off + 1] << 16;
229 val |= (u32) data[off - init_off] << 24;
230 rio_write_config_32(dev, off, val);
231 off += 4;
232 size -= 4;
235 if (size >= 2) {
236 u16 val = data[off - init_off + 1];
237 val |= (u16) data[off - init_off] << 8;
238 rio_write_config_16(dev, off, val);
239 off += 2;
240 size -= 2;
243 if (size) {
244 rio_write_config_8(dev, off, data[off - init_off]);
245 off++;
246 --size;
249 return count;
252 static struct bin_attribute rio_config_attr = {
253 .attr = {
254 .name = "config",
255 .mode = S_IRUGO | S_IWUSR,
257 .size = RIO_MAINT_SPACE_SZ,
258 .read = rio_read_config,
259 .write = rio_write_config,
263 * rio_create_sysfs_dev_files - create RIO specific sysfs files
264 * @rdev: device whose entries should be created
266 * Create files when @rdev is added to sysfs.
268 int rio_create_sysfs_dev_files(struct rio_dev *rdev)
270 int err = 0;
272 err = device_create_bin_file(&rdev->dev, &rio_config_attr);
274 if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
275 err |= device_create_file(&rdev->dev, &dev_attr_routes);
276 err |= device_create_file(&rdev->dev, &dev_attr_lnext);
277 err |= device_create_file(&rdev->dev, &dev_attr_hopcount);
280 if (err)
281 pr_warning("RIO: Failed to create attribute file(s) for %s\n",
282 rio_name(rdev));
284 return err;
288 * rio_remove_sysfs_dev_files - cleanup RIO specific sysfs files
289 * @rdev: device whose entries we should free
291 * Cleanup when @rdev is removed from sysfs.
293 void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
295 device_remove_bin_file(&rdev->dev, &rio_config_attr);
296 if (rdev->pef & RIO_PEF_SWITCH) {
297 device_remove_file(&rdev->dev, &dev_attr_routes);
298 device_remove_file(&rdev->dev, &dev_attr_lnext);
299 device_remove_file(&rdev->dev, &dev_attr_hopcount);
303 static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
304 size_t count)
306 long val;
307 int rc;
309 if (kstrtol(buf, 0, &val) < 0)
310 return -EINVAL;
312 if (val == RIO_MPORT_ANY) {
313 rc = rio_init_mports();
314 goto exit;
317 if (val < 0 || val >= RIO_MAX_MPORTS)
318 return -EINVAL;
320 rc = rio_mport_scan((int)val);
321 exit:
322 if (!rc)
323 rc = count;
325 return rc;
327 static BUS_ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store);
329 static struct attribute *rio_bus_attrs[] = {
330 &bus_attr_scan.attr,
331 NULL,
334 static const struct attribute_group rio_bus_group = {
335 .attrs = rio_bus_attrs,
338 const struct attribute_group *rio_bus_groups[] = {
339 &rio_bus_group,
340 NULL,
343 static ssize_t
344 port_destid_show(struct device *dev, struct device_attribute *attr,
345 char *buf)
347 struct rio_mport *mport = to_rio_mport(dev);
349 if (mport)
350 return sprintf(buf, "0x%04x\n", mport->host_deviceid);
351 else
352 return -ENODEV;
354 static DEVICE_ATTR_RO(port_destid);
356 static ssize_t sys_size_show(struct device *dev, struct device_attribute *attr,
357 char *buf)
359 struct rio_mport *mport = to_rio_mport(dev);
361 if (mport)
362 return sprintf(buf, "%u\n", mport->sys_size);
363 else
364 return -ENODEV;
366 static DEVICE_ATTR_RO(sys_size);
368 static struct attribute *rio_mport_attrs[] = {
369 &dev_attr_port_destid.attr,
370 &dev_attr_sys_size.attr,
371 NULL,
374 static const struct attribute_group rio_mport_group = {
375 .attrs = rio_mport_attrs,
378 const struct attribute_group *rio_mport_groups[] = {
379 &rio_mport_group,
380 NULL,