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 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 #include <sys/types.h>
  28 #include <sys/file.h>
  29 #include <sys/errno.h>
  30 #include <sys/open.h>
  31 #include <sys/cred.h>
  32 #include <sys/conf.h>
  33 #include <sys/stat.h>
  34 #include <sys/policy.h>
  35 #include <sys/processor.h>
  36 #include <sys/kmem.h>
  37 #include <sys/modctl.h>
  38 #include <sys/ddi.h>
  39 #include <sys/sunddi.h>
  40 
  41 #include <sys/auxv.h>
  42 #include <sys/ucode.h>
  43 #include <sys/systeminfo.h>
  44 #include <sys/x86_archext.h>
  45 
  46 static dev_info_t *ucode_devi;
  47 static uint32_t ucode_max_combined_size;
  48 static kmutex_t ucode_update_lock;
  49 
  50 /*ARGSUSED*/
  51 static int
  52 ucode_getinfo(dev_info_t *devi, ddi_info_cmd_t cmd, void *arg, void **result)
  53 {
  54         switch (cmd) {
  55         case DDI_INFO_DEVT2DEVINFO:
  56         case DDI_INFO_DEVT2INSTANCE:
  57                 break;
  58         default:
  59                 return (DDI_FAILURE);
  60         }
  61 
  62         switch (getminor((dev_t)arg)) {
  63         case UCODE_MINOR:
  64                 break;
  65         default:
  66                 return (DDI_FAILURE);
  67         }
  68 
  69         if (cmd == DDI_INFO_DEVT2INSTANCE)
  70                 *result = 0;
  71         else
  72                 *result = ucode_devi;
  73         return (DDI_SUCCESS);
  74 }
  75 
  76 static int
  77 ucode_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
  78 {
  79         ASSERT(cmd != DDI_RESUME);
  80 
  81         switch (cmd) {
  82         case DDI_RESUME:
  83                 return (DDI_SUCCESS);
  84 
  85         case DDI_ATTACH:
  86                 ucode_devi = devi;
  87                 ucode_max_combined_size = UCODE_MAX_COMBINED_SIZE;
  88 
  89                 if (ddi_create_minor_node(devi, UCODE_NODE_NAME, S_IFCHR,
  90                     UCODE_MINOR, DDI_PSEUDO, 0) != DDI_SUCCESS) {
  91                         cmn_err(CE_WARN, "%s: Unable to create minor node",
  92                             UCODE_NODE_NAME);
  93                         return (DDI_FAILURE);
  94                 }
  95                 ddi_report_dev(devi);
  96                 return (DDI_SUCCESS);
  97 
  98         default:
  99                 return (DDI_FAILURE);
 100         }
 101 }
 102 
 103 static int
 104 ucode_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
 105 {
 106         /*
 107          * The power management and DR framework should never invoke this
 108          * driver with DDI_SUSPEND because the ucode pseudo device does not
 109          * have a reg property or hardware binding.  However, we will return
 110          * DDI_SUCCESS so that in the unlikely event that it does get
 111          * called, the system will still suspend and resume.
 112          */
 113         ASSERT(cmd != DDI_SUSPEND);
 114 
 115         switch (cmd) {
 116         case DDI_SUSPEND:
 117                 return (DDI_SUCCESS);
 118 
 119         case DDI_DETACH:
 120                 ddi_remove_minor_node(devi, NULL);
 121                 ucode_devi = NULL;
 122                 return (DDI_SUCCESS);
 123 
 124         default:
 125                 return (DDI_FAILURE);
 126         }
 127 }
 128 
 129 /*ARGSUSED1*/
 130 static int
 131 ucode_open(dev_t *dev, int flag, int otyp, cred_t *cr)
 132 {
 133         return (getminor(*dev) == UCODE_MINOR ? 0 : ENXIO);
 134 }
 135 
 136 
 137 /*ARGSUSED*/
 138 static int
 139 ucode_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval)
 140 {
 141         /*
 142          * Make sure that the ucode ops pointer has been set up.
 143          */
 144         if (!ucode)
 145                 return (EIO);
 146 
 147         switch (cmd) {
 148         case UCODE_GET_VERSION: {
 149                 int size;
 150                 uint32_t *revp, *rev_array;
 151                 size_t bufsz = NCPU * sizeof (*revp);
 152                 ucode_errno_t rc = EM_OK;
 153 
 154                 STRUCT_DECL(ucode_get_rev_struct, h);
 155                 STRUCT_INIT(h, mode);
 156                 if (ddi_copyin((void *)arg,
 157                     STRUCT_BUF(h), STRUCT_SIZE(h), mode))
 158                         return (EFAULT);
 159 
 160                 if ((size = STRUCT_FGET(h, ugv_size)) > NCPU || size < 0)
 161                         return (EINVAL);
 162 
 163                 if (size == 0)
 164                         return (0);
 165 
 166                 if ((rev_array = STRUCT_FGETP(h, ugv_rev)) == NULL)
 167                         return (EINVAL);
 168 
 169                 size *= sizeof (uint32_t);
 170 
 171                 /* Can't rely on caller for kernel's buffer size. */
 172                 revp = kmem_zalloc(bufsz, KM_SLEEP);
 173                 if (ddi_copyin((void *)rev_array, revp, size, mode) != 0) {
 174                         kmem_free(revp, bufsz);
 175                         return (EINVAL);
 176                 }
 177 
 178                 rc = ucode_get_rev(revp);
 179 
 180                 STRUCT_FSET(h, ugv_errno, rc);
 181 
 182                 if (ddi_copyout(revp, (void *)rev_array, size, mode) != 0) {
 183                         kmem_free(revp, bufsz);
 184                         return (EFAULT);
 185                 }
 186 
 187                 kmem_free(revp, bufsz);
 188 
 189                 if (ddi_copyout(STRUCT_BUF(h), (void *)arg,
 190                     STRUCT_SIZE(h), mode))
 191                         return (EFAULT);
 192 
 193                 return (0);
 194         }
 195 
 196         case UCODE_UPDATE: {
 197                 int size;
 198                 uint8_t *ucodep, *uw_ucode;
 199                 ucode_errno_t rc = EM_OK;
 200 
 201                 /*
 202                  * Requires all privilege.
 203                  */
 204                 if (cr && secpolicy_ucode_update(cr))
 205                         return (EPERM);
 206 
 207                 STRUCT_DECL(ucode_write_struct, h);
 208 
 209                 STRUCT_INIT(h, mode);
 210                 if (ddi_copyin((void *)arg, STRUCT_BUF(h), STRUCT_SIZE(h),
 211                     mode))
 212                         return (EFAULT);
 213 
 214                 /*
 215                  * We allow the size of the combined microcode file to be up to
 216                  * ucode_max_combined_size.  It is initialized to
 217                  * UCODE_MAX_COMBINED_SIZE, and can be patched if necessary.
 218                  */
 219                 size = STRUCT_FGET(h, uw_size);
 220                 if (size > ucode_max_combined_size || size == 0)
 221                         return (EINVAL);
 222 
 223                 if ((uw_ucode = STRUCT_FGETP(h, uw_ucode)) == NULL)
 224                         return (EINVAL);
 225 
 226                 ucodep = kmem_zalloc(size, KM_SLEEP);
 227                 if (ddi_copyin((void *)uw_ucode, ucodep, size, mode) != 0) {
 228                         kmem_free(ucodep, size);
 229                         return (EFAULT);
 230                 }
 231 
 232                 if ((rc = ucode->validate(ucodep, size)) != EM_OK) {
 233                         kmem_free(ucodep, size);
 234                         STRUCT_FSET(h, uw_errno, rc);
 235                         if (ddi_copyout(STRUCT_BUF(h), (void *)arg,
 236                             STRUCT_SIZE(h), mode))
 237                                 return (EFAULT);
 238                         return (0);
 239                 }
 240 
 241                 mutex_enter(&ucode_update_lock);
 242                 rc = ucode_update(ucodep, size);
 243                 mutex_exit(&ucode_update_lock);
 244 
 245                 kmem_free(ucodep, size);
 246 
 247                 STRUCT_FSET(h, uw_errno, rc);
 248                 if (ddi_copyout(STRUCT_BUF(h), (void *)arg,
 249                     STRUCT_SIZE(h), mode))
 250                         return (EFAULT);
 251 
 252                 /*
 253                  * Even if rc is not EM_OK, it is a successful operation
 254                  * from ioctl()'s perspective.  We return the detailed error
 255                  * code via the ucode_write_struct data structure.
 256                  */
 257                 return (0);
 258         }
 259 
 260 
 261         default:
 262                 return (ENOTTY);
 263         }
 264 }
 265 
 266 static struct cb_ops ucode_cb_ops = {
 267         ucode_open,
 268         nulldev,        /* close */
 269         nodev,          /* strategy */
 270         nodev,          /* print */
 271         nodev,          /* dump */
 272         nodev,          /* read */
 273         nodev,          /* write */
 274         ucode_ioctl,
 275         nodev,          /* devmap */
 276         nodev,          /* mmap */
 277         nodev,          /* segmap */
 278         nochpoll,       /* poll */
 279         ddi_prop_op,
 280         NULL,
 281         D_64BIT | D_NEW | D_MP
 282 };
 283 
 284 static struct dev_ops ucode_dv_ops = {
 285         DEVO_REV,
 286         0,
 287         ucode_getinfo,
 288         nulldev,                /* identify */
 289         nulldev,                /* probe */
 290         ucode_attach,
 291         ucode_detach,
 292         nodev,                  /* reset */
 293         &ucode_cb_ops,
 294         (struct bus_ops *)0,
 295         NULL,                   /* power */
 296         ddi_quiesce_not_needed,         /* quiesce */
 297 };
 298 
 299 static struct modldrv modldrv = {
 300         &mod_driverops,
 301         "ucode driver",
 302         &ucode_dv_ops
 303 };
 304 
 305 static struct modlinkage modl = {
 306         MODREV_1,
 307         &modldrv
 308 };
 309 
 310 int
 311 _init(void)
 312 {
 313         int rc;
 314 
 315         if ((rc = mod_install(&modl)) != 0)
 316                 return (rc);
 317 
 318         mutex_init(&ucode_update_lock, NULL, MUTEX_DRIVER, NULL);
 319 
 320         return (0);
 321 }
 322 
 323 int
 324 _fini(void)
 325 {
 326         int rc;
 327 
 328         if ((rc = mod_remove(&modl)) != 0)
 329                 return (rc);
 330 
 331         mutex_destroy(&ucode_update_lock);
 332 
 333         return (0);
 334 }
 335 
 336 int
 337 _info(struct modinfo *modinfo)
 338 {
 339         return (mod_info(&modl, modinfo));
 340 }