blob: cdb005c0094df0b58362db0e6a4b462afd2f0621 [file] [log] [blame]
Matt Porter394b7012005-11-07 01:00:15 -08001/*
2 * RapidIO sysfs attributes and support
3 *
4 * Copyright 2005 MontaVista Software, Inc.
5 * Matt Porter <mporter@kernel.crashing.org>
6 *
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.
11 */
12
Matt Porter394b7012005-11-07 01:00:15 -080013#include <linux/kernel.h>
14#include <linux/rio.h>
15#include <linux/rio_drv.h>
16#include <linux/stat.h>
Alexandre Bounine388b78a2011-03-23 16:43:03 -070017#include <linux/capability.h>
Matt Porter394b7012005-11-07 01:00:15 -080018
19#include "rio.h"
20
21/* Sysfs support */
22#define rio_config_attr(field, format_string) \
23static ssize_t \
Matt Porter6978bbc2005-11-07 01:00:20 -080024field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
Matt Porter394b7012005-11-07 01:00:15 -080025{ \
26 struct rio_dev *rdev = to_rio_dev(dev); \
27 \
28 return sprintf(buf, format_string, rdev->field); \
29} \
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -070030static DEVICE_ATTR_RO(field);
Matt Porter394b7012005-11-07 01:00:15 -080031
32rio_config_attr(did, "0x%04x\n");
33rio_config_attr(vid, "0x%04x\n");
34rio_config_attr(device_rev, "0x%08x\n");
35rio_config_attr(asm_did, "0x%04x\n");
36rio_config_attr(asm_vid, "0x%04x\n");
37rio_config_attr(asm_rev, "0x%04x\n");
Alexandre Bouninecd8b9742011-03-23 16:42:59 -070038rio_config_attr(destid, "0x%04x\n");
39rio_config_attr(hopcount, "0x%02x\n");
Matt Porter394b7012005-11-07 01:00:15 -080040
Matt Porter6978bbc2005-11-07 01:00:20 -080041static ssize_t routes_show(struct device *dev, struct device_attribute *attr, char *buf)
Matt Porter394b7012005-11-07 01:00:15 -080042{
43 struct rio_dev *rdev = to_rio_dev(dev);
44 char *str = buf;
45 int i;
46
Zhang Weie0423232008-04-18 13:33:42 -070047 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
48 i++) {
Matt Porter394b7012005-11-07 01:00:15 -080049 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]);
54 }
55
Matt Porter394b7012005-11-07 01:00:15 -080056 return (str - buf);
57}
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -070058static DEVICE_ATTR_RO(routes);
Matt Porter394b7012005-11-07 01:00:15 -080059
Alexandre Bouninecd8b9742011-03-23 16:42:59 -070060static ssize_t lprev_show(struct device *dev,
61 struct device_attribute *attr, char *buf)
62{
63 struct rio_dev *rdev = to_rio_dev(dev);
64
65 return sprintf(buf, "%s\n",
66 (rdev->prev) ? rio_name(rdev->prev) : "root");
67}
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -070068static DEVICE_ATTR_RO(lprev);
Alexandre Bouninecd8b9742011-03-23 16:42:59 -070069
70static ssize_t lnext_show(struct device *dev,
71 struct device_attribute *attr, char *buf)
72{
73 struct rio_dev *rdev = to_rio_dev(dev);
74 char *str = buf;
75 int i;
76
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");
84 }
85 }
86
87 return str - buf;
88}
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -070089static DEVICE_ATTR_RO(lnext);
Alexandre Bouninecd8b9742011-03-23 16:42:59 -070090
Alexandre Bounine3bdbb622013-07-03 15:08:58 -070091static ssize_t modalias_show(struct device *dev,
92 struct device_attribute *attr, char *buf)
93{
94 struct rio_dev *rdev = to_rio_dev(dev);
95
96 return sprintf(buf, "rapidio:v%04Xd%04Xav%04Xad%04X\n",
97 rdev->vid, rdev->did, rdev->asm_vid, rdev->asm_did);
98}
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -070099static DEVICE_ATTR_RO(modalias);
Alexandre Bounine3bdbb622013-07-03 15:08:58 -0700100
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -0700101static 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,
Matt Porter394b7012005-11-07 01:00:15 -0800112};
113
Greg Kroah-Hartman6d39c802013-10-06 23:55:47 -0700114static const struct attribute_group rio_dev_group = {
115 .attrs = rio_dev_attrs,
116};
117
118const struct attribute_group *rio_dev_groups[] = {
119 &rio_dev_group,
120 NULL,
121};
Alexandre Bounineac38d722010-10-27 15:34:31 -0700122
Matt Porter394b7012005-11-07 01:00:15 -0800123static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700124rio_read_config(struct file *filp, struct kobject *kobj,
125 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800126 char *buf, loff_t off, size_t count)
Matt Porter394b7012005-11-07 01:00:15 -0800127{
128 struct rio_dev *dev =
129 to_rio_dev(container_of(kobj, struct device, kobj));
130 unsigned int size = 0x100;
131 loff_t init_off = off;
132 u8 *data = (u8 *) buf;
133
134 /* Several chips lock up trying to read undefined config space */
135 if (capable(CAP_SYS_ADMIN))
Alexandre Bouninefe419472011-02-25 14:44:31 -0800136 size = RIO_MAINT_SPACE_SZ;
Matt Porter394b7012005-11-07 01:00:15 -0800137
Alexandre Bouninefe419472011-02-25 14:44:31 -0800138 if (off >= size)
Matt Porter394b7012005-11-07 01:00:15 -0800139 return 0;
140 if (off + count > size) {
141 size -= off;
142 count = size;
143 } else {
144 size = count;
145 }
146
147 if ((off & 1) && size) {
148 u8 val;
149 rio_read_config_8(dev, off, &val);
150 data[off - init_off] = val;
151 off++;
152 size--;
153 }
154
155 if ((off & 3) && size > 2) {
156 u16 val;
157 rio_read_config_16(dev, off, &val);
158 data[off - init_off] = (val >> 8) & 0xff;
159 data[off - init_off + 1] = val & 0xff;
160 off += 2;
161 size -= 2;
162 }
163
164 while (size > 3) {
165 u32 val;
166 rio_read_config_32(dev, off, &val);
167 data[off - init_off] = (val >> 24) & 0xff;
168 data[off - init_off + 1] = (val >> 16) & 0xff;
169 data[off - init_off + 2] = (val >> 8) & 0xff;
170 data[off - init_off + 3] = val & 0xff;
171 off += 4;
172 size -= 4;
173 }
174
175 if (size >= 2) {
176 u16 val;
177 rio_read_config_16(dev, off, &val);
178 data[off - init_off] = (val >> 8) & 0xff;
179 data[off - init_off + 1] = val & 0xff;
180 off += 2;
181 size -= 2;
182 }
183
184 if (size > 0) {
185 u8 val;
186 rio_read_config_8(dev, off, &val);
187 data[off - init_off] = val;
188 off++;
189 --size;
190 }
191
192 return count;
193}
194
195static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700196rio_write_config(struct file *filp, struct kobject *kobj,
197 struct bin_attribute *bin_attr,
Zhang Rui91a69022007-06-09 13:57:22 +0800198 char *buf, loff_t off, size_t count)
Matt Porter394b7012005-11-07 01:00:15 -0800199{
200 struct rio_dev *dev =
201 to_rio_dev(container_of(kobj, struct device, kobj));
202 unsigned int size = count;
203 loff_t init_off = off;
204 u8 *data = (u8 *) buf;
205
Alexandre Bouninefe419472011-02-25 14:44:31 -0800206 if (off >= RIO_MAINT_SPACE_SZ)
Matt Porter394b7012005-11-07 01:00:15 -0800207 return 0;
Alexandre Bouninefe419472011-02-25 14:44:31 -0800208 if (off + count > RIO_MAINT_SPACE_SZ) {
209 size = RIO_MAINT_SPACE_SZ - off;
Matt Porter394b7012005-11-07 01:00:15 -0800210 count = size;
211 }
212
213 if ((off & 1) && size) {
214 rio_write_config_8(dev, off, data[off - init_off]);
215 off++;
216 size--;
217 }
218
219 if ((off & 3) && (size > 2)) {
220 u16 val = data[off - init_off + 1];
221 val |= (u16) data[off - init_off] << 8;
222 rio_write_config_16(dev, off, val);
223 off += 2;
224 size -= 2;
225 }
226
227 while (size > 3) {
228 u32 val = data[off - init_off + 3];
229 val |= (u32) data[off - init_off + 2] << 8;
230 val |= (u32) data[off - init_off + 1] << 16;
231 val |= (u32) data[off - init_off] << 24;
232 rio_write_config_32(dev, off, val);
233 off += 4;
234 size -= 4;
235 }
236
237 if (size >= 2) {
238 u16 val = data[off - init_off + 1];
239 val |= (u16) data[off - init_off] << 8;
240 rio_write_config_16(dev, off, val);
241 off += 2;
242 size -= 2;
243 }
244
245 if (size) {
246 rio_write_config_8(dev, off, data[off - init_off]);
247 off++;
248 --size;
249 }
250
251 return count;
252}
253
254static struct bin_attribute rio_config_attr = {
255 .attr = {
256 .name = "config",
257 .mode = S_IRUGO | S_IWUSR,
Matt Porter394b7012005-11-07 01:00:15 -0800258 },
Alexandre Bouninefe419472011-02-25 14:44:31 -0800259 .size = RIO_MAINT_SPACE_SZ,
Matt Porter394b7012005-11-07 01:00:15 -0800260 .read = rio_read_config,
261 .write = rio_write_config,
262};
263
264/**
265 * rio_create_sysfs_dev_files - create RIO specific sysfs files
266 * @rdev: device whose entries should be created
267 *
268 * Create files when @rdev is added to sysfs.
269 */
270int rio_create_sysfs_dev_files(struct rio_dev *rdev)
271{
Yang Li5f28c522009-05-11 22:36:02 +0000272 int err = 0;
Matt Porter394b7012005-11-07 01:00:15 -0800273
Alexandre Bounineac38d722010-10-27 15:34:31 -0700274 err = device_create_bin_file(&rdev->dev, &rio_config_attr);
275
Alexandre Bounineded05782011-01-12 17:00:39 -0800276 if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
Alexandre Bouninecd8b9742011-03-23 16:42:59 -0700277 err |= device_create_file(&rdev->dev, &dev_attr_routes);
278 err |= device_create_file(&rdev->dev, &dev_attr_lnext);
279 err |= device_create_file(&rdev->dev, &dev_attr_hopcount);
Alexandre Bounineac38d722010-10-27 15:34:31 -0700280 }
281
282 if (err)
283 pr_warning("RIO: Failed to create attribute file(s) for %s\n",
284 rio_name(rdev));
Yang Li5f28c522009-05-11 22:36:02 +0000285
286 return err;
Matt Porter394b7012005-11-07 01:00:15 -0800287}
288
289/**
290 * rio_remove_sysfs_dev_files - cleanup RIO specific sysfs files
291 * @rdev: device whose entries we should free
292 *
293 * Cleanup when @rdev is removed from sysfs.
294 */
295void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
296{
Alexandre Bounineac38d722010-10-27 15:34:31 -0700297 device_remove_bin_file(&rdev->dev, &rio_config_attr);
Alexandre Bounineded05782011-01-12 17:00:39 -0800298 if (rdev->pef & RIO_PEF_SWITCH) {
Alexandre Bounineac38d722010-10-27 15:34:31 -0700299 device_remove_file(&rdev->dev, &dev_attr_routes);
Alexandre Bouninecd8b9742011-03-23 16:42:59 -0700300 device_remove_file(&rdev->dev, &dev_attr_lnext);
301 device_remove_file(&rdev->dev, &dev_attr_hopcount);
Alexandre Bounineac38d722010-10-27 15:34:31 -0700302 }
Matt Porter394b7012005-11-07 01:00:15 -0800303}
Alexandre Bouninebc8fcfe2013-05-24 15:55:06 -0700304
305static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
306 size_t count)
307{
308 long val;
Alexandre Bouninebc8fcfe2013-05-24 15:55:06 -0700309 int rc;
310
311 if (kstrtol(buf, 0, &val) < 0)
312 return -EINVAL;
313
314 if (val == RIO_MPORT_ANY) {
315 rc = rio_init_mports();
316 goto exit;
317 }
318
319 if (val < 0 || val >= RIO_MAX_MPORTS)
320 return -EINVAL;
321
Alexandre Bounine9edbc30b2013-07-03 15:08:53 -0700322 rc = rio_mport_scan((int)val);
Alexandre Bouninebc8fcfe2013-05-24 15:55:06 -0700323exit:
324 if (!rc)
325 rc = count;
326
327 return rc;
328}
Greg Kroah-Hartmaned1d2da2013-08-23 14:24:29 -0700329static BUS_ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store);
Alexandre Bouninebc8fcfe2013-05-24 15:55:06 -0700330
Greg Kroah-Hartmaned1d2da2013-08-23 14:24:29 -0700331static struct attribute *rio_bus_attrs[] = {
332 &bus_attr_scan.attr,
333 NULL,
334};
335
336static const struct attribute_group rio_bus_group = {
337 .attrs = rio_bus_attrs,
338};
339
340const struct attribute_group *rio_bus_groups[] = {
341 &rio_bus_group,
342 NULL,
Alexandre Bouninebc8fcfe2013-05-24 15:55:06 -0700343};
Alexandre Bounine2aaf3082014-04-07 15:38:56 -0700344
345static ssize_t
346port_destid_show(struct device *dev, struct device_attribute *attr,
347 char *buf)
348{
349 struct rio_mport *mport = to_rio_mport(dev);
350
351 if (mport)
352 return sprintf(buf, "0x%04x\n", mport->host_deviceid);
353 else
354 return -ENODEV;
355}
356static DEVICE_ATTR_RO(port_destid);
357
358static ssize_t sys_size_show(struct device *dev, struct device_attribute *attr,
359 char *buf)
360{
361 struct rio_mport *mport = to_rio_mport(dev);
362
363 if (mport)
364 return sprintf(buf, "%u\n", mport->sys_size);
365 else
366 return -ENODEV;
367}
368static DEVICE_ATTR_RO(sys_size);
369
370static struct attribute *rio_mport_attrs[] = {
371 &dev_attr_port_destid.attr,
372 &dev_attr_sys_size.attr,
373 NULL,
374};
375
376static const struct attribute_group rio_mport_group = {
377 .attrs = rio_mport_attrs,
378};
379
380const struct attribute_group *rio_mport_groups[] = {
381 &rio_mport_group,
382 NULL,
383};