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