1/*
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
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/* Sysfs support */
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}									\
30static DEVICE_ATTR_RO(field);
31
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");
38rio_config_attr(destid, "0x%04x\n");
39rio_config_attr(hopcount, "0x%02x\n");
40
41static ssize_t routes_show(struct device *dev, struct device_attribute *attr, char *buf)
42{
43	struct rio_dev *rdev = to_rio_dev(dev);
44	char *str = buf;
45	int i;
46
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]);
54	}
55
56	return (str - buf);
57}
58static DEVICE_ATTR_RO(routes);
59
60static 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}
68static DEVICE_ATTR_RO(lprev);
69
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}
89static DEVICE_ATTR_RO(lnext);
90
91static 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}
99static DEVICE_ATTR_RO(modalias);
100
101static 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,
112};
113
114static 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};
122
123static ssize_t
124rio_read_config(struct file *filp, struct kobject *kobj,
125		struct bin_attribute *bin_attr,
126		char *buf, loff_t off, size_t count)
127{
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))
136		size = RIO_MAINT_SPACE_SZ;
137
138	if (off >= size)
139		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
196rio_write_config(struct file *filp, struct kobject *kobj,
197		 struct bin_attribute *bin_attr,
198		 char *buf, loff_t off, size_t count)
199{
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
206	if (off >= RIO_MAINT_SPACE_SZ)
207		return 0;
208	if (off + count > RIO_MAINT_SPACE_SZ) {
209		size = RIO_MAINT_SPACE_SZ - off;
210		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,
258		 },
259	.size = RIO_MAINT_SPACE_SZ,
260	.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{
272	int err = 0;
273
274	err = device_create_bin_file(&rdev->dev, &rio_config_attr);
275
276	if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
277		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);
280	}
281
282	if (err)
283		pr_warning("RIO: Failed to create attribute file(s) for %s\n",
284			   rio_name(rdev));
285
286	return err;
287}
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{
297	device_remove_bin_file(&rdev->dev, &rio_config_attr);
298	if (rdev->pef & RIO_PEF_SWITCH) {
299		device_remove_file(&rdev->dev, &dev_attr_routes);
300		device_remove_file(&rdev->dev, &dev_attr_lnext);
301		device_remove_file(&rdev->dev, &dev_attr_hopcount);
302	}
303}
304
305static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
306				size_t count)
307{
308	long val;
309	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
322	rc = rio_mport_scan((int)val);
323exit:
324	if (!rc)
325		rc = count;
326
327	return rc;
328}
329static BUS_ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store);
330
331static 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,
343};
344
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};
384