rio-sysfs.c 7.7 KB

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