git.sur5r.net Git - u-boot/blob - drivers/misc/fsl_debug_server.c

   1 /*
   2  * Copyright (C) 2014 Freescale Semiconductor
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <errno.h>
   9 #include <asm/io.h>
  10 #include <asm/system.h>
  11 #include <asm/arch-fsl-lsch3/immap_lsch3.h>
  12
  13 #include <fsl_debug_server.h>
  14
  15 DECLARE_GLOBAL_DATA_PTR;
  16 static int debug_server_ver_info_maj, debug_server_ver_info_min;
  17
  18 /**
  19  * Copying Debug Server firmware to DDR
  20  */
  21 static int debug_server_copy_image(const char *title, u64 image_addr,
  22                                    u32 image_size, u64 debug_server_ram_addr)
  23 {
  24         debug("%s copied to address %p\n", title,
  25               (void *)debug_server_ram_addr);
  26         memcpy((void *)debug_server_ram_addr, (void *)image_addr, image_size);
  27
  28         return 0;
  29 }
  30
  31 /**
  32  * Debug Server FIT image parser checks if the image is in FIT
  33  * format, verifies integrity of the image and calculates
  34  * raw image address and size values.
  35  *
  36  * Returns 0 if success and -1 if any of the above mentioned
  37  * task fail.
  38  **/
  39 int debug_server_parse_firmware_fit_image(const void **raw_image_addr,
  40                                           size_t *raw_image_size)
  41 {
  42         int format;
  43         void *fit_hdr;
  44         int node_offset;
  45         const void *data;
  46         size_t size;
  47         const char *uname = "firmware";
  48         char *desc;
  49         char *debug_server_ver_info;
  50         char *debug_server_ver_info_major, *debug_server_ver_info_minor;
  51
  52         /* Check if the image is in NOR flash */
  53 #ifdef CONFIG_SYS_DEBUG_SERVER_FW_IN_NOR
  54         fit_hdr = (void *)CONFIG_SYS_DEBUG_SERVER_FW_ADDR;
  55 #else
  56 #error "CONFIG_SYS_DEBUG_SERVER_FW_IN_NOR not defined"
  57 #endif
  58
  59         /* Check if Image is in FIT format */
  60         format = genimg_get_format(fit_hdr);
  61         if (format != IMAGE_FORMAT_FIT) {
  62                 printf("Error! Not a FIT image\n");
  63                 goto out_error;
  64         }
  65
  66         if (!fit_check_format(fit_hdr)) {
  67                 printf("Error! Bad FIT image format\n");
  68                 goto out_error;
  69         }
  70
  71         node_offset = fit_image_get_node(fit_hdr, uname);
  72         if (node_offset < 0) {
  73                 printf("Error! Can not find %s subimage\n", uname);
  74                 goto out_error;
  75         }
  76
  77         /* Verify Debug Server firmware image */
  78         if (!fit_image_verify(fit_hdr, node_offset)) {
  79                 printf("Error! Bad Debug Server firmware hash");
  80                 goto out_error;
  81         }
  82
  83         if (fit_get_desc(fit_hdr, node_offset, &desc) < 0) {
  84                 printf("Error! Failed to get Debug Server fw description");
  85                 goto out_error;
  86         }
  87
  88         debug_server_ver_info = strstr(desc, "Version");
  89         debug_server_ver_info_major = strtok(debug_server_ver_info, ".");
  90         debug_server_ver_info_minor = strtok(NULL, ".");
  91
  92         debug_server_ver_info_maj =
  93                         simple_strtoul(debug_server_ver_info_major, NULL, 10);
  94         debug_server_ver_info_min =
  95                         simple_strtoul(debug_server_ver_info_minor, NULL, 10);
  96
  97         /* Debug server version checking */
  98         if ((debug_server_ver_info_maj < DEBUG_SERVER_VER_MAJOR) ||
  99             (debug_server_ver_info_min < DEBUG_SERVER_VER_MINOR)) {
 100                 printf("Debug server FW mismatches the min version required\n");
 101                 printf("Expected:%d.%d, Got %d.%d\n",
 102                        DEBUG_SERVER_VER_MAJOR, DEBUG_SERVER_VER_MINOR,
 103                        debug_server_ver_info_maj,
 104                        debug_server_ver_info_min);
 105                 goto out_error;
 106         }
 107
 108         /* Get address and size of raw image */
 109         fit_image_get_data(fit_hdr, node_offset, &data, &size);
 110
 111         *raw_image_addr = data;
 112         *raw_image_size = size;
 113
 114         return 0;
 115
 116 out_error:
 117         return -1;
 118 }
 119
 120 /**
 121  * Return the actual size of the Debug Server private DRAM block.
 122  *
 123  * NOTE: For now this function always returns the minimum required size,
 124  * However, in the future, the actual size may be obtained from an environment
 125  * variable.
 126  */
 127 unsigned long debug_server_get_dram_block_size(void)
 128 {
 129         return CONFIG_SYS_DEBUG_SERVER_DRAM_BLOCK_MIN_SIZE;
 130 }
 131
 132 int debug_server_init(void)
 133 {
 134         struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
 135         int error, timeout = CONFIG_SYS_DEBUG_SERVER_TIMEOUT;
 136         int debug_server_boot_status;
 137         u64 debug_server_ram_addr, debug_server_ram_size;
 138         const void *raw_image_addr;
 139         size_t raw_image_size = 0;
 140
 141         debug("debug_server_init called\n");
 142         /*
 143          * The Debug Server private DRAM block was already carved at the end of
 144          * DRAM by board_init_f() using CONFIG_SYS_MEM_TOP_HIDE:
 145          */
 146         debug_server_ram_size = debug_server_get_dram_block_size();
 147         if (gd->bd->bi_dram[1].start)
 148                 debug_server_ram_addr =
 149                         gd->bd->bi_dram[1].start + gd->bd->bi_dram[1].size;
 150         else
 151                 debug_server_ram_addr =
 152                         gd->bd->bi_dram[0].start + gd->bd->bi_dram[0].size;
 153
 154         error = debug_server_parse_firmware_fit_image(&raw_image_addr,
 155                                                         &raw_image_size);
 156         if (error != 0)
 157                 goto out;
 158
 159         debug("debug server (ram addr = 0x%llx, ram size = 0x%llx)\n",
 160               debug_server_ram_addr, debug_server_ram_size);
 161         /*
 162          * Load the Debug Server FW at the beginning of the Debug Server
 163          * private DRAM block:
 164          */
 165         debug_server_copy_image("Debug Server Firmware",
 166                                 (u64)raw_image_addr, raw_image_size,
 167                                 debug_server_ram_addr);
 168
 169         /* flush dcache */
 170         flush_dcache_range((unsigned long)debug_server_ram_addr,
 171                            (unsigned long)debug_server_ram_addr +
 172                            (unsigned long)debug_server_ram_size);
 173
 174         /*
 175          * Tell SP that the Debug Server FW is about to be launched. Before that
 176          * populate the following:
 177          * 1. Write the size allocated to SP Memory region into Bits {31:16} of
 178          *    SCRATCHRW5.
 179          * 2. Write the start address of the SP memory regions into
 180          *    SCRATCHRW5 (Bits {15:0}, contain most significant bits, Bits
 181          *    {47:32} of the SP Memory Region physical start address
 182          *    (SoC address)) and SCRATCHRW6 (Bits {31:0}).
 183          * 3. To know the Debug Server FW boot status, set bit 0 of SCRATCHRW11
 184          *    to 1. The Debug Server sets this to 0 to indicate a
 185          *    successul boot.
 186          * 4. Wakeup SP by writing 0x1F to VSG GIC reg VIGR2.
 187          */
 188
 189         /* 512 MB */
 190         out_le32(&gur->scratchrw[5 - 1],
 191                  (u32)((u64)debug_server_ram_addr >> 32) | (0x000D << 16));
 192         out_le32(&gur->scratchrw[6 - 1],
 193                  ((u32)debug_server_ram_addr) & 0xFFFFFFFF);
 194
 195         out_le32(&gur->scratchrw[11 - 1], DEBUG_SERVER_INIT_STATUS);
 196         /* Allow the changes to reflect in GUR block */
 197         mb();
 198
 199         /*
 200          * Program VGIC to raise an interrupt to SP
 201          */
 202         out_le32(CONFIG_SYS_FSL_SP_VSG_GIC_VIGR2, 0x1F);
 203         /* Allow the changes to reflect in VIGR2 */
 204         mb();
 205
 206         dmb();
 207         debug("Polling for Debug server to launch ...\n");
 208
 209         while (1) {
 210                 debug_server_boot_status = in_le32(&gur->scratchrw[11 - 1]);
 211                 if (!(debug_server_boot_status & DEBUG_SERVER_INIT_STATUS_MASK))
 212                         break;
 213
 214                 udelay(1);      /* throttle polling */
 215                 if (timeout-- <= 0)
 216                         break;
 217         }
 218
 219         if (timeout <= 0) {
 220                 printf("Debug Server FW timed out (boot status: 0x%x)\n",
 221                        debug_server_boot_status);
 222                 error = -ETIMEDOUT;
 223                 goto out;
 224         }
 225
 226         if (debug_server_boot_status & DEBUG_SERVER_INIT_STATUS_MASK) {
 227                 printf("Debug server FW error'ed out (boot status: 0x%x)\n",
 228                        debug_server_boot_status);
 229                 error = -ENODEV;
 230                 goto out;
 231         }
 232
 233         printf("Debug server booted\n");
 234         printf("Detected firmware %d.%d, (boot status: 0x0%x)\n",
 235                debug_server_ver_info_maj, debug_server_ver_info_min,
 236                debug_server_boot_status);
 237
 238 out:
 239         if (error != 0)
 240                 debug_server_boot_status = -error;
 241         else
 242                 debug_server_boot_status = 0;
 243
 244         return debug_server_boot_status;
 245 }
 246