drivers/crypto/fsl/sec.c

   1 /*
   2  * Copyright 2014 Freescale Semiconductor, Inc.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <libfdt.h>
   9 #include <fdt_support.h>
  10 #if CONFIG_SYS_FSL_SEC_COMPAT == 2 || CONFIG_SYS_FSL_SEC_COMPAT >= 4
  11 #include <fsl_sec.h>
  12 #endif
  13
  14 /*
  15  * update crypto node properties to a specified revision of the SEC
  16  * called with sec_rev == 0 if not on an E processor
  17  */
  18 #if CONFIG_SYS_FSL_SEC_COMPAT == 2 /* SEC 2.x/3.x */
  19 void fdt_fixup_crypto_node(void *blob, int sec_rev)
  20 {
  21         static const struct sec_rev_prop {
  22                 u32 sec_rev;
  23                 u32 num_channels;
  24                 u32 channel_fifo_len;
  25                 u32 exec_units_mask;
  26                 u32 descriptor_types_mask;
  27         } sec_rev_prop_list[] = {
  28                 { 0x0200, 4, 24, 0x07e, 0x01010ebf }, /* SEC 2.0 */
  29                 { 0x0201, 4, 24, 0x0fe, 0x012b0ebf }, /* SEC 2.1 */
  30                 { 0x0202, 1, 24, 0x04c, 0x0122003f }, /* SEC 2.2 */
  31                 { 0x0204, 4, 24, 0x07e, 0x012b0ebf }, /* SEC 2.4 */
  32                 { 0x0300, 4, 24, 0x9fe, 0x03ab0ebf }, /* SEC 3.0 */
  33                 { 0x0301, 4, 24, 0xbfe, 0x03ab0ebf }, /* SEC 3.1 */
  34                 { 0x0303, 4, 24, 0x97c, 0x03a30abf }, /* SEC 3.3 */
  35         };
  36         static char compat_strlist[ARRAY_SIZE(sec_rev_prop_list) *
  37                                    sizeof("fsl,secX.Y")];
  38         int crypto_node, sec_idx, err;
  39         char *p;
  40         u32 val;
  41
  42         /* locate crypto node based on lowest common compatible */
  43         crypto_node = fdt_node_offset_by_compatible(blob, -1, "fsl,sec2.0");
  44         if (crypto_node == -FDT_ERR_NOTFOUND)
  45                 return;
  46
  47         /* delete it if not on an E-processor */
  48         if (crypto_node > 0 && !sec_rev) {
  49                 fdt_del_node(blob, crypto_node);
  50                 return;
  51         }
  52
  53         /* else we got called for possible uprev */
  54         for (sec_idx = 0; sec_idx < ARRAY_SIZE(sec_rev_prop_list); sec_idx++)
  55                 if (sec_rev_prop_list[sec_idx].sec_rev == sec_rev)
  56                         break;
  57
  58         if (sec_idx == ARRAY_SIZE(sec_rev_prop_list)) {
  59                 puts("warning: unknown SEC revision number\n");
  60                 return;
  61         }
  62
  63         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].num_channels);
  64         err = fdt_setprop(blob, crypto_node, "fsl,num-channels", &val, 4);
  65         if (err < 0)
  66                 printf("WARNING: could not set crypto property: %s\n",
  67                        fdt_strerror(err));
  68
  69         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].descriptor_types_mask);
  70         err = fdt_setprop(blob, crypto_node, "fsl,descriptor-types-mask",
  71                           &val, 4);
  72         if (err < 0)
  73                 printf("WARNING: could not set crypto property: %s\n",
  74                        fdt_strerror(err));
  75
  76         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].exec_units_mask);
  77         err = fdt_setprop(blob, crypto_node, "fsl,exec-units-mask", &val, 4);
  78         if (err < 0)
  79                 printf("WARNING: could not set crypto property: %s\n",
  80                        fdt_strerror(err));
  81
  82         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].channel_fifo_len);
  83         err = fdt_setprop(blob, crypto_node, "fsl,channel-fifo-len", &val, 4);
  84         if (err < 0)
  85                 printf("WARNING: could not set crypto property: %s\n",
  86                        fdt_strerror(err));
  87
  88         val = 0;
  89         while (sec_idx >= 0) {
  90                 p = compat_strlist + val;
  91                 val += sprintf(p, "fsl,sec%d.%d",
  92                         (sec_rev_prop_list[sec_idx].sec_rev & 0xff00) >> 8,
  93                         sec_rev_prop_list[sec_idx].sec_rev & 0x00ff) + 1;
  94                 sec_idx--;
  95         }
  96         err = fdt_setprop(blob, crypto_node, "compatible", &compat_strlist,
  97                           val);
  98         if (err < 0)
  99                 printf("WARNING: could not set crypto property: %s\n",
 100                        fdt_strerror(err));
 101 }
 102 #elif CONFIG_SYS_FSL_SEC_COMPAT >= 4  /* SEC4 */
 103 static u8 caam_get_era(void)
 104 {
 105         static const struct {
 106                 u16 ip_id;
 107                 u8 maj_rev;
 108                 u8 era;
 109         } caam_eras[] = {
 110                 {0x0A10, 1, 1},
 111                 {0x0A10, 2, 2},
 112                 {0x0A12, 1, 3},
 113                 {0x0A14, 1, 3},
 114                 {0x0A14, 2, 4},
 115                 {0x0A16, 1, 4},
 116                 {0x0A10, 3, 4},
 117                 {0x0A11, 1, 4},
 118                 {0x0A18, 1, 4},
 119                 {0x0A11, 2, 5},
 120                 {0x0A12, 2, 5},
 121                 {0x0A13, 1, 5},
 122                 {0x0A1C, 1, 5}
 123         };
 124
 125         ccsr_sec_t __iomem *sec = (void __iomem *)CONFIG_SYS_FSL_SEC_ADDR;
 126         u32 secvid_ms = sec_in32(&sec->secvid_ms);
 127         u32 ccbvid = sec_in32(&sec->ccbvid);
 128         u16 ip_id = (secvid_ms & SEC_SECVID_MS_IPID_MASK) >>
 129                                 SEC_SECVID_MS_IPID_SHIFT;
 130         u8 maj_rev = (secvid_ms & SEC_SECVID_MS_MAJ_REV_MASK) >>
 131                                 SEC_SECVID_MS_MAJ_REV_SHIFT;
 132         u8 era = (ccbvid & SEC_CCBVID_ERA_MASK) >> SEC_CCBVID_ERA_SHIFT;
 133
 134         int i;
 135
 136         if (era)        /* This is '0' prior to CAAM ERA-6 */
 137                 return era;
 138
 139         for (i = 0; i < ARRAY_SIZE(caam_eras); i++)
 140                 if (caam_eras[i].ip_id == ip_id &&
 141                     caam_eras[i].maj_rev == maj_rev)
 142                         return caam_eras[i].era;
 143
 144         return 0;
 145 }
 146
 147 static void fdt_fixup_crypto_era(void *blob, u32 era)
 148 {
 149         int err;
 150         int crypto_node;
 151
 152         crypto_node = fdt_path_offset(blob, "crypto");
 153         if (crypto_node < 0) {
 154                 printf("WARNING: Missing crypto node\n");
 155                 return;
 156         }
 157
 158         err = fdt_setprop(blob, crypto_node, "fsl,sec-era", &era,
 159                           sizeof(era));
 160         if (err < 0) {
 161                 printf("ERROR: could not set fsl,sec-era property: %s\n",
 162                        fdt_strerror(err));
 163         }
 164 }
 165
 166 void fdt_fixup_crypto_node(void *blob, int sec_rev)
 167 {
 168         u8 era;
 169
 170         if (!sec_rev) {
 171                 fdt_del_node_and_alias(blob, "crypto");
 172                 return;
 173         }
 174
 175         /* Add SEC ERA information in compatible */
 176         era = caam_get_era();
 177         if (era) {
 178                 fdt_fixup_crypto_era(blob, era);
 179         } else {
 180                 printf("WARNING: Unable to get ERA for CAAM rev: %d\n",
 181                        sec_rev);
 182         }
 183 }
 184 #endif