1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2013 Google, Inc
4 *
5 * (C) Copyright 2012
6 * Pavel Herrmann <morpheus.ibis@gmail.com>
7 */
8
9 #include <dm.h>
10 #include <errno.h>
11 #include <log.h>
12 #include <malloc.h>
13 #include <asm/io.h>
14 #include <dm/device-internal.h>
15 #include <dm/test.h>
16 #include <test/test.h>
17 #include <test/ut.h>
18
19 int dm_testdrv_op_count[DM_TEST_OP_COUNT];
20
testdrv_ping(struct udevice * dev,int pingval,int * pingret)21 static int testdrv_ping(struct udevice *dev, int pingval, int *pingret)
22 {
23 const struct dm_test_pdata *pdata = dev_get_plat(dev);
24 struct dm_test_priv *priv = dev_get_priv(dev);
25
26 *pingret = pingval + pdata->ping_add;
27 priv->ping_total += *pingret;
28
29 return 0;
30 }
31
32 static const struct test_ops test_ops = {
33 .ping = testdrv_ping,
34 };
35
test_bind(struct udevice * dev)36 static int test_bind(struct udevice *dev)
37 {
38 struct unit_test_state *uts = ut_get_state();
39
40 /* Private data should not be allocated */
41 ut_assert(!dev_get_priv(dev));
42
43 dm_testdrv_op_count[DM_TEST_OP_BIND]++;
44 return 0;
45 }
46
test_probe(struct udevice * dev)47 static int test_probe(struct udevice *dev)
48 {
49 struct unit_test_state *uts = ut_get_state();
50 struct dm_test_priv *priv = dev_get_priv(dev);
51
52 /* Private data should be allocated */
53 ut_assert(priv);
54
55 dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
56 priv->ping_total += DM_TEST_START_TOTAL;
57 return 0;
58 }
59
test_remove(struct udevice * dev)60 static int test_remove(struct udevice *dev)
61 {
62 struct unit_test_state *uts = ut_get_state();
63
64 /* Private data should still be allocated */
65 ut_assert(dev_get_priv(dev));
66
67 dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
68 return 0;
69 }
70
test_unbind(struct udevice * dev)71 static int test_unbind(struct udevice *dev)
72 {
73 struct unit_test_state *uts = ut_get_state();
74
75 /* Private data should not be allocated */
76 ut_assert(!dev_get_priv(dev));
77
78 dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
79 return 0;
80 }
81
82 U_BOOT_DRIVER(test_drv) = {
83 .name = "test_drv",
84 .id = UCLASS_TEST,
85 .ops = &test_ops,
86 .bind = test_bind,
87 .probe = test_probe,
88 .remove = test_remove,
89 .unbind = test_unbind,
90 .priv_auto = sizeof(struct dm_test_priv),
91 };
92
93 U_BOOT_DRIVER(test2_drv) = {
94 .name = "test2_drv",
95 .id = UCLASS_TEST,
96 .ops = &test_ops,
97 .bind = test_bind,
98 .probe = test_probe,
99 .remove = test_remove,
100 .unbind = test_unbind,
101 .priv_auto = sizeof(struct dm_test_priv),
102 };
103
test_manual_drv_ping(struct udevice * dev,int pingval,int * pingret)104 static int test_manual_drv_ping(struct udevice *dev, int pingval, int *pingret)
105 {
106 *pingret = pingval + 2;
107
108 return 0;
109 }
110
111 static const struct test_ops test_manual_ops = {
112 .ping = test_manual_drv_ping,
113 };
114
test_manual_bind(struct udevice * dev)115 static int test_manual_bind(struct udevice *dev)
116 {
117 dm_testdrv_op_count[DM_TEST_OP_BIND]++;
118
119 return 0;
120 }
121
test_manual_probe(struct udevice * dev)122 static int test_manual_probe(struct udevice *dev)
123 {
124 struct unit_test_state *uts = ut_get_state();
125
126 dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
127 if (!uts->force_fail_alloc)
128 dev_set_priv(dev, calloc(1, sizeof(struct dm_test_priv)));
129 if (!dev_get_priv(dev))
130 return -ENOMEM;
131
132 return 0;
133 }
134
test_manual_remove(struct udevice * dev)135 static int test_manual_remove(struct udevice *dev)
136 {
137 dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
138 return 0;
139 }
140
test_manual_unbind(struct udevice * dev)141 static int test_manual_unbind(struct udevice *dev)
142 {
143 dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
144 return 0;
145 }
146
147 U_BOOT_DRIVER(test_manual_drv) = {
148 .name = "test_manual_drv",
149 .id = UCLASS_TEST,
150 .ops = &test_manual_ops,
151 .bind = test_manual_bind,
152 .probe = test_manual_probe,
153 .remove = test_manual_remove,
154 .unbind = test_manual_unbind,
155 };
156
157 U_BOOT_DRIVER(test_pre_reloc_drv) = {
158 .name = "test_pre_reloc_drv",
159 .id = UCLASS_TEST,
160 .ops = &test_manual_ops,
161 .bind = test_manual_bind,
162 .probe = test_manual_probe,
163 .remove = test_manual_remove,
164 .unbind = test_manual_unbind,
165 .flags = DM_FLAG_PRE_RELOC,
166 };
167
168 U_BOOT_DRIVER(test_act_dma_drv) = {
169 .name = "test_act_dma_drv",
170 .id = UCLASS_TEST,
171 .ops = &test_manual_ops,
172 .bind = test_manual_bind,
173 .probe = test_manual_probe,
174 .remove = test_manual_remove,
175 .unbind = test_manual_unbind,
176 .flags = DM_FLAG_ACTIVE_DMA,
177 };
178
179 U_BOOT_DRIVER(test_vital_clk_drv) = {
180 .name = "test_vital_clk_drv",
181 .id = UCLASS_TEST,
182 .ops = &test_manual_ops,
183 .bind = test_manual_bind,
184 .probe = test_manual_probe,
185 .remove = test_manual_remove,
186 .unbind = test_manual_unbind,
187 .flags = DM_FLAG_VITAL,
188 };
189
190 U_BOOT_DRIVER(test_act_dma_vital_clk_drv) = {
191 .name = "test_act_dma_vital_clk_drv",
192 .id = UCLASS_TEST,
193 .ops = &test_manual_ops,
194 .bind = test_manual_bind,
195 .probe = test_manual_probe,
196 .remove = test_manual_remove,
197 .unbind = test_manual_unbind,
198 .flags = DM_FLAG_VITAL | DM_FLAG_ACTIVE_DMA,
199 };
200