git.sur5r.net Git - u-boot/blob - test/dm/test-driver.c

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