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 <common.h>
10 #include <malloc.h>
11 #include <dm.h>
12 #include <errno.h>
13 #include <asm/io.h>
14 #include <dm/test.h>
15 #include <linux/list.h>
16 #include <test/ut.h>
17
18 static struct unit_test_state *uts = &global_dm_test_state;
19
test_ping(struct udevice * dev,int pingval,int * pingret)20 int test_ping(struct udevice *dev, int pingval, int *pingret)
21 {
22 const struct test_ops *ops = device_get_ops(dev);
23
24 if (!ops->ping)
25 return -ENOSYS;
26
27 return ops->ping(dev, pingval, pingret);
28 }
29
test_post_bind(struct udevice * dev)30 static int test_post_bind(struct udevice *dev)
31 {
32 struct dm_test_perdev_uc_pdata *uc_pdata;
33
34 dm_testdrv_op_count[DM_TEST_OP_POST_BIND]++;
35 ut_assert(!device_active(dev));
36
37 uc_pdata = dev_get_uclass_platdata(dev);
38 ut_assert(uc_pdata);
39
40 uc_pdata->intval1 = TEST_UC_PDATA_INTVAL1;
41 uc_pdata->intval2 = TEST_UC_PDATA_INTVAL2;
42 uc_pdata->intval3 = TEST_UC_PDATA_INTVAL3;
43
44 return 0;
45 }
46
test_pre_unbind(struct udevice * dev)47 static int test_pre_unbind(struct udevice *dev)
48 {
49 dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]++;
50
51 return 0;
52 }
53
test_pre_probe(struct udevice * dev)54 static int test_pre_probe(struct udevice *dev)
55 {
56 struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
57
58 dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]++;
59 ut_assert(priv);
60 ut_assert(device_active(dev));
61
62 return 0;
63 }
64
test_post_probe(struct udevice * dev)65 static int test_post_probe(struct udevice *dev)
66 {
67 struct udevice *prev = list_entry(dev->uclass_node.prev,
68 struct udevice, uclass_node);
69
70 struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
71 struct uclass *uc = dev->uclass;
72 struct dm_test_state *dms = uts->priv;
73
74 dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]++;
75 ut_assert(priv);
76 ut_assert(device_active(dev));
77 priv->base_add = 0;
78 if (dms->skip_post_probe)
79 return 0;
80 if (&prev->uclass_node != &uc->dev_head) {
81 struct dm_test_uclass_perdev_priv *prev_uc_priv
82 = dev_get_uclass_priv(prev);
83 struct dm_test_pdata *pdata = prev->platdata;
84
85 ut_assert(pdata);
86 ut_assert(prev_uc_priv);
87 priv->base_add = prev_uc_priv->base_add + pdata->ping_add;
88 }
89
90 return 0;
91 }
92
test_pre_remove(struct udevice * dev)93 static int test_pre_remove(struct udevice *dev)
94 {
95 dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]++;
96
97 return 0;
98 }
99
test_init(struct uclass * uc)100 static int test_init(struct uclass *uc)
101 {
102 dm_testdrv_op_count[DM_TEST_OP_INIT]++;
103 ut_assert(uc->priv);
104
105 return 0;
106 }
107
test_destroy(struct uclass * uc)108 static int test_destroy(struct uclass *uc)
109 {
110 dm_testdrv_op_count[DM_TEST_OP_DESTROY]++;
111
112 return 0;
113 }
114
115 UCLASS_DRIVER(test) = {
116 .name = "test",
117 .id = UCLASS_TEST,
118 .post_bind = test_post_bind,
119 .pre_unbind = test_pre_unbind,
120 .pre_probe = test_pre_probe,
121 .post_probe = test_post_probe,
122 .pre_remove = test_pre_remove,
123 .init = test_init,
124 .destroy = test_destroy,
125 .priv_auto_alloc_size = sizeof(struct dm_test_uclass_priv),
126 .per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv),
127 .per_device_platdata_auto_alloc_size =
128 sizeof(struct dm_test_perdev_uc_pdata),
129 };
130