Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (c) 2013 Google, Inc. |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #ifndef __DM_TEST_H |
| 7 | #define __DM_TEST_H |
| 8 | |
Tom Rini | dec7ea0 | 2024-05-20 13:35:03 -0600 | [diff] [blame] | 9 | #include <linux/types.h> |
| 10 | |
Simon Glass | a34b3eb | 2021-03-28 06:53:08 +1300 | [diff] [blame] | 11 | struct udevice; |
| 12 | |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 13 | /** |
| 14 | * struct dm_test_cdata - configuration data for test instance |
| 15 | * |
| 16 | * @ping_add: Amonut to add each time we get a ping |
| 17 | * @base: Base address of this device |
| 18 | */ |
| 19 | struct dm_test_pdata { |
| 20 | int ping_add; |
| 21 | uint32_t base; |
| 22 | }; |
| 23 | |
| 24 | /** |
| 25 | * struct test_ops - Operations supported by the test device |
| 26 | * |
| 27 | * @ping: Ping operation |
| 28 | * @dev: Device to operate on |
| 29 | * @pingval: Value to ping the device with |
| 30 | * @pingret: Returns resulting value from driver |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 31 | * Return: 0 if OK, -ve on error |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 32 | */ |
| 33 | struct test_ops { |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 34 | int (*ping)(struct udevice *dev, int pingval, int *pingret); |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 35 | }; |
| 36 | |
| 37 | /* Operations that our test driver supports */ |
| 38 | enum { |
| 39 | DM_TEST_OP_BIND = 0, |
| 40 | DM_TEST_OP_UNBIND, |
| 41 | DM_TEST_OP_PROBE, |
| 42 | DM_TEST_OP_REMOVE, |
| 43 | |
| 44 | /* For uclass */ |
| 45 | DM_TEST_OP_POST_BIND, |
| 46 | DM_TEST_OP_PRE_UNBIND, |
Simon Glass | 9c1f382 | 2015-03-05 12:25:22 -0700 | [diff] [blame] | 47 | DM_TEST_OP_PRE_PROBE, |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 48 | DM_TEST_OP_POST_PROBE, |
| 49 | DM_TEST_OP_PRE_REMOVE, |
| 50 | DM_TEST_OP_INIT, |
| 51 | DM_TEST_OP_DESTROY, |
| 52 | |
| 53 | DM_TEST_OP_COUNT, |
| 54 | }; |
| 55 | |
| 56 | /* Test driver types */ |
| 57 | enum { |
| 58 | DM_TEST_TYPE_FIRST = 0, |
| 59 | DM_TEST_TYPE_SECOND, |
Simon Glass | 35cb2a4 | 2020-02-06 09:54:50 -0700 | [diff] [blame] | 60 | |
| 61 | DM_TEST_TYPE_COUNT, |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 62 | }; |
| 63 | |
| 64 | /* The number added to the ping total on each probe */ |
| 65 | #define DM_TEST_START_TOTAL 5 |
| 66 | |
| 67 | /** |
| 68 | * struct dm_test_priv - private data for the test devices |
| 69 | */ |
| 70 | struct dm_test_priv { |
| 71 | int ping_total; |
| 72 | int op_count[DM_TEST_OP_COUNT]; |
Simon Glass | 5104b98 | 2015-01-25 08:27:10 -0700 | [diff] [blame] | 73 | int uclass_flag; |
| 74 | int uclass_total; |
Bin Meng | d9bad17 | 2018-10-15 02:20:58 -0700 | [diff] [blame] | 75 | int uclass_postp; |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 76 | }; |
| 77 | |
Simon Glass | c7b4b83 | 2021-02-03 06:01:20 -0700 | [diff] [blame] | 78 | /* struct dm_test_uc_priv - private data for the testdrv uclass */ |
| 79 | struct dm_test_uc_priv { |
| 80 | int dummy; |
| 81 | }; |
| 82 | |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 83 | /** |
| 84 | * struct dm_test_perdev_class_priv - private per-device data for test uclass |
| 85 | */ |
| 86 | struct dm_test_uclass_perdev_priv { |
| 87 | int base_add; |
| 88 | }; |
| 89 | |
| 90 | /** |
| 91 | * struct dm_test_uclass_priv - private data for test uclass |
| 92 | */ |
| 93 | struct dm_test_uclass_priv { |
| 94 | int total_add; |
| 95 | }; |
| 96 | |
Simon Glass | 60d971b | 2014-07-23 06:55:20 -0600 | [diff] [blame] | 97 | /** |
Simon Glass | e330447 | 2022-05-08 04:39:23 -0600 | [diff] [blame] | 98 | * struct dm_test_uclass_plat - private plat data for test uclass |
| 99 | */ |
| 100 | struct dm_test_uclass_plat { |
| 101 | char dummy[32]; |
| 102 | }; |
| 103 | |
| 104 | /** |
Simon Glass | 60d971b | 2014-07-23 06:55:20 -0600 | [diff] [blame] | 105 | * struct dm_test_parent_data - parent's information on each child |
| 106 | * |
| 107 | * @sum: Test value used to check parent data works correctly |
Simon Glass | d45560d | 2014-07-23 06:55:21 -0600 | [diff] [blame] | 108 | * @flag: Used to track calling of parent operations |
Simon Glass | 5104b98 | 2015-01-25 08:27:10 -0700 | [diff] [blame] | 109 | * @uclass_flag: Used to track calling of parent operations by uclass |
Simon Glass | 60d971b | 2014-07-23 06:55:20 -0600 | [diff] [blame] | 110 | */ |
| 111 | struct dm_test_parent_data { |
| 112 | int sum; |
Simon Glass | d45560d | 2014-07-23 06:55:21 -0600 | [diff] [blame] | 113 | int flag; |
Simon Glass | 60d971b | 2014-07-23 06:55:20 -0600 | [diff] [blame] | 114 | }; |
| 115 | |
Przemyslaw Marczak | 34cbe31 | 2015-04-15 13:07:19 +0200 | [diff] [blame] | 116 | /* Test values for test device's uclass platform data */ |
| 117 | enum { |
| 118 | TEST_UC_PDATA_INTVAL1 = 2, |
| 119 | TEST_UC_PDATA_INTVAL2 = 334, |
| 120 | TEST_UC_PDATA_INTVAL3 = 789452, |
| 121 | }; |
| 122 | |
| 123 | /** |
| 124 | * struct dm_test_uclass_platda - uclass's information on each device |
| 125 | * |
| 126 | * @intval1: set to TEST_UC_PDATA_INTVAL1 in .post_bind method of test uclass |
| 127 | * @intval2: set to TEST_UC_PDATA_INTVAL2 in .post_bind method of test uclass |
| 128 | * @intval3: set to TEST_UC_PDATA_INTVAL3 in .post_bind method of test uclass |
| 129 | */ |
| 130 | struct dm_test_perdev_uc_pdata { |
| 131 | int intval1; |
| 132 | int intval2; |
| 133 | int intval3; |
| 134 | }; |
| 135 | |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 136 | /* |
| 137 | * Operation counts for the test driver, used to check that each method is |
| 138 | * called correctly |
| 139 | */ |
| 140 | extern int dm_testdrv_op_count[DM_TEST_OP_COUNT]; |
| 141 | |
Joe Hershberger | 3a77be5 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 142 | extern struct unit_test_state global_dm_test_state; |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 143 | |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 144 | /* Declare a new driver model test */ |
Simon Glass | ab1fca0 | 2021-03-07 17:34:45 -0700 | [diff] [blame] | 145 | #define DM_TEST(_name, _flags) \ |
Simon Glass | 11fcfa3 | 2024-08-22 07:57:50 -0600 | [diff] [blame] | 146 | UNIT_TEST(_name, UTF_DM | UTF_CONSOLE | (_flags), dm_test) |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 147 | |
Simon Glass | 4425bf4 | 2020-07-02 21:12:28 -0600 | [diff] [blame] | 148 | /* |
| 149 | * struct sandbox_sdl_plat - Platform data for the SDL video driver |
| 150 | * |
| 151 | * This platform data is needed in tests, so declare it here |
| 152 | * |
| 153 | * @xres: Width of display in pixels |
| 154 | * @yres: Height of display in pixels |
| 155 | * @bpix: Log2 of bits per pixel (enum video_log2_bpp) |
| 156 | * @rot: Console rotation (0=normal orientation, 1=90 degrees clockwise, |
| 157 | * 2=upside down, 3=90 degree counterclockwise) |
| 158 | * @vidconsole_drv_name: Name of video console driver (set by tests) |
| 159 | * @font_size: Console font size to select (set by tests) |
| 160 | */ |
Simon Glass | 90b6fef | 2016-01-18 19:52:26 -0700 | [diff] [blame] | 161 | struct sandbox_sdl_plat { |
| 162 | int xres; |
| 163 | int yres; |
| 164 | int bpix; |
| 165 | int rot; |
Simon Glass | 69f617f | 2016-01-14 18:10:49 -0700 | [diff] [blame] | 166 | const char *vidconsole_drv_name; |
| 167 | int font_size; |
Simon Glass | 90b6fef | 2016-01-18 19:52:26 -0700 | [diff] [blame] | 168 | }; |
| 169 | |
Simon Glass | 4bf8972 | 2020-12-23 08:11:18 -0700 | [diff] [blame] | 170 | /** |
| 171 | * struct dm_test_parent_plat - Used to track state in bus tests |
| 172 | * |
| 173 | * @count: |
| 174 | * @bind_flag: Indicates that the child post-bind method was called |
| 175 | * @uclass_bind_flag: Also indicates that the child post-bind method was called |
| 176 | */ |
| 177 | struct dm_test_parent_plat { |
| 178 | int count; |
| 179 | int bind_flag; |
| 180 | int uclass_bind_flag; |
| 181 | }; |
| 182 | |
| 183 | enum { |
| 184 | TEST_FLAG_CHILD_PROBED = 10, |
| 185 | TEST_FLAG_CHILD_REMOVED = -7, |
| 186 | }; |
| 187 | |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 188 | /* Declare ping methods for the drivers */ |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 189 | int test_ping(struct udevice *dev, int pingval, int *pingret); |
| 190 | int testfdt_ping(struct udevice *dev, int pingval, int *pingret); |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 191 | |
| 192 | /** |
| 193 | * dm_check_operations() - Check that we can perform ping operations |
| 194 | * |
| 195 | * This checks that the ping operations work as expected for a device |
| 196 | * |
| 197 | * @dms: Overall test state |
| 198 | * @dev: Device to test |
| 199 | * @base: Base address, used to check ping return value |
| 200 | * @priv: Pointer to private test information |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 201 | * Return: 0 if OK, -ve on error |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 202 | */ |
Joe Hershberger | 3a77be5 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 203 | int dm_check_operations(struct unit_test_state *uts, struct udevice *dev, |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 204 | uint32_t base, struct dm_test_priv *priv); |
| 205 | |
| 206 | /** |
Simon Glass | 4071742 | 2014-07-23 06:55:18 -0600 | [diff] [blame] | 207 | * dm_check_devices() - check the devices respond to operations correctly |
| 208 | * |
| 209 | * @dms: Overall test state |
| 210 | * @num_devices: Number of test devices to check |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 211 | * Return: 0 if OK, -ve on error |
Simon Glass | 4071742 | 2014-07-23 06:55:18 -0600 | [diff] [blame] | 212 | */ |
Joe Hershberger | 3a77be5 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 213 | int dm_check_devices(struct unit_test_state *uts, int num_devices); |
Simon Glass | 4071742 | 2014-07-23 06:55:18 -0600 | [diff] [blame] | 214 | |
| 215 | /** |
Simon Glass | 0927a6f | 2014-10-04 11:29:50 -0600 | [diff] [blame] | 216 | * dm_leak_check_start() - Prepare to check for a memory leak |
| 217 | * |
| 218 | * Call this before allocating memory to record the amount of memory being |
| 219 | * used. |
| 220 | * |
| 221 | * @dms: Overall test state |
| 222 | */ |
Joe Hershberger | 3a77be5 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 223 | void dm_leak_check_start(struct unit_test_state *uts); |
Simon Glass | 0927a6f | 2014-10-04 11:29:50 -0600 | [diff] [blame] | 224 | |
| 225 | /** |
| 226 | * dm_leak_check_end() - Check that no memory has leaked |
| 227 | * |
| 228 | * Call this after dm_leak_check_start() and after you have hopefuilly freed |
| 229 | * all the memory that was allocated. This function will print an error if |
| 230 | * it sees a different amount of total memory allocated than before. |
| 231 | * |
| 232 | * @dms: Overall test state |
Joe Hershberger | 3a77be5 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 233 | */int dm_leak_check_end(struct unit_test_state *uts); |
Simon Glass | 0927a6f | 2014-10-04 11:29:50 -0600 | [diff] [blame] | 234 | |
Simon Glass | b2c1cac | 2014-02-26 15:59:21 -0700 | [diff] [blame] | 235 | #endif |