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 }; 344 345 static ssize_t 346 port_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 } 356 static DEVICE_ATTR_RO(port_destid); 357 358 static 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 } 368 static DEVICE_ATTR_RO(sys_size); 369 370 static struct attribute *rio_mport_attrs[] = { 371 &dev_attr_port_destid.attr, 372 &dev_attr_sys_size.attr, 373 NULL, 374 }; 375 376 static const struct attribute_group rio_mport_group = { 377 .attrs = rio_mport_attrs, 378 }; 379 380 const struct attribute_group *rio_mport_groups[] = { 381 &rio_mport_group, 382 NULL, 383 }; 384