drivers/fpga/fpga.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2002
   4  * Rich Ireland, Enterasys Networks, rireland@enterasys.com.
   5  */
   6
   7 /* Generic FPGA support */
   8 #include <common.h>             /* core U-Boot definitions */
   9 #include <xilinx.h>             /* xilinx specific definitions */
  10 #include <altera.h>             /* altera specific definitions */
  11 #include <lattice.h>
  12 #include <dm/device_compat.h>
  13
  14 /* Local definitions */
  15 #ifndef CONFIG_MAX_FPGA_DEVICES
  16 #define CONFIG_MAX_FPGA_DEVICES         5
  17 #endif
  18
  19 /* Local static data */
  20 static int next_desc = FPGA_INVALID_DEVICE;
  21 static fpga_desc desc_table[CONFIG_MAX_FPGA_DEVICES];
  22
  23 /*
  24  * fpga_no_sup
  25  * 'no support' message function
  26  */
  27 static void fpga_no_sup(char *fn, char *msg)
  28 {
  29         if (fn && msg)
  30                 printf("%s: No support for %s.\n", fn, msg);
  31         else if (msg)
  32                 printf("No support for %s.\n", msg);
  33         else
  34                 printf("No FPGA support!\n");
  35 }
  36
  37
  38 /* fpga_get_desc
  39  *      map a device number to a descriptor
  40  */
  41 const fpga_desc *const fpga_get_desc(int devnum)
  42 {
  43         fpga_desc *desc = (fpga_desc *)NULL;
  44
  45         if ((devnum >= 0) && (devnum < next_desc)) {
  46                 desc = &desc_table[devnum];
  47                 debug("%s: found fpga descriptor #%d @ 0x%p\n",
  48                       __func__, devnum, desc);
  49         }
  50
  51         return desc;
  52 }
  53
  54 /*
  55  * fpga_validate
  56  *      generic parameter checking code
  57  */
  58 const fpga_desc *const fpga_validate(int devnum, const void *buf,
  59                                      size_t bsize, char *fn)
  60 {
  61         const fpga_desc *desc = fpga_get_desc(devnum);
  62
  63         if (!desc)
  64                 printf("%s: Invalid device number %d\n", fn, devnum);
  65
  66         if (!buf) {
  67                 printf("%s: Null buffer.\n", fn);
  68                 return (fpga_desc * const)NULL;
  69         }
  70         return desc;
  71 }
  72
  73 /*
  74  * fpga_dev_info
  75  *      generic multiplexing code
  76  */
  77 static int fpga_dev_info(int devnum)
  78 {
  79         int ret_val = FPGA_FAIL; /* assume failure */
  80         const fpga_desc * const desc = fpga_get_desc(devnum);
  81
  82         if (desc) {
  83                 debug("%s: Device Descriptor @ 0x%p\n",
  84                       __func__, desc->devdesc);
  85
  86                 switch (desc->devtype) {
  87                 case fpga_xilinx:
  88 #if defined(CONFIG_FPGA_XILINX)
  89                         printf("Xilinx Device\nDescriptor @ 0x%p\n", desc);
  90                         ret_val = xilinx_info(desc->devdesc);
  91 #else
  92                         fpga_no_sup((char *)__func__, "Xilinx devices");
  93 #endif
  94                         break;
  95                 case fpga_altera:
  96 #if defined(CONFIG_FPGA_ALTERA)
  97                         printf("Altera Device\nDescriptor @ 0x%p\n", desc);
  98                         ret_val = altera_info(desc->devdesc);
  99 #else
 100                         fpga_no_sup((char *)__func__, "Altera devices");
 101 #endif
 102                         break;
 103                 case fpga_lattice:
 104 #if defined(CONFIG_FPGA_LATTICE)
 105                         printf("Lattice Device\nDescriptor @ 0x%p\n", desc);
 106                         ret_val = lattice_info(desc->devdesc);
 107 #else
 108                         fpga_no_sup((char *)__func__, "Lattice devices");
 109 #endif
 110                         break;
 111                 default:
 112                         printf("%s: Invalid or unsupported device type %d\n",
 113                                __func__, desc->devtype);
 114                 }
 115         } else {
 116                 printf("%s: Invalid device number %d\n", __func__, devnum);
 117         }
 118
 119         return ret_val;
 120 }
 121
 122 /*
 123  * fpga_init is usually called from misc_init_r() and MUST be called
 124  * before any of the other fpga functions are used.
 125  */
 126 void fpga_init(void)
 127 {
 128         next_desc = 0;
 129         memset(desc_table, 0, sizeof(desc_table));
 130
 131         debug("%s\n", __func__);
 132 }
 133
 134 /*
 135  * fpga_count
 136  * Basic interface function to get the current number of devices available.
 137  */
 138 int fpga_count(void)
 139 {
 140         return next_desc;
 141 }
 142
 143 /*
 144  * fpga_add
 145  *      Add the device descriptor to the device table.
 146  */
 147 int fpga_add(fpga_type devtype, void *desc)
 148 {
 149         int devnum = FPGA_INVALID_DEVICE;
 150
 151         if (!desc) {
 152                 printf("%s: NULL device descriptor\n", __func__);
 153                 return devnum;
 154         }
 155
 156         if (next_desc < 0) {
 157                 printf("%s: FPGA support not initialized!\n", __func__);
 158         } else if ((devtype > fpga_min_type) && (devtype < fpga_undefined)) {
 159                 if (next_desc < CONFIG_MAX_FPGA_DEVICES) {
 160                         devnum = next_desc;
 161                         desc_table[next_desc].devtype = devtype;
 162                         desc_table[next_desc++].devdesc = desc;
 163                 } else {
 164                         printf("%s: Exceeded Max FPGA device count\n",
 165                                __func__);
 166                 }
 167         } else {
 168                 printf("%s: Unsupported FPGA type %d\n", __func__, devtype);
 169         }
 170
 171         return devnum;
 172 }
 173
 174 /*
 175  * Return 1 if the fpga data is partial.
 176  * This is only required for fpga drivers that support bitstream_type.
 177  */
 178 int __weak fpga_is_partial_data(int devnum, size_t img_len)
 179 {
 180         return 0;
 181 }
 182
 183 /*
 184  * Convert bitstream data and load into the fpga
 185  */
 186 int __weak fpga_loadbitstream(int devnum, char *fpgadata, size_t size,
 187                               bitstream_type bstype)
 188 {
 189         printf("Bitstream support not implemented for this FPGA device\n");
 190         return FPGA_FAIL;
 191 }
 192
 193 #if defined(CONFIG_CMD_FPGA_LOADFS)
 194 int fpga_fsload(int devnum, const void *buf, size_t size,
 195                  fpga_fs_info *fpga_fsinfo)
 196 {
 197         int ret_val = FPGA_FAIL;           /* assume failure */
 198         const fpga_desc *desc = fpga_validate(devnum, buf, size,
 199                                               (char *)__func__);
 200
 201         if (desc) {
 202                 switch (desc->devtype) {
 203                 case fpga_xilinx:
 204 #if defined(CONFIG_FPGA_XILINX)
 205                         ret_val = xilinx_loadfs(desc->devdesc, buf, size,
 206                                                 fpga_fsinfo);
 207 #else
 208                         fpga_no_sup((char *)__func__, "Xilinx devices");
 209 #endif
 210                         break;
 211                 default:
 212                         printf("%s: Invalid or unsupported device type %d\n",
 213                                __func__, desc->devtype);
 214                 }
 215         }
 216
 217         return ret_val;
 218 }
 219 #endif
 220
 221 #if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
 222 int fpga_loads(int devnum, const void *buf, size_t size,
 223                struct fpga_secure_info *fpga_sec_info)
 224 {
 225         int ret_val = FPGA_FAIL;
 226
 227         const fpga_desc *desc = fpga_validate(devnum, buf, size,
 228                                               (char *)__func__);
 229
 230         if (desc) {
 231                 switch (desc->devtype) {
 232                 case fpga_xilinx:
 233 #if defined(CONFIG_FPGA_XILINX)
 234                         ret_val = xilinx_loads(desc->devdesc, buf, size,
 235                                                fpga_sec_info);
 236 #else
 237                         fpga_no_sup((char *)__func__, "Xilinx devices");
 238 #endif
 239                         break;
 240                 default:
 241                         printf("%s: Invalid or unsupported device type %d\n",
 242                                __func__, desc->devtype);
 243                 }
 244         }
 245
 246         return ret_val;
 247 }
 248 #endif
 249
 250 /*
 251  * Generic multiplexing code
 252  */
 253 int fpga_load(int devnum, const void *buf, size_t bsize, bitstream_type bstype)
 254 {
 255         int ret_val = FPGA_FAIL;           /* assume failure */
 256         const fpga_desc *desc = fpga_validate(devnum, buf, bsize,
 257                                               (char *)__func__);
 258
 259         if (desc) {
 260                 switch (desc->devtype) {
 261                 case fpga_xilinx:
 262 #if defined(CONFIG_FPGA_XILINX)
 263                         ret_val = xilinx_load(desc->devdesc, buf, bsize,
 264                                               bstype);
 265 #else
 266                         fpga_no_sup((char *)__func__, "Xilinx devices");
 267 #endif
 268                         break;
 269                 case fpga_altera:
 270 #if defined(CONFIG_FPGA_ALTERA)
 271                         ret_val = altera_load(desc->devdesc, buf, bsize);
 272 #else
 273                         fpga_no_sup((char *)__func__, "Altera devices");
 274 #endif
 275                         break;
 276                 case fpga_lattice:
 277 #if defined(CONFIG_FPGA_LATTICE)
 278                         ret_val = lattice_load(desc->devdesc, buf, bsize);
 279 #else
 280                         fpga_no_sup((char *)__func__, "Lattice devices");
 281 #endif
 282                         break;
 283                 default:
 284                         printf("%s: Invalid or unsupported device type %d\n",
 285                                __func__, desc->devtype);
 286                 }
 287         }
 288
 289         return ret_val;
 290 }
 291
 292 /*
 293  * fpga_dump
 294  *      generic multiplexing code
 295  */
 296 int fpga_dump(int devnum, const void *buf, size_t bsize)
 297 {
 298         int ret_val = FPGA_FAIL;           /* assume failure */
 299         const fpga_desc *desc = fpga_validate(devnum, buf, bsize,
 300                                               (char *)__func__);
 301
 302         if (desc) {
 303                 switch (desc->devtype) {
 304                 case fpga_xilinx:
 305 #if defined(CONFIG_FPGA_XILINX)
 306                         ret_val = xilinx_dump(desc->devdesc, buf, bsize);
 307 #else
 308                         fpga_no_sup((char *)__func__, "Xilinx devices");
 309 #endif
 310                         break;
 311                 case fpga_altera:
 312 #if defined(CONFIG_FPGA_ALTERA)
 313                         ret_val = altera_dump(desc->devdesc, buf, bsize);
 314 #else
 315                         fpga_no_sup((char *)__func__, "Altera devices");
 316 #endif
 317                         break;
 318                 case fpga_lattice:
 319 #if defined(CONFIG_FPGA_LATTICE)
 320                         ret_val = lattice_dump(desc->devdesc, buf, bsize);
 321 #else
 322                         fpga_no_sup((char *)__func__, "Lattice devices");
 323 #endif
 324                         break;
 325                 default:
 326                         printf("%s: Invalid or unsupported device type %d\n",
 327                                __func__, desc->devtype);
 328                 }
 329         }
 330
 331         return ret_val;
 332 }
 333
 334 /*
 335  * fpga_info
 336  *      front end to fpga_dev_info.  If devnum is invalid, report on all
 337  *      available devices.
 338  */
 339 int fpga_info(int devnum)
 340 {
 341         if (devnum == FPGA_INVALID_DEVICE) {
 342                 if (next_desc > 0) {
 343                         int dev;
 344
 345                         for (dev = 0; dev < next_desc; dev++)
 346                                 fpga_dev_info(dev);
 347
 348                         return FPGA_SUCCESS;
 349                 } else {
 350                         printf("%s: No FPGA devices available.\n", __func__);
 351                         return FPGA_FAIL;
 352                 }
 353         }
 354
 355         return fpga_dev_info(devnum);
 356 }