swnode.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Software nodes for the firmware node framework.
  4. *
  5. * Copyright (C) 2018, Intel Corporation
  6. * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
  7. */
  8. #include <linux/device.h>
  9. #include <linux/kernel.h>
  10. #include <linux/property.h>
  11. #include <linux/slab.h>
  12. struct swnode {
  13. int id;
  14. struct kobject kobj;
  15. struct fwnode_handle fwnode;
  16. const struct software_node *node;
  17. /* hierarchy */
  18. struct ida child_ids;
  19. struct list_head entry;
  20. struct list_head children;
  21. struct swnode *parent;
  22. unsigned int allocated:1;
  23. };
  24. static DEFINE_IDA(swnode_root_ids);
  25. static struct kset *swnode_kset;
  26. #define kobj_to_swnode(_kobj_) container_of(_kobj_, struct swnode, kobj)
  27. static const struct fwnode_operations software_node_ops;
  28. bool is_software_node(const struct fwnode_handle *fwnode)
  29. {
  30. return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &software_node_ops;
  31. }
  32. EXPORT_SYMBOL_GPL(is_software_node);
  33. #define to_swnode(__fwnode) \
  34. ({ \
  35. typeof(__fwnode) __to_swnode_fwnode = __fwnode; \
  36. \
  37. is_software_node(__to_swnode_fwnode) ? \
  38. container_of(__to_swnode_fwnode, \
  39. struct swnode, fwnode) : NULL; \
  40. })
  41. static inline struct swnode *dev_to_swnode(struct device *dev)
  42. {
  43. struct fwnode_handle *fwnode = dev_fwnode(dev);
  44. if (!fwnode)
  45. return NULL;
  46. if (!is_software_node(fwnode))
  47. fwnode = fwnode->secondary;
  48. return to_swnode(fwnode);
  49. }
  50. static struct swnode *
  51. software_node_to_swnode(const struct software_node *node)
  52. {
  53. struct swnode *swnode = NULL;
  54. struct kobject *k;
  55. if (!node)
  56. return NULL;
  57. spin_lock(&swnode_kset->list_lock);
  58. list_for_each_entry(k, &swnode_kset->list, entry) {
  59. swnode = kobj_to_swnode(k);
  60. if (swnode->node == node)
  61. break;
  62. swnode = NULL;
  63. }
  64. spin_unlock(&swnode_kset->list_lock);
  65. return swnode;
  66. }
  67. const struct software_node *to_software_node(const struct fwnode_handle *fwnode)
  68. {
  69. const struct swnode *swnode = to_swnode(fwnode);
  70. return swnode ? swnode->node : NULL;
  71. }
  72. EXPORT_SYMBOL_GPL(to_software_node);
  73. struct fwnode_handle *software_node_fwnode(const struct software_node *node)
  74. {
  75. struct swnode *swnode = software_node_to_swnode(node);
  76. return swnode ? &swnode->fwnode : NULL;
  77. }
  78. EXPORT_SYMBOL_GPL(software_node_fwnode);
  79. /* -------------------------------------------------------------------------- */
  80. /* property_entry processing */
  81. static const struct property_entry *
  82. property_entry_get(const struct property_entry *prop, const char *name)
  83. {
  84. if (!prop)
  85. return NULL;
  86. for (; prop->name; prop++)
  87. if (!strcmp(name, prop->name))
  88. return prop;
  89. return NULL;
  90. }
  91. static const void *property_get_pointer(const struct property_entry *prop)
  92. {
  93. if (!prop->length)
  94. return NULL;
  95. return prop->is_inline ? &prop->value : prop->pointer;
  96. }
  97. static const void *property_entry_find(const struct property_entry *props,
  98. const char *propname, size_t length)
  99. {
  100. const struct property_entry *prop;
  101. const void *pointer;
  102. prop = property_entry_get(props, propname);
  103. if (!prop)
  104. return ERR_PTR(-EINVAL);
  105. pointer = property_get_pointer(prop);
  106. if (!pointer)
  107. return ERR_PTR(-ENODATA);
  108. if (length > prop->length)
  109. return ERR_PTR(-EOVERFLOW);
  110. return pointer;
  111. }
  112. static int
  113. property_entry_count_elems_of_size(const struct property_entry *props,
  114. const char *propname, size_t length)
  115. {
  116. const struct property_entry *prop;
  117. prop = property_entry_get(props, propname);
  118. if (!prop)
  119. return -EINVAL;
  120. return prop->length / length;
  121. }
  122. static int property_entry_read_int_array(const struct property_entry *props,
  123. const char *name,
  124. unsigned int elem_size, void *val,
  125. size_t nval)
  126. {
  127. const void *pointer;
  128. size_t length;
  129. if (!val)
  130. return property_entry_count_elems_of_size(props, name,
  131. elem_size);
  132. if (!is_power_of_2(elem_size) || elem_size > sizeof(u64))
  133. return -ENXIO;
  134. length = nval * elem_size;
  135. pointer = property_entry_find(props, name, length);
  136. if (IS_ERR(pointer))
  137. return PTR_ERR(pointer);
  138. memcpy(val, pointer, length);
  139. return 0;
  140. }
  141. static int property_entry_read_string_array(const struct property_entry *props,
  142. const char *propname,
  143. const char **strings, size_t nval)
  144. {
  145. const void *pointer;
  146. size_t length;
  147. int array_len;
  148. /* Find out the array length. */
  149. array_len = property_entry_count_elems_of_size(props, propname,
  150. sizeof(const char *));
  151. if (array_len < 0)
  152. return array_len;
  153. /* Return how many there are if strings is NULL. */
  154. if (!strings)
  155. return array_len;
  156. array_len = min_t(size_t, nval, array_len);
  157. length = array_len * sizeof(*strings);
  158. pointer = property_entry_find(props, propname, length);
  159. if (IS_ERR(pointer))
  160. return PTR_ERR(pointer);
  161. memcpy(strings, pointer, length);
  162. return array_len;
  163. }
  164. static void property_entry_free_data(const struct property_entry *p)
  165. {
  166. const char * const *src_str;
  167. size_t i, nval;
  168. if (p->type == DEV_PROP_STRING) {
  169. src_str = property_get_pointer(p);
  170. nval = p->length / sizeof(*src_str);
  171. for (i = 0; i < nval; i++)
  172. kfree(src_str[i]);
  173. }
  174. if (!p->is_inline)
  175. kfree(p->pointer);
  176. kfree(p->name);
  177. }
  178. static bool property_copy_string_array(const char **dst_ptr,
  179. const char * const *src_ptr,
  180. size_t nval)
  181. {
  182. int i;
  183. for (i = 0; i < nval; i++) {
  184. dst_ptr[i] = kstrdup(src_ptr[i], GFP_KERNEL);
  185. if (!dst_ptr[i] && src_ptr[i]) {
  186. while (--i >= 0)
  187. kfree(dst_ptr[i]);
  188. return false;
  189. }
  190. }
  191. return true;
  192. }
  193. static int property_entry_copy_data(struct property_entry *dst,
  194. const struct property_entry *src)
  195. {
  196. const void *pointer = property_get_pointer(src);
  197. void *dst_ptr;
  198. size_t nval;
  199. /*
  200. * Properties with no data should not be marked as stored
  201. * out of line.
  202. */
  203. if (!src->is_inline && !src->length)
  204. return -ENODATA;
  205. /*
  206. * Reference properties are never stored inline as
  207. * they are too big.
  208. */
  209. if (src->type == DEV_PROP_REF && src->is_inline)
  210. return -EINVAL;
  211. if (src->length <= sizeof(dst->value)) {
  212. dst_ptr = &dst->value;
  213. dst->is_inline = true;
  214. } else {
  215. dst_ptr = kmalloc(src->length, GFP_KERNEL);
  216. if (!dst_ptr)
  217. return -ENOMEM;
  218. dst->pointer = dst_ptr;
  219. }
  220. if (src->type == DEV_PROP_STRING) {
  221. nval = src->length / sizeof(const char *);
  222. if (!property_copy_string_array(dst_ptr, pointer, nval)) {
  223. if (!dst->is_inline)
  224. kfree(dst->pointer);
  225. return -ENOMEM;
  226. }
  227. } else {
  228. memcpy(dst_ptr, pointer, src->length);
  229. }
  230. dst->length = src->length;
  231. dst->type = src->type;
  232. dst->name = kstrdup(src->name, GFP_KERNEL);
  233. if (!dst->name) {
  234. property_entry_free_data(dst);
  235. return -ENOMEM;
  236. }
  237. return 0;
  238. }
  239. /**
  240. * property_entries_dup - duplicate array of properties
  241. * @properties: array of properties to copy
  242. *
  243. * This function creates a deep copy of the given NULL-terminated array
  244. * of property entries.
  245. */
  246. struct property_entry *
  247. property_entries_dup(const struct property_entry *properties)
  248. {
  249. struct property_entry *p;
  250. int i, n = 0;
  251. int ret;
  252. if (!properties)
  253. return NULL;
  254. while (properties[n].name)
  255. n++;
  256. p = kcalloc(n + 1, sizeof(*p), GFP_KERNEL);
  257. if (!p)
  258. return ERR_PTR(-ENOMEM);
  259. for (i = 0; i < n; i++) {
  260. ret = property_entry_copy_data(&p[i], &properties[i]);
  261. if (ret) {
  262. while (--i >= 0)
  263. property_entry_free_data(&p[i]);
  264. kfree(p);
  265. return ERR_PTR(ret);
  266. }
  267. }
  268. return p;
  269. }
  270. EXPORT_SYMBOL_GPL(property_entries_dup);
  271. /**
  272. * property_entries_free - free previously allocated array of properties
  273. * @properties: array of properties to destroy
  274. *
  275. * This function frees given NULL-terminated array of property entries,
  276. * along with their data.
  277. */
  278. void property_entries_free(const struct property_entry *properties)
  279. {
  280. const struct property_entry *p;
  281. if (!properties)
  282. return;
  283. for (p = properties; p->name; p++)
  284. property_entry_free_data(p);
  285. kfree(properties);
  286. }
  287. EXPORT_SYMBOL_GPL(property_entries_free);
  288. /* -------------------------------------------------------------------------- */
  289. /* fwnode operations */
  290. static struct fwnode_handle *software_node_get(struct fwnode_handle *fwnode)
  291. {
  292. struct swnode *swnode = to_swnode(fwnode);
  293. kobject_get(&swnode->kobj);
  294. return &swnode->fwnode;
  295. }
  296. static void software_node_put(struct fwnode_handle *fwnode)
  297. {
  298. struct swnode *swnode = to_swnode(fwnode);
  299. kobject_put(&swnode->kobj);
  300. }
  301. static bool software_node_property_present(const struct fwnode_handle *fwnode,
  302. const char *propname)
  303. {
  304. struct swnode *swnode = to_swnode(fwnode);
  305. return !!property_entry_get(swnode->node->properties, propname);
  306. }
  307. static int software_node_read_int_array(const struct fwnode_handle *fwnode,
  308. const char *propname,
  309. unsigned int elem_size, void *val,
  310. size_t nval)
  311. {
  312. struct swnode *swnode = to_swnode(fwnode);
  313. return property_entry_read_int_array(swnode->node->properties, propname,
  314. elem_size, val, nval);
  315. }
  316. static int software_node_read_string_array(const struct fwnode_handle *fwnode,
  317. const char *propname,
  318. const char **val, size_t nval)
  319. {
  320. struct swnode *swnode = to_swnode(fwnode);
  321. return property_entry_read_string_array(swnode->node->properties,
  322. propname, val, nval);
  323. }
  324. static const char *
  325. software_node_get_name(const struct fwnode_handle *fwnode)
  326. {
  327. const struct swnode *swnode = to_swnode(fwnode);
  328. if (!swnode)
  329. return "(null)";
  330. return kobject_name(&swnode->kobj);
  331. }
  332. static const char *
  333. software_node_get_name_prefix(const struct fwnode_handle *fwnode)
  334. {
  335. struct fwnode_handle *parent;
  336. const char *prefix;
  337. parent = fwnode_get_parent(fwnode);
  338. if (!parent)
  339. return "";
  340. /* Figure out the prefix from the parents. */
  341. while (is_software_node(parent))
  342. parent = fwnode_get_next_parent(parent);
  343. prefix = fwnode_get_name_prefix(parent);
  344. fwnode_handle_put(parent);
  345. /* Guess something if prefix was NULL. */
  346. return prefix ?: "/";
  347. }
  348. static struct fwnode_handle *
  349. software_node_get_parent(const struct fwnode_handle *fwnode)
  350. {
  351. struct swnode *swnode = to_swnode(fwnode);
  352. if (!swnode || !swnode->parent)
  353. return NULL;
  354. return fwnode_handle_get(&swnode->parent->fwnode);
  355. }
  356. static struct fwnode_handle *
  357. software_node_get_next_child(const struct fwnode_handle *fwnode,
  358. struct fwnode_handle *child)
  359. {
  360. struct swnode *p = to_swnode(fwnode);
  361. struct swnode *c = to_swnode(child);
  362. if (!p || list_empty(&p->children) ||
  363. (c && list_is_last(&c->entry, &p->children))) {
  364. fwnode_handle_put(child);
  365. return NULL;
  366. }
  367. if (c)
  368. c = list_next_entry(c, entry);
  369. else
  370. c = list_first_entry(&p->children, struct swnode, entry);
  371. fwnode_handle_put(child);
  372. return fwnode_handle_get(&c->fwnode);
  373. }
  374. static struct fwnode_handle *
  375. software_node_get_named_child_node(const struct fwnode_handle *fwnode,
  376. const char *childname)
  377. {
  378. struct swnode *swnode = to_swnode(fwnode);
  379. struct swnode *child;
  380. if (!swnode || list_empty(&swnode->children))
  381. return NULL;
  382. list_for_each_entry(child, &swnode->children, entry) {
  383. if (!strcmp(childname, kobject_name(&child->kobj))) {
  384. kobject_get(&child->kobj);
  385. return &child->fwnode;
  386. }
  387. }
  388. return NULL;
  389. }
  390. static int
  391. software_node_get_reference_args(const struct fwnode_handle *fwnode,
  392. const char *propname, const char *nargs_prop,
  393. unsigned int nargs, unsigned int index,
  394. struct fwnode_reference_args *args)
  395. {
  396. struct swnode *swnode = to_swnode(fwnode);
  397. const struct software_node_ref_args *ref_array;
  398. const struct software_node_ref_args *ref;
  399. const struct property_entry *prop;
  400. struct fwnode_handle *refnode;
  401. u32 nargs_prop_val;
  402. int error;
  403. int i;
  404. if (!swnode)
  405. return -ENOENT;
  406. prop = property_entry_get(swnode->node->properties, propname);
  407. if (!prop)
  408. return -ENOENT;
  409. if (prop->type != DEV_PROP_REF)
  410. return -EINVAL;
  411. /*
  412. * We expect that references are never stored inline, even
  413. * single ones, as they are too big.
  414. */
  415. if (prop->is_inline)
  416. return -EINVAL;
  417. if (index * sizeof(*ref) >= prop->length)
  418. return -ENOENT;
  419. ref_array = prop->pointer;
  420. ref = &ref_array[index];
  421. refnode = software_node_fwnode(ref->node);
  422. if (!refnode)
  423. return -ENOENT;
  424. if (nargs_prop) {
  425. error = property_entry_read_int_array(ref->node->properties,
  426. nargs_prop, sizeof(u32),
  427. &nargs_prop_val, 1);
  428. if (error)
  429. return error;
  430. nargs = nargs_prop_val;
  431. }
  432. if (nargs > NR_FWNODE_REFERENCE_ARGS)
  433. return -EINVAL;
  434. args->fwnode = software_node_get(refnode);
  435. args->nargs = nargs;
  436. for (i = 0; i < nargs; i++)
  437. args->args[i] = ref->args[i];
  438. return 0;
  439. }
  440. static const struct fwnode_operations software_node_ops = {
  441. .get = software_node_get,
  442. .put = software_node_put,
  443. .property_present = software_node_property_present,
  444. .property_read_int_array = software_node_read_int_array,
  445. .property_read_string_array = software_node_read_string_array,
  446. .get_name = software_node_get_name,
  447. .get_name_prefix = software_node_get_name_prefix,
  448. .get_parent = software_node_get_parent,
  449. .get_next_child_node = software_node_get_next_child,
  450. .get_named_child_node = software_node_get_named_child_node,
  451. .get_reference_args = software_node_get_reference_args
  452. };
  453. /* -------------------------------------------------------------------------- */
  454. /**
  455. * software_node_find_by_name - Find software node by name
  456. * @parent: Parent of the software node
  457. * @name: Name of the software node
  458. *
  459. * The function will find a node that is child of @parent and that is named
  460. * @name. If no node is found, the function returns NULL.
  461. *
  462. * NOTE: you will need to drop the reference with fwnode_handle_put() after use.
  463. */
  464. const struct software_node *
  465. software_node_find_by_name(const struct software_node *parent, const char *name)
  466. {
  467. struct swnode *swnode = NULL;
  468. struct kobject *k;
  469. if (!name)
  470. return NULL;
  471. spin_lock(&swnode_kset->list_lock);
  472. list_for_each_entry(k, &swnode_kset->list, entry) {
  473. swnode = kobj_to_swnode(k);
  474. if (parent == swnode->node->parent && swnode->node->name &&
  475. !strcmp(name, swnode->node->name)) {
  476. kobject_get(&swnode->kobj);
  477. break;
  478. }
  479. swnode = NULL;
  480. }
  481. spin_unlock(&swnode_kset->list_lock);
  482. return swnode ? swnode->node : NULL;
  483. }
  484. EXPORT_SYMBOL_GPL(software_node_find_by_name);
  485. static int
  486. software_node_register_properties(struct software_node *node,
  487. const struct property_entry *properties)
  488. {
  489. struct property_entry *props;
  490. props = property_entries_dup(properties);
  491. if (IS_ERR(props))
  492. return PTR_ERR(props);
  493. node->properties = props;
  494. return 0;
  495. }
  496. static void software_node_release(struct kobject *kobj)
  497. {
  498. struct swnode *swnode = kobj_to_swnode(kobj);
  499. if (swnode->parent) {
  500. ida_simple_remove(&swnode->parent->child_ids, swnode->id);
  501. list_del(&swnode->entry);
  502. } else {
  503. ida_simple_remove(&swnode_root_ids, swnode->id);
  504. }
  505. if (swnode->allocated) {
  506. property_entries_free(swnode->node->properties);
  507. kfree(swnode->node);
  508. }
  509. ida_destroy(&swnode->child_ids);
  510. kfree(swnode);
  511. }
  512. static struct kobj_type software_node_type = {
  513. .release = software_node_release,
  514. .sysfs_ops = &kobj_sysfs_ops,
  515. };
  516. static struct fwnode_handle *
  517. swnode_register(const struct software_node *node, struct swnode *parent,
  518. unsigned int allocated)
  519. {
  520. struct swnode *swnode;
  521. int ret;
  522. swnode = kzalloc(sizeof(*swnode), GFP_KERNEL);
  523. if (!swnode) {
  524. ret = -ENOMEM;
  525. goto out_err;
  526. }
  527. ret = ida_simple_get(parent ? &parent->child_ids : &swnode_root_ids,
  528. 0, 0, GFP_KERNEL);
  529. if (ret < 0) {
  530. kfree(swnode);
  531. goto out_err;
  532. }
  533. swnode->id = ret;
  534. swnode->node = node;
  535. swnode->parent = parent;
  536. swnode->allocated = allocated;
  537. swnode->kobj.kset = swnode_kset;
  538. fwnode_init(&swnode->fwnode, &software_node_ops);
  539. ida_init(&swnode->child_ids);
  540. INIT_LIST_HEAD(&swnode->entry);
  541. INIT_LIST_HEAD(&swnode->children);
  542. if (node->name)
  543. ret = kobject_init_and_add(&swnode->kobj, &software_node_type,
  544. parent ? &parent->kobj : NULL,
  545. "%s", node->name);
  546. else
  547. ret = kobject_init_and_add(&swnode->kobj, &software_node_type,
  548. parent ? &parent->kobj : NULL,
  549. "node%d", swnode->id);
  550. if (ret) {
  551. kobject_put(&swnode->kobj);
  552. return ERR_PTR(ret);
  553. }
  554. if (parent)
  555. list_add_tail(&swnode->entry, &parent->children);
  556. kobject_uevent(&swnode->kobj, KOBJ_ADD);
  557. return &swnode->fwnode;
  558. out_err:
  559. if (allocated)
  560. property_entries_free(node->properties);
  561. return ERR_PTR(ret);
  562. }
  563. /**
  564. * software_node_register_nodes - Register an array of software nodes
  565. * @nodes: Zero terminated array of software nodes to be registered
  566. *
  567. * Register multiple software nodes at once.
  568. */
  569. int software_node_register_nodes(const struct software_node *nodes)
  570. {
  571. int ret;
  572. int i;
  573. for (i = 0; nodes[i].name; i++) {
  574. ret = software_node_register(&nodes[i]);
  575. if (ret) {
  576. software_node_unregister_nodes(nodes);
  577. return ret;
  578. }
  579. }
  580. return 0;
  581. }
  582. EXPORT_SYMBOL_GPL(software_node_register_nodes);
  583. /**
  584. * software_node_unregister_nodes - Unregister an array of software nodes
  585. * @nodes: Zero terminated array of software nodes to be unregistered
  586. *
  587. * Unregister multiple software nodes at once.
  588. *
  589. * NOTE: Be careful using this call if the nodes had parent pointers set up in
  590. * them before registering. If so, it is wiser to remove the nodes
  591. * individually, in the correct order (child before parent) instead of relying
  592. * on the sequential order of the list of nodes in the array.
  593. */
  594. void software_node_unregister_nodes(const struct software_node *nodes)
  595. {
  596. int i;
  597. for (i = 0; nodes[i].name; i++)
  598. software_node_unregister(&nodes[i]);
  599. }
  600. EXPORT_SYMBOL_GPL(software_node_unregister_nodes);
  601. /**
  602. * software_node_register_node_group - Register a group of software nodes
  603. * @node_group: NULL terminated array of software node pointers to be registered
  604. *
  605. * Register multiple software nodes at once.
  606. */
  607. int software_node_register_node_group(const struct software_node **node_group)
  608. {
  609. unsigned int i;
  610. int ret;
  611. if (!node_group)
  612. return 0;
  613. for (i = 0; node_group[i]; i++) {
  614. ret = software_node_register(node_group[i]);
  615. if (ret) {
  616. software_node_unregister_node_group(node_group);
  617. return ret;
  618. }
  619. }
  620. return 0;
  621. }
  622. EXPORT_SYMBOL_GPL(software_node_register_node_group);
  623. /**
  624. * software_node_unregister_node_group - Unregister a group of software nodes
  625. * @node_group: NULL terminated array of software node pointers to be unregistered
  626. *
  627. * Unregister multiple software nodes at once.
  628. */
  629. void software_node_unregister_node_group(const struct software_node **node_group)
  630. {
  631. unsigned int i;
  632. if (!node_group)
  633. return;
  634. for (i = 0; node_group[i]; i++)
  635. software_node_unregister(node_group[i]);
  636. }
  637. EXPORT_SYMBOL_GPL(software_node_unregister_node_group);
  638. /**
  639. * software_node_register - Register static software node
  640. * @node: The software node to be registered
  641. */
  642. int software_node_register(const struct software_node *node)
  643. {
  644. struct swnode *parent = software_node_to_swnode(node->parent);
  645. if (software_node_to_swnode(node))
  646. return -EEXIST;
  647. if (node->parent && !parent)
  648. return -EINVAL;
  649. return PTR_ERR_OR_ZERO(swnode_register(node, parent, 0));
  650. }
  651. EXPORT_SYMBOL_GPL(software_node_register);
  652. /**
  653. * software_node_unregister - Unregister static software node
  654. * @node: The software node to be unregistered
  655. */
  656. void software_node_unregister(const struct software_node *node)
  657. {
  658. struct swnode *swnode;
  659. swnode = software_node_to_swnode(node);
  660. if (swnode)
  661. fwnode_remove_software_node(&swnode->fwnode);
  662. }
  663. EXPORT_SYMBOL_GPL(software_node_unregister);
  664. struct fwnode_handle *
  665. fwnode_create_software_node(const struct property_entry *properties,
  666. const struct fwnode_handle *parent)
  667. {
  668. struct software_node *node;
  669. struct swnode *p = NULL;
  670. int ret;
  671. if (parent) {
  672. if (IS_ERR(parent))
  673. return ERR_CAST(parent);
  674. if (!is_software_node(parent))
  675. return ERR_PTR(-EINVAL);
  676. p = to_swnode(parent);
  677. }
  678. node = kzalloc(sizeof(*node), GFP_KERNEL);
  679. if (!node)
  680. return ERR_PTR(-ENOMEM);
  681. ret = software_node_register_properties(node, properties);
  682. if (ret) {
  683. kfree(node);
  684. return ERR_PTR(ret);
  685. }
  686. node->parent = p ? p->node : NULL;
  687. return swnode_register(node, p, 1);
  688. }
  689. EXPORT_SYMBOL_GPL(fwnode_create_software_node);
  690. void fwnode_remove_software_node(struct fwnode_handle *fwnode)
  691. {
  692. struct swnode *swnode = to_swnode(fwnode);
  693. if (!swnode)
  694. return;
  695. kobject_put(&swnode->kobj);
  696. }
  697. EXPORT_SYMBOL_GPL(fwnode_remove_software_node);
  698. /**
  699. * device_add_software_node - Assign software node to a device
  700. * @dev: The device the software node is meant for.
  701. * @node: The software node.
  702. *
  703. * This function will make @node the secondary firmware node pointer of @dev. If
  704. * @dev has no primary node, then @node will become the primary node. The
  705. * function will register @node automatically if it wasn't already registered.
  706. */
  707. int device_add_software_node(struct device *dev, const struct software_node *node)
  708. {
  709. struct swnode *swnode;
  710. int ret;
  711. /* Only one software node per device. */
  712. if (dev_to_swnode(dev))
  713. return -EBUSY;
  714. swnode = software_node_to_swnode(node);
  715. if (swnode) {
  716. kobject_get(&swnode->kobj);
  717. } else {
  718. ret = software_node_register(node);
  719. if (ret)
  720. return ret;
  721. swnode = software_node_to_swnode(node);
  722. }
  723. set_secondary_fwnode(dev, &swnode->fwnode);
  724. /*
  725. * If the device has been fully registered by the time this function is
  726. * called, software_node_notify() must be called separately so that the
  727. * symlinks get created and the reference count of the node is kept in
  728. * balance.
  729. */
  730. if (device_is_registered(dev))
  731. software_node_notify(dev, KOBJ_ADD);
  732. return 0;
  733. }
  734. EXPORT_SYMBOL_GPL(device_add_software_node);
  735. /**
  736. * device_remove_software_node - Remove device's software node
  737. * @dev: The device with the software node.
  738. *
  739. * This function will unregister the software node of @dev.
  740. */
  741. void device_remove_software_node(struct device *dev)
  742. {
  743. struct swnode *swnode;
  744. swnode = dev_to_swnode(dev);
  745. if (!swnode)
  746. return;
  747. if (device_is_registered(dev))
  748. software_node_notify(dev, KOBJ_REMOVE);
  749. set_secondary_fwnode(dev, NULL);
  750. kobject_put(&swnode->kobj);
  751. }
  752. EXPORT_SYMBOL_GPL(device_remove_software_node);
  753. int software_node_notify(struct device *dev, unsigned long action)
  754. {
  755. struct swnode *swnode;
  756. int ret;
  757. swnode = dev_to_swnode(dev);
  758. if (!swnode)
  759. return 0;
  760. switch (action) {
  761. case KOBJ_ADD:
  762. ret = sysfs_create_link(&dev->kobj, &swnode->kobj, "software_node");
  763. if (ret)
  764. break;
  765. ret = sysfs_create_link(&swnode->kobj, &dev->kobj,
  766. dev_name(dev));
  767. if (ret) {
  768. sysfs_remove_link(&dev->kobj, "software_node");
  769. break;
  770. }
  771. kobject_get(&swnode->kobj);
  772. break;
  773. case KOBJ_REMOVE:
  774. sysfs_remove_link(&swnode->kobj, dev_name(dev));
  775. sysfs_remove_link(&dev->kobj, "software_node");
  776. kobject_put(&swnode->kobj);
  777. break;
  778. default:
  779. break;
  780. }
  781. return 0;
  782. }
  783. static int __init software_node_init(void)
  784. {
  785. swnode_kset = kset_create_and_add("software_nodes", NULL, kernel_kobj);
  786. if (!swnode_kset)
  787. return -ENOMEM;
  788. return 0;
  789. }
  790. postcore_initcall(software_node_init);
  791. static void __exit software_node_exit(void)
  792. {
  793. ida_destroy(&swnode_root_ids);
  794. kset_unregister(swnode_kset);
  795. }
  796. __exitcall(software_node_exit);