git.sur5r.net Git - u-boot/blob - test/dm/test-uclass.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 <malloc.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <asm/io.h>
  14 #include <dm/test.h>
  15 #include <linux/list.h>
  16 #include <test/ut.h>
  17
  18 static struct unit_test_state *uts = &global_dm_test_state;
  19
  20 int test_ping(struct udevice *dev, int pingval, int *pingret)
  21 {
  22         const struct test_ops *ops = device_get_ops(dev);
  23
  24         if (!ops->ping)
  25                 return -ENOSYS;
  26
  27         return ops->ping(dev, pingval, pingret);
  28 }
  29
  30 static int test_post_bind(struct udevice *dev)
  31 {
  32         struct dm_test_perdev_uc_pdata *uc_pdata;
  33
  34         dm_testdrv_op_count[DM_TEST_OP_POST_BIND]++;
  35         ut_assert(!device_active(dev));
  36
  37         uc_pdata = dev_get_uclass_platdata(dev);
  38         ut_assert(uc_pdata);
  39
  40         uc_pdata->intval1 = TEST_UC_PDATA_INTVAL1;
  41         uc_pdata->intval2 = TEST_UC_PDATA_INTVAL2;
  42         uc_pdata->intval3 = TEST_UC_PDATA_INTVAL3;
  43
  44         return 0;
  45 }
  46
  47 static int test_pre_unbind(struct udevice *dev)
  48 {
  49         dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]++;
  50
  51         return 0;
  52 }
  53
  54 static int test_pre_probe(struct udevice *dev)
  55 {
  56         struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
  57
  58         dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]++;
  59         ut_assert(priv);
  60         ut_assert(device_active(dev));
  61
  62         return 0;
  63 }
  64
  65 static int test_post_probe(struct udevice *dev)
  66 {
  67         struct udevice *prev = list_entry(dev->uclass_node.prev,
  68                                             struct udevice, uclass_node);
  69
  70         struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
  71         struct uclass *uc = dev->uclass;
  72         struct dm_test_state *dms = uts->priv;
  73
  74         dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]++;
  75         ut_assert(priv);
  76         ut_assert(device_active(dev));
  77         priv->base_add = 0;
  78         if (dms->skip_post_probe)
  79                 return 0;
  80         if (&prev->uclass_node != &uc->dev_head) {
  81                 struct dm_test_uclass_perdev_priv *prev_uc_priv
  82                                 = dev_get_uclass_priv(prev);
  83                 struct dm_test_pdata *pdata = prev->platdata;
  84
  85                 ut_assert(pdata);
  86                 ut_assert(prev_uc_priv);
  87                 priv->base_add = prev_uc_priv->base_add + pdata->ping_add;
  88         }
  89
  90         return 0;
  91 }
  92
  93 static int test_pre_remove(struct udevice *dev)
  94 {
  95         dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]++;
  96
  97         return 0;
  98 }
  99
 100 static int test_init(struct uclass *uc)
 101 {
 102         dm_testdrv_op_count[DM_TEST_OP_INIT]++;
 103         ut_assert(uc->priv);
 104
 105         return 0;
 106 }
 107
 108 static int test_destroy(struct uclass *uc)
 109 {
 110         dm_testdrv_op_count[DM_TEST_OP_DESTROY]++;
 111
 112         return 0;
 113 }
 114
 115 UCLASS_DRIVER(test) = {
 116         .name           = "test",
 117         .id             = UCLASS_TEST,
 118         .post_bind      = test_post_bind,
 119         .pre_unbind     = test_pre_unbind,
 120         .pre_probe      = test_pre_probe,
 121         .post_probe     = test_post_probe,
 122         .pre_remove     = test_pre_remove,
 123         .init           = test_init,
 124         .destroy        = test_destroy,
 125         .priv_auto_alloc_size   = sizeof(struct dm_test_uclass_priv),
 126         .per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv),
 127         .per_device_platdata_auto_alloc_size =
 128                                         sizeof(struct dm_test_perdev_uc_pdata),
 129 };