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)                                   \
  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);                         \
  27                                                                         \
  28         return sprintf(buf, format_string, rdev->field);                \
  29 }                                                                       \
  30 static DEVICE_ATTR_RO(field);
  31
  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");
  40
  41 static 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 }
  58 static DEVICE_ATTR_RO(routes);
  59
  60 static 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 }
  68 static DEVICE_ATTR_RO(lprev);
  69
  70 static 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 }
  89 static DEVICE_ATTR_RO(lnext);
  90
  91 static 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 }
  99 static DEVICE_ATTR_RO(modalias);
 100
 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,
 112 };
 113
 114 static const struct attribute_group rio_dev_group = {
 115         .attrs = rio_dev_attrs,
 116 };
 117
 118 const struct attribute_group *rio_dev_groups[] = {
 119         &rio_dev_group,
 120         NULL,
 121 };
 122
 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)
 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
 195 static ssize_t
 196 rio_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
 254 static 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  */
 270 int 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  */
 295 void 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
 305 static 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);
 323 exit:
 324         if (!rc)
 325                 rc = count;
 326
 327         return rc;
 328 }
 329 static BUS_ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store);
 330
 331 static struct attribute *rio_bus_attrs[] = {
 332         &bus_attr_scan.attr,
 333         NULL,
 334 };
 335
 336 static const struct attribute_group rio_bus_group = {
 337         .attrs = rio_bus_attrs,
 338 };
 339
 340 const struct attribute_group *rio_bus_groups[] = {
 341         &rio_bus_group,
 342         NULL,
 343 };