usr/src/uts/common/sys/ucode.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _SYS_UCODE_H
  27 #define _SYS_UCODE_H
  28
  29 #ifdef _KERNEL
  30 #include <sys/cpuvar.h>
  31 #endif
  32 #include <sys/types.h>
  33 #include <sys/priv.h>
  34 #include <sys/processor.h>
  35 #ifndef _KERNEL
  36 #include <limits.h>
  37 #endif
  38 #include <ucode/ucode_errno.h>
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 /*
  45  *      /dev/ucode
  46  */
  47 #define UCODE_DRIVER_NAME       "ucode"
  48 #define UCODE_NODE_NAME         "ucode"
  49 #define UCODE_MINOR             ((minor_t)0x3fffful)
  50
  51 /*
  52  * Where to install the microcode
  53  */
  54 #define UCODE_INSTALL_PATH              "platform/i86pc/ucode"
  55 #define UCODE_INSTALL_COMMON_PATH       ".f"
  56
  57 /*
  58  * ioctl numbers
  59  */
  60 #define UCODE_IOC               (('u'<<24)|('c'<<16)|('o'<<8))
  61
  62 #define UCODE_GET_VERSION       (UCODE_IOC|0)
  63 #define UCODE_UPDATE            (UCODE_IOC|1)
  64
  65 struct ucode_get_rev_struct {
  66         uint32_t *ugv_rev;              /* microcode revision array */
  67         int ugv_size;                   /* size of the array */
  68         ucode_errno_t ugv_errno;        /* EUC error code */
  69 };
  70
  71 struct ucode_write_struct {
  72         uint32_t uw_size;       /* size of the uw_code buffer */
  73         uint8_t *uw_ucode;      /* pointer to the undigested microcode */
  74         ucode_errno_t uw_errno; /* EUC error code */
  75 };
  76
  77 #if defined(_SYSCALL32_IMPL)
  78
  79 #include <sys/types32.h>
  80
  81 struct ucode_get_rev_struct32 {
  82         caddr32_t ugv_rev;              /* microcode revision array */
  83         int ugv_size;                   /* size of the array */
  84         ucode_errno_t ugv_errno;        /* EUC error code */
  85 };
  86
  87 struct ucode_write_struct32 {
  88         uint32_t uw_size;       /* size of the uw_code buffer */
  89         caddr32_t uw_ucode;     /* pointer to the undigested microcode */
  90         ucode_errno_t uw_errno; /* EUC error code */
  91 };
  92
  93 #endif  /* _SYSCALL32_IMPL */
  94
  95 /*
  96  * AMD Microcode file information
  97  */
  98 typedef struct ucode_header_amd {
  99         uint32_t uh_date;
 100         uint32_t uh_patch_id;
 101         uint32_t uh_internal; /* patch data id & length, init flag */
 102         uint32_t uh_cksum;
 103         uint32_t uh_nb_id;
 104         uint32_t uh_sb_id;
 105         uint16_t uh_cpu_rev;
 106         uint8_t  uh_nb_rev;
 107         uint8_t  uh_sb_rev;
 108         uint32_t uh_bios_rev;
 109         uint32_t uh_match[8];
 110 } ucode_header_amd_t;
 111
 112 typedef struct ucode_file_amd {
 113 #ifndef __xpv
 114         ucode_header_amd_t uf_header;
 115         uint8_t uf_data[896];
 116         uint8_t uf_resv[896];
 117         uint8_t uf_code_present;
 118         uint8_t uf_code[191];
 119 #else
 120         uint8_t *ucodep;
 121         uint32_t usize;
 122 #endif
 123 } ucode_file_amd_t;
 124
 125 typedef struct ucode_eqtbl_amd {
 126         uint32_t ue_inst_cpu;
 127         uint32_t ue_fixed_mask;
 128         uint32_t ue_fixed_comp;
 129         uint16_t ue_equiv_cpu;
 130         uint16_t ue_reserved;
 131 } ucode_eqtbl_amd_t;
 132
 133 /*
 134  * Intel Microcode file information
 135  */
 136 typedef struct ucode_header_intel {
 137         uint32_t        uh_header_ver;
 138         uint32_t        uh_rev;
 139         uint32_t        uh_date;
 140         uint32_t        uh_signature;
 141         uint32_t        uh_checksum;
 142         uint32_t        uh_loader_ver;
 143         uint32_t        uh_proc_flags;
 144         uint32_t        uh_body_size;
 145         uint32_t        uh_total_size;
 146         uint32_t        uh_reserved[3];
 147 } ucode_header_intel_t;
 148
 149 typedef struct ucode_ext_sig_intel {
 150         uint32_t        ues_signature;
 151         uint32_t        ues_proc_flags;
 152         uint32_t        ues_checksum;
 153 } ucode_ext_sig_intel_t;
 154
 155 typedef struct ucode_ext_table_intel {
 156         uint32_t        uet_count;
 157         uint32_t        uet_checksum;
 158         uint32_t        uet_reserved[3];
 159         ucode_ext_sig_intel_t uet_ext_sig[1];
 160 } ucode_ext_table_intel_t;
 161
 162 typedef struct ucode_file_intel {
 163         ucode_header_intel_t    *uf_header;
 164         uint8_t                 *uf_body;
 165         ucode_ext_table_intel_t *uf_ext_table;
 166 } ucode_file_intel_t;
 167
 168 /*
 169  * common container
 170  */
 171 typedef union ucode_file {
 172         ucode_file_amd_t *amd;
 173         ucode_file_intel_t intel;
 174 } ucode_file_t;
 175
 176
 177 #define UCODE_SHORT_NAME_LEN    12      /* "32-bit-sig"-"8-bit-platid"\0 */
 178 /*
 179  * Length of UCODE_INSTALL_COMMON_PATH/short-name
 180  *      strlen(UCODE_INSTALL_COMMON_PATH) + 1 + UCODE_SHORT_NAME_LEN
 181  * Use sizeof which will give us the additional byte for the '/' in between
 182  * the common path and the file name.
 183  */
 184 #define UCODE_COMMON_NAME_LEN   \
 185         (sizeof (UCODE_INSTALL_COMMON_PATH) + (UCODE_SHORT_NAME_LEN))
 186 #define UCODE_MAX_PATH_LEN      (PATH_MAX - UCODE_COMMON_NAME_LEN)
 187
 188
 189 #define UCODE_HEADER_SIZE_INTEL         (sizeof (struct ucode_header_intel))
 190 #define UCODE_EXT_TABLE_SIZE_INTEL      (20)    /* 20-bytes */
 191 #define UCODE_EXT_SIG_SIZE_INTEL        (sizeof (struct ucode_ext_sig_intel))
 192
 193 #define UCODE_KB(a)     ((a) << 10)     /* KB */
 194 #define UCODE_MB(a)     ((a) << 20)     /* MB */
 195 #define UCODE_DEFAULT_TOTAL_SIZE        UCODE_KB(2)
 196 #define UCODE_DEFAULT_BODY_SIZE         (UCODE_KB(2) - UCODE_HEADER_SIZE_INTEL)
 197
 198 /*
 199  * For a single microcode file, the minimum size is 1K, maximum size is 16K.
 200  * Such limitations, while somewhat artificial, are not only to provide better
 201  * sanity checks, but also avoid wasting precious memory at startup time as the
 202  * microcode buffer for the first processor has to be statically allocated.
 203  *
 204  * For the concatenation of all the microcode binary files, the maximum size
 205  * is 16M.
 206  */
 207 #define UCODE_MIN_SIZE                  UCODE_KB(1)
 208 #define UCODE_MAX_SIZE                  UCODE_KB(16)
 209 #define UCODE_MAX_COMBINED_SIZE         UCODE_MB(16)
 210
 211 #define UCODE_SIZE_CONVERT(size, default_size) \
 212         ((size) == 0 ? (default_size) : (size))
 213
 214 #define UCODE_BODY_SIZE_INTEL(size) \
 215         UCODE_SIZE_CONVERT((size), UCODE_DEFAULT_BODY_SIZE)
 216
 217 #define UCODE_TOTAL_SIZE_INTEL(size)                    \
 218         UCODE_SIZE_CONVERT((size), UCODE_DEFAULT_TOTAL_SIZE)
 219
 220 #define UCODE_MATCH_INTEL(sig1, sig2, pf1, pf2) \
 221         (((sig1) == (sig2)) && \
 222         (((pf1) & (pf2)) || (((pf1) == 0) && ((pf2) == 0))))
 223
 224 extern ucode_errno_t ucode_header_validate_intel(ucode_header_intel_t *);
 225 extern uint32_t ucode_checksum_intel(uint32_t, uint32_t, uint8_t *);
 226
 227 extern ucode_errno_t ucode_validate_amd(uint8_t *, int);
 228 extern ucode_errno_t ucode_validate_intel(uint8_t *, int);
 229
 230 #ifdef _KERNEL
 231 extern ucode_errno_t ucode_get_rev(uint32_t *);
 232 extern ucode_errno_t ucode_update(uint8_t *, int);
 233
 234 /*
 235  * Microcode specific information per core
 236  */
 237 typedef struct cpu_ucode_info {
 238         uint32_t        cui_platid;     /* platform id */
 239         uint32_t        cui_rev;        /* microcode revision */
 240 } cpu_ucode_info_t;
 241
 242 /*
 243  * Data structure used for xcall
 244  */
 245 typedef struct ucode_update {
 246         uint32_t                sig;    /* signature */
 247         cpu_ucode_info_t        info;   /* ucode info */
 248         uint32_t                expected_rev;
 249         uint32_t                new_rev;
 250         uint8_t                 *ucodep; /* pointer to ucode */
 251         uint32_t                usize;
 252 } ucode_update_t;
 253
 254 /*
 255  * Microcode kernel operations
 256  */
 257 struct ucode_ops {
 258         uint32_t        write_msr;
 259         int             (*capable)(cpu_t *);
 260         void            (*file_reset)(ucode_file_t *, processorid_t);
 261         void            (*read_rev)(cpu_ucode_info_t *);
 262         uint32_t        (*load)(ucode_file_t *, cpu_ucode_info_t *, cpu_t *);
 263         ucode_errno_t   (*validate)(uint8_t *, int);
 264         ucode_errno_t   (*extract)(ucode_update_t *, uint8_t *, int);
 265         ucode_errno_t   (*locate)(cpu_t *, cpu_ucode_info_t *, ucode_file_t *);
 266 };
 267 #else
 268
 269 #define UCODE_MAX_VENDORS_NAME_LEN              20
 270
 271 #define UCODE_VENDORS                           \
 272 static struct {                                 \
 273         char *filestr;                          \
 274         char *extstr;                           \
 275         char *vendorstr;                        \
 276         int  supported;                         \
 277 } ucode_vendors[] = {                           \
 278         { "intel", "txt", "GenuineIntel", 1 },  \
 279         { "amd", "bin", "AuthenticAMD", 1 },    \
 280         { NULL, NULL, NULL, 0 }                 \
 281 }
 282
 283 /*
 284  * Microcode user operations
 285  */
 286 struct ucode_ops {
 287         int             (*convert)(const char *, uint8_t *, size_t);
 288         ucode_errno_t   (*gen_files)(uint8_t *, int, char *);
 289         ucode_errno_t   (*validate)(uint8_t *, int);
 290 };
 291 #endif
 292
 293 extern const struct ucode_ops *ucode;
 294
 295 #ifdef __cplusplus
 296 }
 297 #endif
 298
 299 #endif  /* _SYS_UCODE_H */