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
 112         /* Switch-only attributes */
 113         &dev_attr_routes.attr,
 114         &dev_attr_lnext.attr,
 115         &dev_attr_hopcount.attr,
 116         NULL,
 117 };
 118
 119 static ssize_t
 120 rio_read_config(struct file *filp, struct kobject *kobj,
 121                 struct bin_attribute *bin_attr,
 122                 char *buf, loff_t off, size_t count)
 123 {
 124         struct rio_dev *dev = to_rio_dev(kobj_to_dev(kobj));
 125         unsigned int size = 0x100;
 126         loff_t init_off = off;
 127         u8 *data = (u8 *) buf;
 128
 129         /* Several chips lock up trying to read undefined config space */
 130         if (capable(CAP_SYS_ADMIN))
 131                 size = RIO_MAINT_SPACE_SZ;
 132
 133         if (off >= size)
 134                 return 0;
 135         if (off + count > size) {
 136                 size -= off;
 137                 count = size;
 138         } else {
 139                 size = count;
 140         }
 141
 142         if ((off & 1) && size) {
 143                 u8 val;
 144                 rio_read_config_8(dev, off, &val);
 145                 data[off - init_off] = val;
 146                 off++;
 147                 size--;
 148         }
 149
 150         if ((off & 3) && size > 2) {
 151                 u16 val;
 152                 rio_read_config_16(dev, off, &val);
 153                 data[off - init_off] = (val >> 8) & 0xff;
 154                 data[off - init_off + 1] = val & 0xff;
 155                 off += 2;
 156                 size -= 2;
 157         }
 158
 159         while (size > 3) {
 160                 u32 val;
 161                 rio_read_config_32(dev, off, &val);
 162                 data[off - init_off] = (val >> 24) & 0xff;
 163                 data[off - init_off + 1] = (val >> 16) & 0xff;
 164                 data[off - init_off + 2] = (val >> 8) & 0xff;
 165                 data[off - init_off + 3] = val & 0xff;
 166                 off += 4;
 167                 size -= 4;
 168         }
 169
 170         if (size >= 2) {
 171                 u16 val;
 172                 rio_read_config_16(dev, off, &val);
 173                 data[off - init_off] = (val >> 8) & 0xff;
 174                 data[off - init_off + 1] = val & 0xff;
 175                 off += 2;
 176                 size -= 2;
 177         }
 178
 179         if (size > 0) {
 180                 u8 val;
 181                 rio_read_config_8(dev, off, &val);
 182                 data[off - init_off] = val;
 183                 off++;
 184                 --size;
 185         }
 186
 187         return count;
 188 }
 189
 190 static ssize_t
 191 rio_write_config(struct file *filp, struct kobject *kobj,
 192                  struct bin_attribute *bin_attr,
 193                  char *buf, loff_t off, size_t count)
 194 {
 195         struct rio_dev *dev = to_rio_dev(kobj_to_dev(kobj));
 196         unsigned int size = count;
 197         loff_t init_off = off;
 198         u8 *data = (u8 *) buf;
 199
 200         if (off >= RIO_MAINT_SPACE_SZ)
 201                 return 0;
 202         if (off + count > RIO_MAINT_SPACE_SZ) {
 203                 size = RIO_MAINT_SPACE_SZ - off;
 204                 count = size;
 205         }
 206
 207         if ((off & 1) && size) {
 208                 rio_write_config_8(dev, off, data[off - init_off]);
 209                 off++;
 210                 size--;
 211         }
 212
 213         if ((off & 3) && (size > 2)) {
 214                 u16 val = data[off - init_off + 1];
 215                 val |= (u16) data[off - init_off] << 8;
 216                 rio_write_config_16(dev, off, val);
 217                 off += 2;
 218                 size -= 2;
 219         }
 220
 221         while (size > 3) {
 222                 u32 val = data[off - init_off + 3];
 223                 val |= (u32) data[off - init_off + 2] << 8;
 224                 val |= (u32) data[off - init_off + 1] << 16;
 225                 val |= (u32) data[off - init_off] << 24;
 226                 rio_write_config_32(dev, off, val);
 227                 off += 4;
 228                 size -= 4;
 229         }
 230
 231         if (size >= 2) {
 232                 u16 val = data[off - init_off + 1];
 233                 val |= (u16) data[off - init_off] << 8;
 234                 rio_write_config_16(dev, off, val);
 235                 off += 2;
 236                 size -= 2;
 237         }
 238
 239         if (size) {
 240                 rio_write_config_8(dev, off, data[off - init_off]);
 241                 off++;
 242                 --size;
 243         }
 244
 245         return count;
 246 }
 247
 248 static struct bin_attribute rio_config_attr = {
 249         .attr = {
 250                  .name = "config",
 251                  .mode = S_IRUGO | S_IWUSR,
 252                  },
 253         .size = RIO_MAINT_SPACE_SZ,
 254         .read = rio_read_config,
 255         .write = rio_write_config,
 256 };
 257
 258 static struct bin_attribute *rio_dev_bin_attrs[] = {
 259         &rio_config_attr,
 260         NULL,
 261 };
 262
 263 static umode_t rio_dev_is_attr_visible(struct kobject *kobj,
 264                                        struct attribute *attr, int n)
 265 {
 266         struct rio_dev *rdev = to_rio_dev(kobj_to_dev(kobj));
 267         umode_t mode = attr->mode;
 268
 269         if (!(rdev->pef & RIO_PEF_SWITCH) &&
 270             (attr == &dev_attr_routes.attr ||
 271              attr == &dev_attr_lnext.attr ||
 272              attr == &dev_attr_hopcount.attr)) {
 273                 /*
 274                  * Hide switch-specific attributes for a non-switch device.
 275                  */
 276                 mode = 0;
 277         }
 278
 279         return mode;
 280 }
 281
 282 static const struct attribute_group rio_dev_group = {
 283         .attrs          = rio_dev_attrs,
 284         .is_visible     = rio_dev_is_attr_visible,
 285         .bin_attrs      = rio_dev_bin_attrs,
 286 };
 287
 288 const struct attribute_group *rio_dev_groups[] = {
 289         &rio_dev_group,
 290         NULL,
 291 };
 292
 293 static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
 294                                 size_t count)
 295 {
 296         long val;
 297         int rc;
 298
 299         if (kstrtol(buf, 0, &val) < 0)
 300                 return -EINVAL;
 301
 302         if (val == RIO_MPORT_ANY) {
 303                 rc = rio_init_mports();
 304                 goto exit;
 305         }
 306
 307         if (val < 0 || val >= RIO_MAX_MPORTS)
 308                 return -EINVAL;
 309
 310         rc = rio_mport_scan((int)val);
 311 exit:
 312         if (!rc)
 313                 rc = count;
 314
 315         return rc;
 316 }
 317 static BUS_ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store);
 318
 319 static struct attribute *rio_bus_attrs[] = {
 320         &bus_attr_scan.attr,
 321         NULL,
 322 };
 323
 324 static const struct attribute_group rio_bus_group = {
 325         .attrs = rio_bus_attrs,
 326 };
 327
 328 const struct attribute_group *rio_bus_groups[] = {
 329         &rio_bus_group,
 330         NULL,
 331 };
 332
 333 static ssize_t
 334 port_destid_show(struct device *dev, struct device_attribute *attr,
 335                  char *buf)
 336 {
 337         struct rio_mport *mport = to_rio_mport(dev);
 338
 339         if (mport)
 340                 return sprintf(buf, "0x%04x\n", mport->host_deviceid);
 341         else
 342                 return -ENODEV;
 343 }
 344 static DEVICE_ATTR_RO(port_destid);
 345
 346 static ssize_t sys_size_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, "%u\n", mport->sys_size);
 353         else
 354                 return -ENODEV;
 355 }
 356 static DEVICE_ATTR_RO(sys_size);
 357
 358 static struct attribute *rio_mport_attrs[] = {
 359         &dev_attr_port_destid.attr,
 360         &dev_attr_sys_size.attr,
 361         NULL,
 362 };
 363
 364 static const struct attribute_group rio_mport_group = {
 365         .attrs = rio_mport_attrs,
 366 };
 367
 368 const struct attribute_group *rio_mport_groups[] = {
 369         &rio_mport_group,
 370         NULL,
 371 };