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
  31 rio_config_attr(did, "0x%04x\n");
  32 rio_config_attr(vid, "0x%04x\n");
  33 rio_config_attr(device_rev, "0x%08x\n");
  34 rio_config_attr(asm_did, "0x%04x\n");
  35 rio_config_attr(asm_vid, "0x%04x\n");
  36 rio_config_attr(asm_rev, "0x%04x\n");
  37 rio_config_attr(destid, "0x%04x\n");
  38 rio_config_attr(hopcount, "0x%02x\n");
  39
  40 static 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
  58 static 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
  67 static 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
  87 struct 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
  99 static DEVICE_ATTR(routes, S_IRUGO, routes_show, NULL);
 100 static DEVICE_ATTR(lnext, S_IRUGO, lnext_show, NULL);
 101 static DEVICE_ATTR(hopcount, S_IRUGO, hopcount_show, NULL);
 102
 103 static ssize_t
 104 rio_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
 175 static ssize_t
 176 rio_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
 234 static 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  */
 250 int 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  */
 277 void 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 }