rio-sysfs.c 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371
  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. #include <linux/kernel.h>
  13. #include <linux/rio.h>
  14. #include <linux/rio_drv.h>
  15. #include <linux/stat.h>
  16. #include <linux/capability.h>
  17. #include "rio.h"
  18. /* Sysfs support */
  19. #define rio_config_attr(field, format_string) \
  20. static ssize_t \
  21. field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
  22. { \
  23. struct rio_dev *rdev = to_rio_dev(dev); \
  24. \
  25. return sprintf(buf, format_string, rdev->field); \
  26. } \
  27. static DEVICE_ATTR_RO(field);
  28. rio_config_attr(did, "0x%04x\n");
  29. rio_config_attr(vid, "0x%04x\n");
  30. rio_config_attr(device_rev, "0x%08x\n");
  31. rio_config_attr(asm_did, "0x%04x\n");
  32. rio_config_attr(asm_vid, "0x%04x\n");
  33. rio_config_attr(asm_rev, "0x%04x\n");
  34. rio_config_attr(destid, "0x%04x\n");
  35. rio_config_attr(hopcount, "0x%02x\n");
  36. static ssize_t routes_show(struct device *dev, struct device_attribute *attr, char *buf)
  37. {
  38. struct rio_dev *rdev = to_rio_dev(dev);
  39. char *str = buf;
  40. int i;
  41. for (i = 0; i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
  42. i++) {
  43. if (rdev->rswitch->route_table[i] == RIO_INVALID_ROUTE)
  44. continue;
  45. str +=
  46. sprintf(str, "%04x %02x\n", i,
  47. rdev->rswitch->route_table[i]);
  48. }
  49. return (str - buf);
  50. }
  51. static DEVICE_ATTR_RO(routes);
  52. static ssize_t lprev_show(struct device *dev,
  53. struct device_attribute *attr, char *buf)
  54. {
  55. struct rio_dev *rdev = to_rio_dev(dev);
  56. return sprintf(buf, "%s\n",
  57. (rdev->prev) ? rio_name(rdev->prev) : "root");
  58. }
  59. static DEVICE_ATTR_RO(lprev);
  60. static ssize_t lnext_show(struct device *dev,
  61. struct device_attribute *attr, char *buf)
  62. {
  63. struct rio_dev *rdev = to_rio_dev(dev);
  64. char *str = buf;
  65. int i;
  66. if (rdev->pef & RIO_PEF_SWITCH) {
  67. for (i = 0; i < RIO_GET_TOTAL_PORTS(rdev->swpinfo); i++) {
  68. if (rdev->rswitch->nextdev[i])
  69. str += sprintf(str, "%s\n",
  70. rio_name(rdev->rswitch->nextdev[i]));
  71. else
  72. str += sprintf(str, "null\n");
  73. }
  74. }
  75. return str - buf;
  76. }
  77. static DEVICE_ATTR_RO(lnext);
  78. static ssize_t modalias_show(struct device *dev,
  79. struct device_attribute *attr, char *buf)
  80. {
  81. struct rio_dev *rdev = to_rio_dev(dev);
  82. return sprintf(buf, "rapidio:v%04Xd%04Xav%04Xad%04X\n",
  83. rdev->vid, rdev->did, rdev->asm_vid, rdev->asm_did);
  84. }
  85. static DEVICE_ATTR_RO(modalias);
  86. static struct attribute *rio_dev_attrs[] = {
  87. &dev_attr_did.attr,
  88. &dev_attr_vid.attr,
  89. &dev_attr_device_rev.attr,
  90. &dev_attr_asm_did.attr,
  91. &dev_attr_asm_vid.attr,
  92. &dev_attr_asm_rev.attr,
  93. &dev_attr_lprev.attr,
  94. &dev_attr_destid.attr,
  95. &dev_attr_modalias.attr,
  96. /* Switch-only attributes */
  97. &dev_attr_routes.attr,
  98. &dev_attr_lnext.attr,
  99. &dev_attr_hopcount.attr,
  100. NULL,
  101. };
  102. static ssize_t
  103. rio_read_config(struct file *filp, struct kobject *kobj,
  104. struct bin_attribute *bin_attr,
  105. char *buf, loff_t off, size_t count)
  106. {
  107. struct rio_dev *dev = to_rio_dev(kobj_to_dev(kobj));
  108. unsigned int size = 0x100;
  109. loff_t init_off = off;
  110. u8 *data = (u8 *) buf;
  111. /* Several chips lock up trying to read undefined config space */
  112. if (capable(CAP_SYS_ADMIN))
  113. size = RIO_MAINT_SPACE_SZ;
  114. if (off >= size)
  115. return 0;
  116. if (off + count > size) {
  117. size -= off;
  118. count = size;
  119. } else {
  120. size = count;
  121. }
  122. if ((off & 1) && size) {
  123. u8 val;
  124. rio_read_config_8(dev, off, &val);
  125. data[off - init_off] = val;
  126. off++;
  127. size--;
  128. }
  129. if ((off & 3) && size > 2) {
  130. u16 val;
  131. rio_read_config_16(dev, off, &val);
  132. data[off - init_off] = (val >> 8) & 0xff;
  133. data[off - init_off + 1] = val & 0xff;
  134. off += 2;
  135. size -= 2;
  136. }
  137. while (size > 3) {
  138. u32 val;
  139. rio_read_config_32(dev, off, &val);
  140. data[off - init_off] = (val >> 24) & 0xff;
  141. data[off - init_off + 1] = (val >> 16) & 0xff;
  142. data[off - init_off + 2] = (val >> 8) & 0xff;
  143. data[off - init_off + 3] = val & 0xff;
  144. off += 4;
  145. size -= 4;
  146. }
  147. if (size >= 2) {
  148. u16 val;
  149. rio_read_config_16(dev, off, &val);
  150. data[off - init_off] = (val >> 8) & 0xff;
  151. data[off - init_off + 1] = val & 0xff;
  152. off += 2;
  153. size -= 2;
  154. }
  155. if (size > 0) {
  156. u8 val;
  157. rio_read_config_8(dev, off, &val);
  158. data[off - init_off] = val;
  159. off++;
  160. --size;
  161. }
  162. return count;
  163. }
  164. static ssize_t
  165. rio_write_config(struct file *filp, struct kobject *kobj,
  166. struct bin_attribute *bin_attr,
  167. char *buf, loff_t off, size_t count)
  168. {
  169. struct rio_dev *dev = to_rio_dev(kobj_to_dev(kobj));
  170. unsigned int size = count;
  171. loff_t init_off = off;
  172. u8 *data = (u8 *) buf;
  173. if (off >= RIO_MAINT_SPACE_SZ)
  174. return 0;
  175. if (off + count > RIO_MAINT_SPACE_SZ) {
  176. size = RIO_MAINT_SPACE_SZ - off;
  177. count = size;
  178. }
  179. if ((off & 1) && size) {
  180. rio_write_config_8(dev, off, data[off - init_off]);
  181. off++;
  182. size--;
  183. }
  184. if ((off & 3) && (size > 2)) {
  185. u16 val = data[off - init_off + 1];
  186. val |= (u16) data[off - init_off] << 8;
  187. rio_write_config_16(dev, off, val);
  188. off += 2;
  189. size -= 2;
  190. }
  191. while (size > 3) {
  192. u32 val = data[off - init_off + 3];
  193. val |= (u32) data[off - init_off + 2] << 8;
  194. val |= (u32) data[off - init_off + 1] << 16;
  195. val |= (u32) data[off - init_off] << 24;
  196. rio_write_config_32(dev, off, val);
  197. off += 4;
  198. size -= 4;
  199. }
  200. if (size >= 2) {
  201. u16 val = data[off - init_off + 1];
  202. val |= (u16) data[off - init_off] << 8;
  203. rio_write_config_16(dev, off, val);
  204. off += 2;
  205. size -= 2;
  206. }
  207. if (size) {
  208. rio_write_config_8(dev, off, data[off - init_off]);
  209. off++;
  210. --size;
  211. }
  212. return count;
  213. }
  214. static struct bin_attribute rio_config_attr = {
  215. .attr = {
  216. .name = "config",
  217. .mode = S_IRUGO | S_IWUSR,
  218. },
  219. .size = RIO_MAINT_SPACE_SZ,
  220. .read = rio_read_config,
  221. .write = rio_write_config,
  222. };
  223. static struct bin_attribute *rio_dev_bin_attrs[] = {
  224. &rio_config_attr,
  225. NULL,
  226. };
  227. static umode_t rio_dev_is_attr_visible(struct kobject *kobj,
  228. struct attribute *attr, int n)
  229. {
  230. struct rio_dev *rdev = to_rio_dev(kobj_to_dev(kobj));
  231. umode_t mode = attr->mode;
  232. if (!(rdev->pef & RIO_PEF_SWITCH) &&
  233. (attr == &dev_attr_routes.attr ||
  234. attr == &dev_attr_lnext.attr ||
  235. attr == &dev_attr_hopcount.attr)) {
  236. /*
  237. * Hide switch-specific attributes for a non-switch device.
  238. */
  239. mode = 0;
  240. }
  241. return mode;
  242. }
  243. static const struct attribute_group rio_dev_group = {
  244. .attrs = rio_dev_attrs,
  245. .is_visible = rio_dev_is_attr_visible,
  246. .bin_attrs = rio_dev_bin_attrs,
  247. };
  248. const struct attribute_group *rio_dev_groups[] = {
  249. &rio_dev_group,
  250. NULL,
  251. };
  252. static ssize_t bus_scan_store(struct bus_type *bus, const char *buf,
  253. size_t count)
  254. {
  255. long val;
  256. int rc;
  257. if (kstrtol(buf, 0, &val) < 0)
  258. return -EINVAL;
  259. if (val == RIO_MPORT_ANY) {
  260. rc = rio_init_mports();
  261. goto exit;
  262. }
  263. if (val < 0 || val >= RIO_MAX_MPORTS)
  264. return -EINVAL;
  265. rc = rio_mport_scan((int)val);
  266. exit:
  267. if (!rc)
  268. rc = count;
  269. return rc;
  270. }
  271. static BUS_ATTR(scan, (S_IWUSR|S_IWGRP), NULL, bus_scan_store);
  272. static struct attribute *rio_bus_attrs[] = {
  273. &bus_attr_scan.attr,
  274. NULL,
  275. };
  276. static const struct attribute_group rio_bus_group = {
  277. .attrs = rio_bus_attrs,
  278. };
  279. const struct attribute_group *rio_bus_groups[] = {
  280. &rio_bus_group,
  281. NULL,
  282. };
  283. static ssize_t
  284. port_destid_show(struct device *dev, struct device_attribute *attr,
  285. char *buf)
  286. {
  287. struct rio_mport *mport = to_rio_mport(dev);
  288. if (mport)
  289. return sprintf(buf, "0x%04x\n", mport->host_deviceid);
  290. else
  291. return -ENODEV;
  292. }
  293. static DEVICE_ATTR_RO(port_destid);
  294. static ssize_t sys_size_show(struct device *dev, struct device_attribute *attr,
  295. char *buf)
  296. {
  297. struct rio_mport *mport = to_rio_mport(dev);
  298. if (mport)
  299. return sprintf(buf, "%u\n", mport->sys_size);
  300. else
  301. return -ENODEV;
  302. }
  303. static DEVICE_ATTR_RO(sys_size);
  304. static struct attribute *rio_mport_attrs[] = {
  305. &dev_attr_port_destid.attr,
  306. &dev_attr_sys_size.attr,
  307. NULL,
  308. };
  309. static const struct attribute_group rio_mport_group = {
  310. .attrs = rio_mport_attrs,
  311. };
  312. const struct attribute_group *rio_mport_groups[] = {
  313. &rio_mport_group,
  314. NULL,
  315. };