drivers/staging/board/board.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2014 Magnus Damm
   4  * Copyright (C) 2015 Glider bvba
   5  */
   6
   7 #define pr_fmt(fmt)     "board_staging: "  fmt
   8
   9 #include <linux/clkdev.h>
  10 #include <linux/init.h>
  11 #include <linux/irq.h>
  12 #include <linux/device.h>
  13 #include <linux/kernel.h>
  14 #include <linux/of.h>
  15 #include <linux/of_address.h>
  16 #include <linux/of_irq.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/pm_domain.h>
  19
  20 #include "board.h"
  21
  22 static struct device_node *irqc_node __initdata;
  23 static unsigned int irqc_base __initdata;
  24
  25 static bool find_by_address(u64 base_address)
  26 {
  27         struct device_node *dn = of_find_all_nodes(NULL);
  28         struct resource res;
  29
  30         while (dn) {
  31                 if (!of_address_to_resource(dn, 0, &res)) {
  32                         if (res.start == base_address) {
  33                                 of_node_put(dn);
  34                                 return true;
  35                         }
  36                 }
  37                 dn = of_find_all_nodes(dn);
  38         }
  39
  40         return false;
  41 }
  42
  43 bool __init board_staging_dt_node_available(const struct resource *resource,
  44                                             unsigned int num_resources)
  45 {
  46         unsigned int i;
  47
  48         for (i = 0; i < num_resources; i++) {
  49                 const struct resource *r = resource + i;
  50
  51                 if (resource_type(r) == IORESOURCE_MEM)
  52                         if (find_by_address(r->start))
  53                                 return true; /* DT node available */
  54         }
  55
  56         return false; /* Nothing found */
  57 }
  58
  59 int __init board_staging_gic_setup_xlate(const char *gic_match,
  60                                          unsigned int base)
  61 {
  62         WARN_ON(irqc_node);
  63
  64         irqc_node = of_find_compatible_node(NULL, NULL, gic_match);
  65
  66         WARN_ON(!irqc_node);
  67         if (!irqc_node)
  68                 return -ENOENT;
  69
  70         irqc_base = base;
  71         return 0;
  72 }
  73
  74 static void __init gic_fixup_resource(struct resource *res)
  75 {
  76         struct of_phandle_args irq_data;
  77         unsigned int hwirq = res->start;
  78         unsigned int virq;
  79
  80         if (resource_type(res) != IORESOURCE_IRQ || !irqc_node)
  81                 return;
  82
  83         irq_data.np = irqc_node;
  84         irq_data.args_count = 3;
  85         irq_data.args[0] = 0;
  86         irq_data.args[1] = hwirq - irqc_base;
  87         switch (res->flags &
  88                 (IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE |
  89                  IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL)) {
  90         case IORESOURCE_IRQ_LOWEDGE:
  91                 irq_data.args[2] = IRQ_TYPE_EDGE_FALLING;
  92                 break;
  93         case IORESOURCE_IRQ_HIGHEDGE:
  94                 irq_data.args[2] = IRQ_TYPE_EDGE_RISING;
  95                 break;
  96         case IORESOURCE_IRQ_LOWLEVEL:
  97                 irq_data.args[2] = IRQ_TYPE_LEVEL_LOW;
  98                 break;
  99         case IORESOURCE_IRQ_HIGHLEVEL:
 100         default:
 101                 irq_data.args[2] = IRQ_TYPE_LEVEL_HIGH;
 102                 break;
 103         }
 104
 105         virq = irq_create_of_mapping(&irq_data);
 106         if (WARN_ON(!virq))
 107                 return;
 108
 109         pr_debug("hwirq %u -> virq %u\n", hwirq, virq);
 110         res->start = virq;
 111 }
 112
 113 void __init board_staging_gic_fixup_resources(struct resource *res,
 114                                               unsigned int nres)
 115 {
 116         unsigned int i;
 117
 118         for (i = 0; i < nres; i++)
 119                 gic_fixup_resource(&res[i]);
 120 }
 121
 122 int __init board_staging_register_clock(const struct board_staging_clk *bsc)
 123 {
 124         int error;
 125
 126         pr_debug("Aliasing clock %s for con_id %s dev_id %s\n", bsc->clk,
 127                  bsc->con_id, bsc->dev_id);
 128         error = clk_add_alias(bsc->con_id, bsc->dev_id, bsc->clk, NULL);
 129         if (error)
 130                 pr_err("Failed to alias clock %s (%d)\n", bsc->clk, error);
 131
 132         return error;
 133 }
 134
 135 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
 136 static int board_staging_add_dev_domain(struct platform_device *pdev,
 137                                         const char *domain)
 138 {
 139         struct device *dev = &pdev->dev;
 140         struct of_phandle_args pd_args;
 141         struct device_node *np;
 142
 143         np = of_find_node_by_path(domain);
 144         if (!np) {
 145                 pr_err("Cannot find domain node %s\n", domain);
 146                 return -ENOENT;
 147         }
 148
 149         pd_args.np = np;
 150         pd_args.args_count = 0;
 151
 152         /* Initialization similar to device_pm_init_common() */
 153         spin_lock_init(&dev->power.lock);
 154         dev->power.early_init = true;
 155
 156         return of_genpd_add_device(&pd_args, dev);
 157 }
 158 #else
 159 static inline int board_staging_add_dev_domain(struct platform_device *pdev,
 160                                                const char *domain)
 161 {
 162         return 0;
 163 }
 164 #endif
 165
 166 int __init board_staging_register_device(const struct board_staging_dev *dev)
 167 {
 168         struct platform_device *pdev = dev->pdev;
 169         unsigned int i;
 170         int error;
 171
 172         pr_debug("Trying to register device %s\n", pdev->name);
 173         if (board_staging_dt_node_available(pdev->resource,
 174                                             pdev->num_resources)) {
 175                 pr_warn("Skipping %s, already in DT\n", pdev->name);
 176                 return -EEXIST;
 177         }
 178
 179         board_staging_gic_fixup_resources(pdev->resource, pdev->num_resources);
 180
 181         for (i = 0; i < dev->nclocks; i++)
 182                 board_staging_register_clock(&dev->clocks[i]);
 183
 184         if (dev->domain)
 185                 board_staging_add_dev_domain(pdev, dev->domain);
 186
 187         error = platform_device_register(pdev);
 188         if (error) {
 189                 pr_err("Failed to register device %s (%d)\n", pdev->name,
 190                        error);
 191                 return error;
 192         }
 193
 194         return error;
 195 }
 196
 197 void __init board_staging_register_devices(const struct board_staging_dev *devs,
 198                                            unsigned int ndevs)
 199 {
 200         unsigned int i;
 201
 202         for (i = 0; i < ndevs; i++)
 203                 board_staging_register_device(&devs[i]);
 204 }