drivers/cpu/cpu-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_CPU
   8
   9 #include <common.h>
  10 #include <cpu.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <log.h>
  14 #include <dm/lists.h>
  15 #include <dm/root.h>
  16 #include <linux/err.h>
  17
  18 int cpu_probe_all(void)
  19 {
  20         struct udevice *cpu;
  21         int ret;
  22
  23         ret = uclass_first_device(UCLASS_CPU, &cpu);
  24         if (ret) {
  25                 debug("%s: No CPU found (err = %d)\n", __func__, ret);
  26                 return ret;
  27         }
  28
  29         while (cpu) {
  30                 ret = uclass_next_device(&cpu);
  31                 if (ret) {
  32                         debug("%s: Error while probing CPU (err = %d)\n",
  33                               __func__, ret);
  34                         return ret;
  35                 }
  36         }
  37
  38         return 0;
  39 }
  40
  41 int cpu_is_current(struct udevice *cpu)
  42 {
  43         struct cpu_ops *ops = cpu_get_ops(cpu);
  44
  45         if (ops->is_current) {
  46                 if (ops->is_current(cpu))
  47                         return 1;
  48         }
  49
  50         return -ENOSYS;
  51 }
  52
  53 struct udevice *cpu_get_current_dev(void)
  54 {
  55         struct udevice *cpu;
  56         int ret;
  57
  58         uclass_foreach_dev_probe(UCLASS_CPU, cpu) {
  59                 if (cpu_is_current(cpu) > 0)
  60                         return cpu;
  61         }
  62
  63         /* If can't find current cpu device, use the first dev instead */
  64         ret = uclass_first_device_err(UCLASS_CPU, &cpu);
  65         if (ret) {
  66                 debug("%s: Could not get CPU device (err = %d)\n",
  67                       __func__, ret);
  68                 return NULL;
  69         }
  70
  71         return cpu;
  72 }
  73
  74 int cpu_get_desc(const struct udevice *dev, char *buf, int size)
  75 {
  76         struct cpu_ops *ops = cpu_get_ops(dev);
  77
  78         if (!ops->get_desc)
  79                 return -ENOSYS;
  80
  81         return ops->get_desc(dev, buf, size);
  82 }
  83
  84 int cpu_get_info(const struct udevice *dev, struct cpu_info *info)
  85 {
  86         struct cpu_ops *ops = cpu_get_ops(dev);
  87
  88         if (!ops->get_info)
  89                 return -ENOSYS;
  90
  91         /* Init cpu_info to 0 */
  92         memset(info, 0, sizeof(struct cpu_info));
  93
  94         return ops->get_info(dev, info);
  95 }
  96
  97 int cpu_get_count(const struct udevice *dev)
  98 {
  99         struct cpu_ops *ops = cpu_get_ops(dev);
 100
 101         if (!ops->get_count)
 102                 return -ENOSYS;
 103
 104         return ops->get_count(dev);
 105 }
 106
 107 int cpu_get_vendor(const struct udevice *dev, char *buf, int size)
 108 {
 109         struct cpu_ops *ops = cpu_get_ops(dev);
 110
 111         if (!ops->get_vendor)
 112                 return -ENOSYS;
 113
 114         return ops->get_vendor(dev, buf, size);
 115 }
 116
 117 U_BOOT_DRIVER(cpu_bus) = {
 118         .name   = "cpu_bus",
 119         .id     = UCLASS_SIMPLE_BUS,
 120         .per_child_plat_auto    = sizeof(struct cpu_plat),
 121 };
 122
 123 static int uclass_cpu_init(struct uclass *uc)
 124 {
 125         struct udevice *dev;
 126         ofnode node;
 127         int ret;
 128
 129         node = ofnode_path("/cpus");
 130         if (!ofnode_valid(node))
 131                 return 0;
 132
 133         ret = device_bind_driver_to_node(dm_root(), "cpu_bus", "cpus", node,
 134                                          &dev);
 135
 136         return ret;
 137 }
 138
 139 UCLASS_DRIVER(cpu) = {
 140         .id             = UCLASS_CPU,
 141         .name           = "cpu",
 142         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 143         .init           = uclass_cpu_init,
 144 };