drivers/mcb/mcb-parse.c

   1 #include <linux/types.h>
   2 #include <linux/ioport.h>
   3 #include <linux/slab.h>
   4 #include <linux/export.h>
   5 #include <linux/io.h>
   6 #include <linux/mcb.h>
   7
   8 #include "mcb-internal.h"
   9
  10 struct mcb_parse_priv {
  11         phys_addr_t mapbase;
  12         void __iomem *base;
  13 };
  14
  15 #define for_each_chameleon_cell(dtype, p)       \
  16         for ((dtype) = get_next_dtype((p));     \
  17              (dtype) != CHAMELEON_DTYPE_END;    \
  18              (dtype) = get_next_dtype((p)))
  19
  20 static inline uint32_t get_next_dtype(void __iomem *p)
  21 {
  22         uint32_t dtype;
  23
  24         dtype = readl(p);
  25         return dtype >> 28;
  26 }
  27
  28 static int chameleon_parse_bdd(struct mcb_bus *bus,
  29                         phys_addr_t mapbase,
  30                         void __iomem *base)
  31 {
  32         return 0;
  33 }
  34
  35 static int chameleon_parse_gdd(struct mcb_bus *bus,
  36                         phys_addr_t mapbase,
  37                         void __iomem *base)
  38 {
  39         struct chameleon_gdd __iomem *gdd =
  40                 (struct chameleon_gdd __iomem *) base;
  41         struct mcb_device *mdev;
  42         u32 offset;
  43         u32 size;
  44         int ret;
  45         __le32 reg1;
  46         __le32 reg2;
  47
  48         mdev = mcb_alloc_dev(bus);
  49         if (!mdev)
  50                 return -ENOMEM;
  51
  52         reg1 = readl(&gdd->reg1);
  53         reg2 = readl(&gdd->reg2);
  54         offset = readl(&gdd->offset);
  55         size = readl(&gdd->size);
  56
  57         mdev->id = GDD_DEV(reg1);
  58         mdev->rev = GDD_REV(reg1);
  59         mdev->var = GDD_VAR(reg1);
  60         mdev->bar = GDD_BAR(reg1);
  61         mdev->group = GDD_GRP(reg2);
  62         mdev->inst = GDD_INS(reg2);
  63
  64         pr_debug("Found a 16z%03d\n", mdev->id);
  65
  66         mdev->irq.start = GDD_IRQ(reg1);
  67         mdev->irq.end = GDD_IRQ(reg1);
  68         mdev->irq.flags = IORESOURCE_IRQ;
  69
  70         mdev->mem.start = mapbase + offset;
  71         mdev->mem.end = mdev->mem.start + size - 1;
  72         mdev->mem.flags = IORESOURCE_MEM;
  73
  74         mdev->is_added = false;
  75
  76         ret = mcb_device_register(bus, mdev);
  77         if (ret < 0)
  78                 goto err;
  79
  80         return 0;
  81
  82 err:
  83         mcb_free_dev(mdev);
  84
  85         return ret;
  86 }
  87
  88 int chameleon_parse_cells(struct mcb_bus *bus, phys_addr_t mapbase,
  89                         void __iomem *base)
  90 {
  91         char __iomem *p = base;
  92         struct chameleon_fpga_header *header;
  93         uint32_t dtype;
  94         int num_cells = 0;
  95         int ret = 0;
  96         u32 hsize;
  97
  98         hsize = sizeof(struct chameleon_fpga_header);
  99
 100         header = kzalloc(hsize, GFP_KERNEL);
 101         if (!header)
 102                 return -ENOMEM;
 103
 104         /* Extract header information */
 105         memcpy_fromio(header, p, hsize);
 106         /* We only support chameleon v2 at the moment */
 107         header->magic = le16_to_cpu(header->magic);
 108         if (header->magic != CHAMELEONV2_MAGIC) {
 109                 pr_err("Unsupported chameleon version 0x%x\n",
 110                                 header->magic);
 111                 kfree(header);
 112                 return -ENODEV;
 113         }
 114         p += hsize;
 115
 116         pr_debug("header->revision = %d\n", header->revision);
 117         pr_debug("header->model = 0x%x ('%c')\n", header->model,
 118                 header->model);
 119         pr_debug("header->minor = %d\n", header->minor);
 120         pr_debug("header->bus_type = 0x%x\n", header->bus_type);
 121
 122
 123         pr_debug("header->magic = 0x%x\n", header->magic);
 124         pr_debug("header->filename = \"%.*s\"\n", CHAMELEON_FILENAME_LEN,
 125                 header->filename);
 126
 127         for_each_chameleon_cell(dtype, p) {
 128                 switch (dtype) {
 129                 case CHAMELEON_DTYPE_GENERAL:
 130                         ret = chameleon_parse_gdd(bus, mapbase, p);
 131                         if (ret < 0)
 132                                 goto out;
 133                         p += sizeof(struct chameleon_gdd);
 134                         break;
 135                 case CHAMELEON_DTYPE_BRIDGE:
 136                         chameleon_parse_bdd(bus, mapbase, p);
 137                         p += sizeof(struct chameleon_bdd);
 138                         break;
 139                 case CHAMELEON_DTYPE_END:
 140                         break;
 141                 default:
 142                         pr_err("Invalid chameleon descriptor type 0x%x\n",
 143                                 dtype);
 144                         kfree(header);
 145                         return -EINVAL;
 146                 }
 147                 num_cells++;
 148         }
 149
 150         if (num_cells == 0)
 151                 num_cells = -EINVAL;
 152
 153         kfree(header);
 154         return num_cells;
 155
 156 out:
 157         kfree(header);
 158         return ret;
 159 }
 160 EXPORT_SYMBOL_GPL(chameleon_parse_cells);