test/dm/clk.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  */
   5
   6 #include <clk.h>
   7 #include <dm.h>
   8 #include <log.h>
   9 #include <malloc.h>
  10 #include <asm/clk.h>
  11 #include <dm/test.h>
  12 #include <dm/device-internal.h>
  13 #include <linux/err.h>
  14 #include <test/test.h>
  15 #include <test/ut.h>
  16
  17 /* Base test of the clk uclass */
  18 static int dm_test_clk_base(struct unit_test_state *uts)
  19 {
  20         struct udevice *dev;
  21         struct clk clk_method1;
  22         struct clk clk_method2;
  23
  24         /* Get the device using the clk device */
  25         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test", &dev));
  26
  27         /* Get the same clk port in 2 different ways and compare */
  28         ut_assertok(clk_get_by_index(dev, 0, &clk_method1));
  29         ut_assertok(clk_get_by_name(dev, NULL, &clk_method2));
  30         ut_asserteq(clk_is_match(&clk_method1, &clk_method2), true);
  31         ut_asserteq(clk_method1.id, clk_method2.id);
  32
  33         ut_assertok(clk_get_by_index(dev, 1, &clk_method1));
  34         ut_assertok(clk_get_by_index_nodev(dev_ofnode(dev), 1, &clk_method2));
  35         ut_asserteq(clk_is_match(&clk_method1, &clk_method2), true);
  36         ut_asserteq(clk_method1.id, clk_method2.id);
  37
  38         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test2", &dev));
  39         ut_assertok(clk_set_defaults(dev, CLK_DEFAULTS_PRE));
  40
  41         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test3", &dev));
  42         ut_assertok(clk_set_defaults(dev, CLK_DEFAULTS_PRE));
  43
  44         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test4", &dev));
  45         ut_assertok(clk_set_defaults(dev, CLK_DEFAULTS_PRE));
  46
  47         return 0;
  48 }
  49 DM_TEST(dm_test_clk_base, UTF_SCAN_FDT);
  50
  51 static int dm_test_clk(struct unit_test_state *uts)
  52 {
  53         struct udevice *dev_fixed, *dev_fixed_factor, *dev_clk, *dev_test;
  54         ulong rate;
  55
  56         ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-fixed",
  57                                               &dev_fixed));
  58
  59         ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-fixed-factor",
  60                                               &dev_fixed_factor));
  61
  62         ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-sbox",
  63                                               &dev_clk));
  64         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
  65         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
  66         ut_asserteq(0, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_SPI));
  67         ut_asserteq(0, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_I2C));
  68
  69         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test",
  70                                               &dev_test));
  71         ut_assertok(sandbox_clk_test_get(dev_test));
  72         ut_assertok(sandbox_clk_test_devm_get(dev_test));
  73         ut_assertok(sandbox_clk_test_valid(dev_test));
  74
  75         ut_asserteq(0, sandbox_clk_test_get_rate(dev_test,
  76                                                  SANDBOX_CLK_TEST_ID_DEVM_NULL));
  77         ut_asserteq(0, sandbox_clk_test_set_rate(dev_test,
  78                                                  SANDBOX_CLK_TEST_ID_DEVM_NULL,
  79                                                  0));
  80         ut_asserteq(0, sandbox_clk_test_enable(dev_test,
  81                                                SANDBOX_CLK_TEST_ID_DEVM_NULL));
  82         ut_asserteq(0, sandbox_clk_test_disable(dev_test,
  83                                                 SANDBOX_CLK_TEST_ID_DEVM_NULL));
  84
  85         ut_asserteq(1234,
  86                     sandbox_clk_test_get_rate(dev_test,
  87                                               SANDBOX_CLK_TEST_ID_FIXED));
  88         ut_asserteq(0, sandbox_clk_test_get_rate(dev_test,
  89                                                  SANDBOX_CLK_TEST_ID_SPI));
  90         ut_asserteq(0, sandbox_clk_test_get_rate(dev_test,
  91                                                  SANDBOX_CLK_TEST_ID_I2C));
  92         ut_asserteq(321, sandbox_clk_test_get_rate(dev_test,
  93                                                    SANDBOX_CLK_TEST_ID_DEVM1));
  94         ut_asserteq(0, sandbox_clk_test_get_rate(dev_test,
  95                                                  SANDBOX_CLK_TEST_ID_DEVM2));
  96
  97         rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED,
  98                                          12345);
  99         ut_assert(IS_ERR_VALUE(rate));
 100         rate = sandbox_clk_test_get_rate(dev_test, SANDBOX_CLK_TEST_ID_FIXED);
 101         ut_asserteq(1234, rate);
 102
 103         ut_asserteq(0, sandbox_clk_test_set_rate(dev_test,
 104                                                  SANDBOX_CLK_TEST_ID_SPI,
 105                                                  1000));
 106         ut_asserteq(0, sandbox_clk_test_set_rate(dev_test,
 107                                                  SANDBOX_CLK_TEST_ID_I2C,
 108                                                  2000));
 109
 110         ut_asserteq(1000, sandbox_clk_test_get_rate(dev_test,
 111                                                     SANDBOX_CLK_TEST_ID_SPI));
 112         ut_asserteq(2000, sandbox_clk_test_get_rate(dev_test,
 113                                                     SANDBOX_CLK_TEST_ID_I2C));
 114
 115         ut_asserteq(1000, sandbox_clk_test_set_rate(dev_test,
 116                                                     SANDBOX_CLK_TEST_ID_SPI,
 117                                                     10000));
 118         ut_asserteq(2000, sandbox_clk_test_set_rate(dev_test,
 119                                                     SANDBOX_CLK_TEST_ID_I2C,
 120                                                     20000));
 121
 122         rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI, 0);
 123         ut_assert(IS_ERR_VALUE(rate));
 124         rate = sandbox_clk_test_set_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C, 0);
 125         ut_assert(IS_ERR_VALUE(rate));
 126
 127         ut_asserteq(10000, sandbox_clk_test_get_rate(dev_test,
 128                                                      SANDBOX_CLK_TEST_ID_SPI));
 129         ut_asserteq(20000, sandbox_clk_test_get_rate(dev_test,
 130                                                      SANDBOX_CLK_TEST_ID_I2C));
 131
 132         ut_asserteq(5000, sandbox_clk_test_round_rate(dev_test,
 133                                                       SANDBOX_CLK_TEST_ID_SPI,
 134                                                       5000));
 135         ut_asserteq(7000, sandbox_clk_test_round_rate(dev_test,
 136                                                       SANDBOX_CLK_TEST_ID_I2C,
 137                                                       7000));
 138
 139         ut_asserteq(10000, sandbox_clk_test_get_rate(dev_test,
 140                                                      SANDBOX_CLK_TEST_ID_SPI));
 141         ut_asserteq(20000, sandbox_clk_test_get_rate(dev_test,
 142                                                      SANDBOX_CLK_TEST_ID_I2C));
 143
 144         rate = sandbox_clk_test_round_rate(dev_test, SANDBOX_CLK_TEST_ID_SPI, 0);
 145         ut_assert(IS_ERR_VALUE(rate));
 146         rate = sandbox_clk_test_round_rate(dev_test, SANDBOX_CLK_TEST_ID_I2C, 0);
 147         ut_assert(IS_ERR_VALUE(rate));
 148
 149         ut_asserteq(10000, sandbox_clk_test_get_rate(dev_test,
 150                                                      SANDBOX_CLK_TEST_ID_SPI));
 151         ut_asserteq(20000, sandbox_clk_test_get_rate(dev_test,
 152                                                      SANDBOX_CLK_TEST_ID_I2C));
 153
 154         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 155         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 156         ut_asserteq(10000, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_SPI));
 157         ut_asserteq(20000, sandbox_clk_query_rate(dev_clk, SANDBOX_CLK_ID_I2C));
 158
 159         ut_assertok(sandbox_clk_test_enable(dev_test, SANDBOX_CLK_TEST_ID_SPI));
 160         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 161         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 162
 163         ut_assertok(sandbox_clk_test_enable(dev_test, SANDBOX_CLK_TEST_ID_I2C));
 164         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 165         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 166
 167         ut_assertok(sandbox_clk_test_disable(dev_test,
 168                                              SANDBOX_CLK_TEST_ID_SPI));
 169         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 170         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 171
 172         ut_assertok(sandbox_clk_test_disable(dev_test,
 173                                              SANDBOX_CLK_TEST_ID_I2C));
 174         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 175         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 176
 177         ut_asserteq(1, sandbox_clk_query_requested(dev_clk,
 178                                                    SANDBOX_CLK_ID_SPI));
 179         ut_asserteq(1, sandbox_clk_query_requested(dev_clk,
 180                                                    SANDBOX_CLK_ID_I2C));
 181         ut_asserteq(1, sandbox_clk_query_requested(dev_clk,
 182                                                    SANDBOX_CLK_ID_UART2));
 183
 184         ut_asserteq(1, sandbox_clk_query_requested(dev_clk,
 185                                                    SANDBOX_CLK_ID_UART1));
 186         ut_assertok(device_remove(dev_test, DM_REMOVE_NORMAL));
 187         return 0;
 188 }
 189 DM_TEST(dm_test_clk, UTF_SCAN_FDT);
 190
 191 static int dm_test_clk_bulk(struct unit_test_state *uts)
 192 {
 193         struct udevice *dev_clk, *dev_test;
 194
 195         ut_assertok(uclass_get_device_by_name(UCLASS_CLK, "clk-sbox",
 196                                               &dev_clk));
 197         ut_assertok(uclass_get_device_by_name(UCLASS_MISC, "clk-test",
 198                                               &dev_test));
 199         ut_assertok(sandbox_clk_test_get_bulk(dev_test));
 200
 201         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 202         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 203
 204         /* Fixed clock does not support enable, thus should not fail */
 205         ut_assertok(sandbox_clk_test_enable_bulk(dev_test));
 206         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 207         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 208
 209         /* Fixed clock does not support disable, thus should not fail */
 210         ut_assertok(sandbox_clk_test_disable_bulk(dev_test));
 211         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 212         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 213
 214         /* Fixed clock does not support enable, thus should not fail */
 215         ut_assertok(sandbox_clk_test_enable_bulk(dev_test));
 216         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 217         ut_asserteq(1, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 218
 219         /* Fixed clock does not support disable, thus should not fail */
 220         ut_assertok(sandbox_clk_test_release_bulk(dev_test));
 221         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_SPI));
 222         ut_asserteq(0, sandbox_clk_query_enable(dev_clk, SANDBOX_CLK_ID_I2C));
 223         ut_assertok(device_remove(dev_test, DM_REMOVE_NORMAL));
 224
 225         return 0;
 226 }
 227 DM_TEST(dm_test_clk_bulk, UTF_SCAN_FDT);