arch/powerpc/platforms/powernv/vas.c

   1 /*
   2  * Copyright 2016-17 IBM Corp.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version
   7  * 2 of the License, or (at your option) any later version.
   8  */
   9
  10 #define pr_fmt(fmt) "vas: " fmt
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/export.h>
  15 #include <linux/types.h>
  16 #include <linux/slab.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/of_platform.h>
  19 #include <linux/of_address.h>
  20 #include <linux/of.h>
  21
  22 #include "vas.h"
  23
  24 static DEFINE_MUTEX(vas_mutex);
  25 static LIST_HEAD(vas_instances);
  26
  27 static int init_vas_instance(struct platform_device *pdev)
  28 {
  29         int rc, vasid;
  30         struct resource *res;
  31         struct vas_instance *vinst;
  32         struct device_node *dn = pdev->dev.of_node;
  33
  34         rc = of_property_read_u32(dn, "ibm,vas-id", &vasid);
  35         if (rc) {
  36                 pr_err("No ibm,vas-id property for %s?\n", pdev->name);
  37                 return -ENODEV;
  38         }
  39
  40         if (pdev->num_resources != 4) {
  41                 pr_err("Unexpected DT configuration for [%s, %d]\n",
  42                                 pdev->name, vasid);
  43                 return -ENODEV;
  44         }
  45
  46         vinst = kzalloc(sizeof(*vinst), GFP_KERNEL);
  47         if (!vinst)
  48                 return -ENOMEM;
  49
  50         INIT_LIST_HEAD(&vinst->node);
  51         ida_init(&vinst->ida);
  52         mutex_init(&vinst->mutex);
  53         vinst->vas_id = vasid;
  54         vinst->pdev = pdev;
  55
  56         res = &pdev->resource[0];
  57         vinst->hvwc_bar_start = res->start;
  58
  59         res = &pdev->resource[1];
  60         vinst->uwc_bar_start = res->start;
  61
  62         res = &pdev->resource[2];
  63         vinst->paste_base_addr = res->start;
  64
  65         res = &pdev->resource[3];
  66         if (res->end > 62) {
  67                 pr_err("Bad 'paste_win_id_shift' in DT, %llx\n", res->end);
  68                 goto free_vinst;
  69         }
  70
  71         vinst->paste_win_id_shift = 63 - res->end;
  72
  73         pr_devel("Initialized instance [%s, %d], paste_base 0x%llx, "
  74                         "paste_win_id_shift 0x%llx\n", pdev->name, vasid,
  75                         vinst->paste_base_addr, vinst->paste_win_id_shift);
  76
  77         mutex_lock(&vas_mutex);
  78         list_add(&vinst->node, &vas_instances);
  79         mutex_unlock(&vas_mutex);
  80
  81         dev_set_drvdata(&pdev->dev, vinst);
  82
  83         return 0;
  84
  85 free_vinst:
  86         kfree(vinst);
  87         return -ENODEV;
  88
  89 }
  90
  91 /*
  92  * Although this is read/used multiple times, it is written to only
  93  * during initialization.
  94  */
  95 struct vas_instance *find_vas_instance(int vasid)
  96 {
  97         struct list_head *ent;
  98         struct vas_instance *vinst;
  99
 100         mutex_lock(&vas_mutex);
 101         list_for_each(ent, &vas_instances) {
 102                 vinst = list_entry(ent, struct vas_instance, node);
 103                 if (vinst->vas_id == vasid) {
 104                         mutex_unlock(&vas_mutex);
 105                         return vinst;
 106                 }
 107         }
 108         mutex_unlock(&vas_mutex);
 109
 110         pr_devel("Instance %d not found\n", vasid);
 111         return NULL;
 112 }
 113
 114 static int vas_probe(struct platform_device *pdev)
 115 {
 116         return init_vas_instance(pdev);
 117 }
 118
 119 static const struct of_device_id powernv_vas_match[] = {
 120         { .compatible = "ibm,vas",},
 121         {},
 122 };
 123
 124 static struct platform_driver vas_driver = {
 125         .driver = {
 126                 .name = "vas",
 127                 .of_match_table = powernv_vas_match,
 128         },
 129         .probe = vas_probe,
 130 };
 131
 132 static int __init vas_init(void)
 133 {
 134         int found = 0;
 135         struct device_node *dn;
 136
 137         platform_driver_register(&vas_driver);
 138
 139         for_each_compatible_node(dn, NULL, "ibm,vas") {
 140                 of_platform_device_create(dn, NULL, NULL);
 141                 found++;
 142         }
 143
 144         if (!found)
 145                 return -ENODEV;
 146
 147         pr_devel("Found %d instances\n", found);
 148
 149         return 0;
 150 }
 151 device_initcall(vas_init);