test/dm/test-driver.c

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