Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit f85ff3056cefdf4635ebf98b30e9a7d86521567f

Authored by Stephen Rothwell
1 parent 1ef4d4242d

Begin to consolidate of_device.c 

This moves all the common parts for the Sparc, Sparc64 and PowerPC
of_device.c files into drivers/of/device.c.

Apart from the simple move, Sparc gains of_match_node() and a call to
of_node_put in of_release_dev().  PowerPC gains better recovery if
device_create_file() fails in of_device_register().

Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Acked-by: Paul Mackerras <paulus@samba.org>
Acked-by: David S. Miller <davem@davemloft.net>

Showing 7 changed files with 142 additions and 340 deletions Side-by-side Diff

arch/powerpc/kernel/of_device.c
Diff comments   View file @ f85ff30
1 1 #include <linux/string.h>
2 2 #include <linux/kernel.h>
  3 +#include <linux/of.h>
3 4 #include <linux/init.h>
4 5 #include <linux/module.h>
5 6 #include <linux/mod_devicetable.h>
... ... @@ -8,118 +9,6 @@
8 9 #include <asm/errno.h>
9 10 #include <asm/of_device.h>
10 11  
11   -/**
12   - * of_match_node - Tell if an device_node has a matching of_match structure
13   - * @ids: array of of device match structures to search in
14   - * @node: the of device structure to match against
15   - *
16   - * Low level utility function used by device matching.
17   - */
18   -const struct of_device_id *of_match_node(const struct of_device_id *matches,
19   - const struct device_node *node)
20   -{
21   - while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
22   - int match = 1;
23   - if (matches->name[0])
24   - match &= node->name
25   - && !strcmp(matches->name, node->name);
26   - if (matches->type[0])
27   - match &= node->type
28   - && !strcmp(matches->type, node->type);
29   - if (matches->compatible[0])
30   - match &= of_device_is_compatible(node,
31   - matches->compatible);
32   - if (match)
33   - return matches;
34   - matches++;
35   - }
36   - return NULL;
37   -}
38   -
39   -/**
40   - * of_match_device - Tell if an of_device structure has a matching
41   - * of_match structure
42   - * @ids: array of of device match structures to search in
43   - * @dev: the of device structure to match against
44   - *
45   - * Used by a driver to check whether an of_device present in the
46   - * system is in its list of supported devices.
47   - */
48   -const struct of_device_id *of_match_device(const struct of_device_id *matches,
49   - const struct of_device *dev)
50   -{
51   - if (!dev->node)
52   - return NULL;
53   - return of_match_node(matches, dev->node);
54   -}
55   -
56   -struct of_device *of_dev_get(struct of_device *dev)
57   -{
58   - struct device *tmp;
59   -
60   - if (!dev)
61   - return NULL;
62   - tmp = get_device(&dev->dev);
63   - if (tmp)
64   - return to_of_device(tmp);
65   - else
66   - return NULL;
67   -}
68   -
69   -void of_dev_put(struct of_device *dev)
70   -{
71   - if (dev)
72   - put_device(&dev->dev);
73   -}
74   -
75   -static ssize_t dev_show_devspec(struct device *dev,
76   - struct device_attribute *attr, char *buf)
77   -{
78   - struct of_device *ofdev;
79   -
80   - ofdev = to_of_device(dev);
81   - return sprintf(buf, "%s", ofdev->node->full_name);
82   -}
83   -
84   -static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
85   -
86   -/**
87   - * of_release_dev - free an of device structure when all users of it are finished.
88   - * @dev: device that's been disconnected
89   - *
90   - * Will be called only by the device core when all users of this of device are
91   - * done.
92   - */
93   -void of_release_dev(struct device *dev)
94   -{
95   - struct of_device *ofdev;
96   -
97   - ofdev = to_of_device(dev);
98   - of_node_put(ofdev->node);
99   - kfree(ofdev);
100   -}
101   -
102   -int of_device_register(struct of_device *ofdev)
103   -{
104   - int rc;
105   -
106   - BUG_ON(ofdev->node == NULL);
107   -
108   - rc = device_register(&ofdev->dev);
109   - if (rc)
110   - return rc;
111   -
112   - return device_create_file(&ofdev->dev, &dev_attr_devspec);
113   -}
114   -
115   -void of_device_unregister(struct of_device *ofdev)
116   -{
117   - device_remove_file(&ofdev->dev, &dev_attr_devspec);
118   -
119   - device_unregister(&ofdev->dev);
120   -}
121   -
122   -
123 12 ssize_t of_device_get_modalias(struct of_device *ofdev,
124 13 char *str, ssize_t len)
125 14 {
... ... @@ -229,15 +118,6 @@
229 118  
230 119 return 0;
231 120 }
232   -
233   -
234   -EXPORT_SYMBOL(of_match_node);
235   -EXPORT_SYMBOL(of_match_device);
236   -EXPORT_SYMBOL(of_device_register);
237   -EXPORT_SYMBOL(of_device_unregister);
238   -EXPORT_SYMBOL(of_dev_get);
239   -EXPORT_SYMBOL(of_dev_put);
240   -EXPORT_SYMBOL(of_release_dev);
241 121 EXPORT_SYMBOL(of_device_uevent);
242 122 EXPORT_SYMBOL(of_device_get_modalias);
arch/sparc/kernel/of_device.c
Diff comments   View file @ f85ff30
1 1 #include <linux/string.h>
2 2 #include <linux/kernel.h>
  3 +#include <linux/of.h>
3 4 #include <linux/init.h>
4 5 #include <linux/module.h>
5 6 #include <linux/mod_devicetable.h>
... ... @@ -8,38 +9,6 @@
8 9 #include <asm/errno.h>
9 10 #include <asm/of_device.h>
10 11  
11   -/**
12   - * of_match_device - Tell if an of_device structure has a matching
13   - * of_match structure
14   - * @ids: array of of device match structures to search in
15   - * @dev: the of device structure to match against
16   - *
17   - * Used by a driver to check whether an of_device present in the
18   - * system is in its list of supported devices.
19   - */
20   -const struct of_device_id *of_match_device(const struct of_device_id *matches,
21   - const struct of_device *dev)
22   -{
23   - if (!dev->node)
24   - return NULL;
25   - while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
26   - int match = 1;
27   - if (matches->name[0])
28   - match &= dev->node->name
29   - && !strcmp(matches->name, dev->node->name);
30   - if (matches->type[0])
31   - match &= dev->node->type
32   - && !strcmp(matches->type, dev->node->type);
33   - if (matches->compatible[0])
34   - match &= of_device_is_compatible(dev->node,
35   - matches->compatible);
36   - if (match)
37   - return matches;
38   - matches++;
39   - }
40   - return NULL;
41   -}
42   -
43 12 static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
44 13 {
45 14 struct of_device * of_dev = to_of_device(dev);
... ... @@ -52,26 +21,6 @@
52 21 return of_match_device(matches, of_dev) != NULL;
53 22 }
54 23  
55   -struct of_device *of_dev_get(struct of_device *dev)
56   -{
57   - struct device *tmp;
58   -
59   - if (!dev)
60   - return NULL;
61   - tmp = get_device(&dev->dev);
62   - if (tmp)
63   - return to_of_device(tmp);
64   - else
65   - return NULL;
66   -}
67   -
68   -void of_dev_put(struct of_device *dev)
69   -{
70   - if (dev)
71   - put_device(&dev->dev);
72   -}
73   -
74   -
75 24 static int of_device_probe(struct device *dev)
76 25 {
77 26 int error = -ENODEV;
... ... @@ -735,56 +684,6 @@
735 684 driver_unregister(&drv->driver);
736 685 }
737 686  
738   -
739   -static ssize_t dev_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
740   -{
741   - struct of_device *ofdev;
742   -
743   - ofdev = to_of_device(dev);
744   - return sprintf(buf, "%s", ofdev->node->full_name);
745   -}
746   -
747   -static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
748   -
749   -/**
750   - * of_release_dev - free an of device structure when all users of it are finished.
751   - * @dev: device that's been disconnected
752   - *
753   - * Will be called only by the device core when all users of this of device are
754   - * done.
755   - */
756   -void of_release_dev(struct device *dev)
757   -{
758   - struct of_device *ofdev;
759   -
760   - ofdev = to_of_device(dev);
761   -
762   - kfree(ofdev);
763   -}
764   -
765   -int of_device_register(struct of_device *ofdev)
766   -{
767   - int rc;
768   -
769   - BUG_ON(ofdev->node == NULL);
770   -
771   - rc = device_register(&ofdev->dev);
772   - if (rc)
773   - return rc;
774   -
775   - rc = device_create_file(&ofdev->dev, &dev_attr_devspec);
776   - if (rc)
777   - device_unregister(&ofdev->dev);
778   -
779   - return rc;
780   -}
781   -
782   -void of_device_unregister(struct of_device *ofdev)
783   -{
784   - device_remove_file(&ofdev->dev, &dev_attr_devspec);
785   - device_unregister(&ofdev->dev);
786   -}
787   -
788 687 struct of_device* of_platform_device_create(struct device_node *np,
789 688 const char *bus_id,
790 689 struct device *parent,
791 690  
792 691  
... ... @@ -810,13 +709,7 @@
810 709 return dev;
811 710 }
812 711  
813   -EXPORT_SYMBOL(of_match_device);
814 712 EXPORT_SYMBOL(of_register_driver);
815 713 EXPORT_SYMBOL(of_unregister_driver);
816   -EXPORT_SYMBOL(of_device_register);
817   -EXPORT_SYMBOL(of_device_unregister);
818   -EXPORT_SYMBOL(of_dev_get);
819   -EXPORT_SYMBOL(of_dev_put);
820 714 EXPORT_SYMBOL(of_platform_device_create);
821   -EXPORT_SYMBOL(of_release_dev);
arch/sparc64/kernel/of_device.c
Diff comments   View file @ f85ff30
1 1 #include <linux/string.h>
2 2 #include <linux/kernel.h>
  3 +#include <linux/of.h>
3 4 #include <linux/init.h>
4 5 #include <linux/module.h>
5 6 #include <linux/mod_devicetable.h>
... ... @@ -8,38 +9,6 @@
8 9 #include <asm/errno.h>
9 10 #include <asm/of_device.h>
10 11  
11   -/**
12   - * of_match_device - Tell if an of_device structure has a matching
13   - * of_match structure
14   - * @ids: array of of device match structures to search in
15   - * @dev: the of device structure to match against
16   - *
17   - * Used by a driver to check whether an of_device present in the
18   - * system is in its list of supported devices.
19   - */
20   -const struct of_device_id *of_match_device(const struct of_device_id *matches,
21   - const struct of_device *dev)
22   -{
23   - if (!dev->node)
24   - return NULL;
25   - while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
26   - int match = 1;
27   - if (matches->name[0])
28   - match &= dev->node->name
29   - && !strcmp(matches->name, dev->node->name);
30   - if (matches->type[0])
31   - match &= dev->node->type
32   - && !strcmp(matches->type, dev->node->type);
33   - if (matches->compatible[0])
34   - match &= of_device_is_compatible(dev->node,
35   - matches->compatible);
36   - if (match)
37   - return matches;
38   - matches++;
39   - }
40   - return NULL;
41   -}
42   -
43 12 static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
44 13 {
45 14 struct of_device * of_dev = to_of_device(dev);
... ... @@ -52,26 +21,6 @@
52 21 return of_match_device(matches, of_dev) != NULL;
53 22 }
54 23  
55   -struct of_device *of_dev_get(struct of_device *dev)
56   -{
57   - struct device *tmp;
58   -
59   - if (!dev)
60   - return NULL;
61   - tmp = get_device(&dev->dev);
62   - if (tmp)
63   - return to_of_device(tmp);
64   - else
65   - return NULL;
66   -}
67   -
68   -void of_dev_put(struct of_device *dev)
69   -{
70   - if (dev)
71   - put_device(&dev->dev);
72   -}
73   -
74   -
75 24 static int of_device_probe(struct device *dev)
76 25 {
77 26 int error = -ENODEV;
78 27  
79 28  
... ... @@ -1020,62 +969,14 @@
1020 969 /* register with core */
1021 970 return driver_register(&drv->driver);
1022 971 }
  972 +EXPORT_SYMBOL(of_register_driver);
1023 973  
1024 974 void of_unregister_driver(struct of_platform_driver *drv)
1025 975 {
1026 976 driver_unregister(&drv->driver);
1027 977 }
  978 +EXPORT_SYMBOL(of_unregister_driver);
1028 979  
1029   -
1030   -static ssize_t dev_show_devspec(struct device *dev, struct device_attribute *attr, char *buf)
1031   -{
1032   - struct of_device *ofdev;
1033   -
1034   - ofdev = to_of_device(dev);
1035   - return sprintf(buf, "%s", ofdev->node->full_name);
1036   -}
1037   -
1038   -static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
1039   -
1040   -/**
1041   - * of_release_dev - free an of device structure when all users of it are finished.
1042   - * @dev: device that's been disconnected
1043   - *
1044   - * Will be called only by the device core when all users of this of device are
1045   - * done.
1046   - */
1047   -void of_release_dev(struct device *dev)
1048   -{
1049   - struct of_device *ofdev;
1050   -
1051   - ofdev = to_of_device(dev);
1052   -
1053   - kfree(ofdev);
1054   -}
1055   -
1056   -int of_device_register(struct of_device *ofdev)
1057   -{
1058   - int rc;
1059   -
1060   - BUG_ON(ofdev->node == NULL);
1061   -
1062   - rc = device_register(&ofdev->dev);
1063   - if (rc)
1064   - return rc;
1065   -
1066   - rc = device_create_file(&ofdev->dev, &dev_attr_devspec);
1067   - if (rc)
1068   - device_unregister(&ofdev->dev);
1069   -
1070   - return rc;
1071   -}
1072   -
1073   -void of_device_unregister(struct of_device *ofdev)
1074   -{
1075   - device_remove_file(&ofdev->dev, &dev_attr_devspec);
1076   - device_unregister(&ofdev->dev);
1077   -}
1078   -
1079 980 struct of_device* of_platform_device_create(struct device_node *np,
1080 981 const char *bus_id,
1081 982 struct device *parent,
1082 983  
... ... @@ -1100,14 +1001,5 @@
1100 1001  
1101 1002 return dev;
1102 1003 }
1103   -
1104   -EXPORT_SYMBOL(of_match_device);
1105   -EXPORT_SYMBOL(of_register_driver);
1106   -EXPORT_SYMBOL(of_unregister_driver);
1107   -EXPORT_SYMBOL(of_device_register);
1108   -EXPORT_SYMBOL(of_device_unregister);
1109   -EXPORT_SYMBOL(of_dev_get);
1110   -EXPORT_SYMBOL(of_dev_put);
1111 1004 EXPORT_SYMBOL(of_platform_device_create);
1112   -EXPORT_SYMBOL(of_release_dev);
... ... @@ -8,6 +8,8 @@
8 8  
9 9 source "drivers/mtd/Kconfig"
10 10  
  11 +source "drivers/of/Kconfig"
  12 +
11 13 source "drivers/parport/Kconfig"
12 14  
13 15 source "drivers/pnp/Kconfig"
  1 +config OF_DEVICE
  2 + def_bool y
  3 + depends on OF && (SPARC || PPC_OF)
1 1 obj-y = base.o
  2 +obj-$(CONFIG_OF_DEVICE) += device.o
  1 +#include <linux/string.h>
  2 +#include <linux/kernel.h>
  3 +#include <linux/of.h>
  4 +#include <linux/init.h>
  5 +#include <linux/module.h>
  6 +#include <linux/mod_devicetable.h>
  7 +#include <linux/slab.h>
  8 +
  9 +#include <asm/errno.h>
  10 +#include <asm/of_device.h>
  11 +
  12 +/**
  13 + * of_match_node - Tell if an device_node has a matching of_match structure
  14 + * @ids: array of of device match structures to search in
  15 + * @node: the of device structure to match against
  16 + *
  17 + * Low level utility function used by device matching.
  18 + */
  19 +const struct of_device_id *of_match_node(const struct of_device_id *matches,
  20 + const struct device_node *node)
  21 +{
  22 + while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
  23 + int match = 1;
  24 + if (matches->name[0])
  25 + match &= node->name
  26 + && !strcmp(matches->name, node->name);
  27 + if (matches->type[0])
  28 + match &= node->type
  29 + && !strcmp(matches->type, node->type);
  30 + if (matches->compatible[0])
  31 + match &= of_device_is_compatible(node,
  32 + matches->compatible);
  33 + if (match)
  34 + return matches;
  35 + matches++;
  36 + }
  37 + return NULL;
  38 +}
  39 +EXPORT_SYMBOL(of_match_node);
  40 +
  41 +/**
  42 + * of_match_device - Tell if an of_device structure has a matching
  43 + * of_match structure
  44 + * @ids: array of of device match structures to search in
  45 + * @dev: the of device structure to match against
  46 + *
  47 + * Used by a driver to check whether an of_device present in the
  48 + * system is in its list of supported devices.
  49 + */
  50 +const struct of_device_id *of_match_device(const struct of_device_id *matches,
  51 + const struct of_device *dev)
  52 +{
  53 + if (!dev->node)
  54 + return NULL;
  55 + return of_match_node(matches, dev->node);
  56 +}
  57 +EXPORT_SYMBOL(of_match_device);
  58 +
  59 +struct of_device *of_dev_get(struct of_device *dev)
  60 +{
  61 + struct device *tmp;
  62 +
  63 + if (!dev)
  64 + return NULL;
  65 + tmp = get_device(&dev->dev);
  66 + if (tmp)
  67 + return to_of_device(tmp);
  68 + else
  69 + return NULL;
  70 +}
  71 +EXPORT_SYMBOL(of_dev_get);
  72 +
  73 +void of_dev_put(struct of_device *dev)
  74 +{
  75 + if (dev)
  76 + put_device(&dev->dev);
  77 +}
  78 +EXPORT_SYMBOL(of_dev_put);
  79 +
  80 +static ssize_t dev_show_devspec(struct device *dev,
  81 + struct device_attribute *attr, char *buf)
  82 +{
  83 + struct of_device *ofdev;
  84 +
  85 + ofdev = to_of_device(dev);
  86 + return sprintf(buf, "%s", ofdev->node->full_name);
  87 +}
  88 +
  89 +static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
  90 +
  91 +/**
  92 + * of_release_dev - free an of device structure when all users of it are finished.
  93 + * @dev: device that's been disconnected
  94 + *
  95 + * Will be called only by the device core when all users of this of device are
  96 + * done.
  97 + */
  98 +void of_release_dev(struct device *dev)
  99 +{
  100 + struct of_device *ofdev;
  101 +
  102 + ofdev = to_of_device(dev);
  103 + of_node_put(ofdev->node);
  104 + kfree(ofdev);
  105 +}
  106 +EXPORT_SYMBOL(of_release_dev);
  107 +
  108 +int of_device_register(struct of_device *ofdev)
  109 +{
  110 + int rc;
  111 +
  112 + BUG_ON(ofdev->node == NULL);
  113 +
  114 + rc = device_register(&ofdev->dev);
  115 + if (rc)
  116 + return rc;
  117 +
  118 + rc = device_create_file(&ofdev->dev, &dev_attr_devspec);
  119 + if (rc)
  120 + device_unregister(&ofdev->dev);
  121 +
  122 + return rc;
  123 +}
  124 +EXPORT_SYMBOL(of_device_register);
  125 +
  126 +void of_device_unregister(struct of_device *ofdev)
  127 +{
  128 + device_remove_file(&ofdev->dev, &dev_attr_devspec);
  129 + device_unregister(&ofdev->dev);
  130 +}
  131 +EXPORT_SYMBOL(of_device_unregister);