Root/drivers/rapidio/rio-sysfs.c

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} \
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
87struct device_attribute rio_dev_attrs[] = {
88    __ATTR_RO(did),
89    __ATTR_RO(vid),
90    __ATTR_RO(device_rev),
91    __ATTR_RO(asm_did),
92    __ATTR_RO(asm_vid),
93    __ATTR_RO(asm_rev),
94    __ATTR_RO(lprev),
95    __ATTR_RO(destid),
96    __ATTR_NULL,
97};
98
99static DEVICE_ATTR(routes, S_IRUGO, routes_show, NULL);
100static DEVICE_ATTR(lnext, S_IRUGO, lnext_show, NULL);
101static DEVICE_ATTR(hopcount, S_IRUGO, hopcount_show, NULL);
102
103static ssize_t
104rio_read_config(struct file *filp, struct kobject *kobj,
105        struct bin_attribute *bin_attr,
106        char *buf, loff_t off, size_t count)
107{
108    struct rio_dev *dev =
109        to_rio_dev(container_of(kobj, struct device, kobj));
110    unsigned int size = 0x100;
111    loff_t init_off = off;
112    u8 *data = (u8 *) buf;
113
114    /* Several chips lock up trying to read undefined config space */
115    if (capable(CAP_SYS_ADMIN))
116        size = RIO_MAINT_SPACE_SZ;
117
118    if (off >= size)
119        return 0;
120    if (off + count > size) {
121        size -= off;
122        count = size;
123    } else {
124        size = count;
125    }
126
127    if ((off & 1) && size) {
128        u8 val;
129        rio_read_config_8(dev, off, &val);
130        data[off - init_off] = val;
131        off++;
132        size--;
133    }
134
135    if ((off & 3) && size > 2) {
136        u16 val;
137        rio_read_config_16(dev, off, &val);
138        data[off - init_off] = (val >> 8) & 0xff;
139        data[off - init_off + 1] = val & 0xff;
140        off += 2;
141        size -= 2;
142    }
143
144    while (size > 3) {
145        u32 val;
146        rio_read_config_32(dev, off, &val);
147        data[off - init_off] = (val >> 24) & 0xff;
148        data[off - init_off + 1] = (val >> 16) & 0xff;
149        data[off - init_off + 2] = (val >> 8) & 0xff;
150        data[off - init_off + 3] = val & 0xff;
151        off += 4;
152        size -= 4;
153    }
154
155    if (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    if (size > 0) {
165        u8 val;
166        rio_read_config_8(dev, off, &val);
167        data[off - init_off] = val;
168        off++;
169        --size;
170    }
171
172    return count;
173}
174
175static ssize_t
176rio_write_config(struct file *filp, struct kobject *kobj,
177         struct bin_attribute *bin_attr,
178         char *buf, loff_t off, size_t count)
179{
180    struct rio_dev *dev =
181        to_rio_dev(container_of(kobj, struct device, kobj));
182    unsigned int size = count;
183    loff_t init_off = off;
184    u8 *data = (u8 *) buf;
185
186    if (off >= RIO_MAINT_SPACE_SZ)
187        return 0;
188    if (off + count > RIO_MAINT_SPACE_SZ) {
189        size = RIO_MAINT_SPACE_SZ - off;
190        count = size;
191    }
192
193    if ((off & 1) && size) {
194        rio_write_config_8(dev, off, data[off - init_off]);
195        off++;
196        size--;
197    }
198
199    if ((off & 3) && (size > 2)) {
200        u16 val = data[off - init_off + 1];
201        val |= (u16) data[off - init_off] << 8;
202        rio_write_config_16(dev, off, val);
203        off += 2;
204        size -= 2;
205    }
206
207    while (size > 3) {
208        u32 val = data[off - init_off + 3];
209        val |= (u32) data[off - init_off + 2] << 8;
210        val |= (u32) data[off - init_off + 1] << 16;
211        val |= (u32) data[off - init_off] << 24;
212        rio_write_config_32(dev, off, val);
213        off += 4;
214        size -= 4;
215    }
216
217    if (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;
223    }
224
225    if (size) {
226        rio_write_config_8(dev, off, data[off - init_off]);
227        off++;
228        --size;
229    }
230
231    return count;
232}
233
234static struct bin_attribute rio_config_attr = {
235    .attr = {
236         .name = "config",
237         .mode = S_IRUGO | S_IWUSR,
238         },
239    .size = RIO_MAINT_SPACE_SZ,
240    .read = rio_read_config,
241    .write = rio_write_config,
242};
243
244/**
245 * rio_create_sysfs_dev_files - create RIO specific sysfs files
246 * @rdev: device whose entries should be created
247 *
248 * Create files when @rdev is added to sysfs.
249 */
250int rio_create_sysfs_dev_files(struct rio_dev *rdev)
251{
252    int err = 0;
253
254    err = device_create_bin_file(&rdev->dev, &rio_config_attr);
255
256    if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
257        err |= device_create_file(&rdev->dev, &dev_attr_routes);
258        err |= device_create_file(&rdev->dev, &dev_attr_lnext);
259        err |= device_create_file(&rdev->dev, &dev_attr_hopcount);
260        if (!err && rdev->rswitch->sw_sysfs)
261            err = rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_CREATE);
262    }
263
264    if (err)
265        pr_warning("RIO: Failed to create attribute file(s) for %s\n",
266               rio_name(rdev));
267
268    return err;
269}
270
271/**
272 * rio_remove_sysfs_dev_files - cleanup RIO specific sysfs files
273 * @rdev: device whose entries we should free
274 *
275 * Cleanup when @rdev is removed from sysfs.
276 */
277void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
278{
279    device_remove_bin_file(&rdev->dev, &rio_config_attr);
280    if (rdev->pef & RIO_PEF_SWITCH) {
281        device_remove_file(&rdev->dev, &dev_attr_routes);
282        device_remove_file(&rdev->dev, &dev_attr_lnext);
283        device_remove_file(&rdev->dev, &dev_attr_hopcount);
284        if (rdev->rswitch->sw_sysfs)
285            rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_REMOVE);
286    }
287}
288

Archive Download this file



interactive