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 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 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 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 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 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 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 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 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