usr/src/lib/efcode/pci/pci.c

   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, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2000-2003 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <strings.h>
  32
  33 #include <fcode/private.h>
  34 #include <fcode/log.h>
  35
  36 #include <fcdriver/fcdriver.h>
  37
  38 static fstack_t
  39 mem_map_in(fcode_env_t *env, fstack_t hi, fstack_t mid, fstack_t lo,
  40     fstack_t requested_len)
  41 {
  42         private_data_t  *cdp = DEVICE_PRIVATE(env);
  43         int error;
  44         fc_cell_t requested_virt, adjusted_virt;
  45         char *service = "map-in";
  46         fstack_t mcookie = NULL;
  47         int pa_offset = 0, va_offset = 0;
  48         fstack_t adjusted_len = 0;
  49
  50         pa_offset = lo & PAGEOFFSET;
  51         lo &= PAGEMASK;
  52
  53         /* adjust the requested_len to a multiple of a pagesize */
  54         requested_len = (requested_len + pa_offset + PAGEOFFSET) & PAGEMASK;
  55
  56         error = fc_run_priv(cdp->common, service, 4, 1,
  57             fc_size2cell(requested_len), fc_uint32_t2cell(hi),
  58             fc_uint32_t2cell(mid), fc_uint32_t2cell(lo), &requested_virt);
  59
  60         if (error)
  61                 throw_from_fclib(env, 1, "pci:%s: failed\n", service);
  62
  63         /*
  64          * Check the requested_virt address and ensure that
  65          * it starts at a page boundary.
  66          */
  67
  68         va_offset = requested_virt & PAGEOFFSET;
  69
  70         if (va_offset != 0) {
  71
  72                 /*
  73                  * Align the virtual address to a page boundary
  74                  * before mapping it to a mcookie. Recalcuate the
  75                  * length and round it up to the next multiple of a pagesize.
  76                  */
  77
  78                 adjusted_virt = requested_virt & PAGEMASK;
  79                 adjusted_len = (requested_len + va_offset + PAGEOFFSET)
  80                     & PAGEMASK;
  81         }
  82
  83         mcookie = mapping_to_mcookie(requested_virt, requested_len,
  84             adjusted_virt, adjusted_len);
  85
  86         if (mcookie == NULL)
  87                 throw_from_fclib(env, 1, "pci-mapin-> pci:%s:"
  88                     " mapping_to_mcookie failed\n", service);
  89         /*
  90          * Recalculate the address of the mcookie.
  91          */
  92
  93         mcookie += va_offset + pa_offset;
  94
  95         debug_msg(DEBUG_REG_ACCESS, "pci:map-in: %llx -> %x\n",
  96             (uint64_t)requested_virt, (uint32_t)mcookie);
  97
  98         return (mcookie);
  99 }
 100
 101 static void
 102 mem_map_out(fcode_env_t *env, fstack_t mcookie, fstack_t requested_len)
 103 {
 104         private_data_t *cdp = DEVICE_PRIVATE(env);
 105         char *service = "map-out";
 106         fc_cell_t requested_virt;
 107         int error;
 108
 109         if (!is_mcookie(mcookie)) {
 110                 log_message(MSG_ERROR, "pci:%s: %x not mcookie!\n", service,
 111                     (uint32_t)mcookie);
 112                 requested_virt = mcookie;
 113         } else {
 114                 requested_virt = mcookie_to_rvirt(mcookie);
 115                 requested_len = mcookie_to_rlen(mcookie);
 116                 delete_mapping(mcookie);
 117                 debug_msg(DEBUG_REG_ACCESS, "pci:%s: %x -> %llx\n", service,
 118                     (uint32_t)mcookie, (uint64_t)requested_virt);
 119         }
 120
 121         error = fc_run_priv(cdp->common, service, 2, 0,
 122             fc_size2cell(requested_len), requested_virt);
 123
 124         if (error)
 125                 log_message(MSG_ERROR, "pci:%s: failed\n", service);
 126 }
 127
 128 static void
 129 pci_config_fetch(fcode_env_t *env, char *service)
 130 {
 131         uint32_t cfgadd;
 132         fc_cell_t value;
 133         private_data_t  *h = DEVICE_PRIVATE(env);
 134         int error;
 135
 136         ASSERT(h);
 137         CHECK_DEPTH(env, 1, service);
 138         cfgadd = POP(DS);
 139         error = fc_run_priv(h->common, service, 1, 1, fc_uint32_t2cell(cfgadd),
 140             &value);
 141
 142         if (error)
 143                 throw_from_fclib(env, 1, "pci:%s ( %x ) FAIL\n", service,
 144                     cfgadd);
 145
 146         PUSH(DS, value);
 147 }
 148
 149 static void
 150 pci_config_store(fcode_env_t *env, char *service)
 151 {
 152         uint32_t cfgadd;
 153         fc_cell_t value;
 154         private_data_t  *h = DEVICE_PRIVATE(env);
 155         int error;
 156
 157         ASSERT(h);
 158         CHECK_DEPTH(env, 2, service);
 159         cfgadd = POP(DS);
 160         value = POP(DS);
 161         error = fc_run_priv(h->common, service, 2, 0, fc_uint32_t2cell(cfgadd),
 162             fc_uint32_t2cell(value));
 163
 164         if (error)
 165                 throw_from_fclib(env, 1, "pci:%s ( %x %x ) FAIL\n", service,
 166                     cfgadd, value);
 167 }
 168
 169 static void
 170 config_lfetch(fcode_env_t *env)
 171 {
 172         pci_config_fetch(env, "config-l@");
 173 }
 174
 175 static void
 176 config_lstore(fcode_env_t *env)
 177 {
 178         pci_config_store(env, "config-l!");
 179 }
 180
 181 static void
 182 config_wfetch(fcode_env_t *env)
 183 {
 184         pci_config_fetch(env, "config-w@");
 185 }
 186
 187 static void
 188 config_wstore(fcode_env_t *env)
 189 {
 190         pci_config_store(env, "config-w!");
 191 }
 192
 193 static void
 194 config_bfetch(fcode_env_t *env)
 195 {
 196         pci_config_fetch(env, "config-b@");
 197 }
 198
 199 static void
 200 config_bstore(fcode_env_t *env)
 201 {
 202         pci_config_store(env, "config-b!");
 203 }
 204
 205 static void
 206 do_map_in(fcode_env_t *env)
 207 {
 208         fstack_t phi, pmid, plo, len, addr;
 209
 210         CHECK_DEPTH(env, 4, "pci:map-in");
 211         len = POP(DS);
 212         phi = POP(DS);
 213         pmid = POP(DS);
 214         plo = POP(DS);
 215         addr = mem_map_in(env, phi, pmid, plo, len);
 216         PUSH(DS, addr);
 217 }
 218
 219 static void
 220 do_map_out(fcode_env_t *env)
 221 {
 222         fstack_t addr, len;
 223
 224         CHECK_DEPTH(env, 2, "pci:map-out");
 225         len = POP(DS);
 226         addr = POP(DS);
 227         mem_map_out(env, addr, len);
 228 }
 229
 230 static void
 231 do_encode_unit(fcode_env_t *env)
 232 {
 233         char enc_buf[64];
 234         uint32_t hi;
 235         int dev, fn;
 236
 237         CHECK_DEPTH(env, 3, "pci:encode-unit");
 238         hi = POP(DS);
 239         (void) POP(DS);
 240         (void) POP(DS);
 241
 242         fn  = ((hi >> 8) & 0x7);
 243         dev = ((hi >> 11) & 0x1f);
 244
 245         if (fn) {
 246                 sprintf(enc_buf, "%x,%x", dev, fn);
 247         } else {
 248                 sprintf(enc_buf, "%x", dev);
 249         }
 250         debug_msg(DEBUG_REG_ACCESS, "pci:encode-unit ( %x ) -> %s\n",
 251             hi, enc_buf);
 252         push_a_string(env, STRDUP(enc_buf));
 253 }
 254
 255 static void
 256 do_decode_unit(fcode_env_t *env)
 257 {
 258         int lo, hi, unit;
 259         char *buf;
 260
 261         CHECK_DEPTH(env, 2, "pci:decode-unit");
 262         buf = pop_a_string(env, NULL);
 263         if (sscanf(buf, "%x,%x", &hi, &lo) != 2) {
 264                 throw_from_fclib(env, 1, "pci:decode-unit: '%s'", buf);
 265         }
 266         unit = ((hi & 0x1f) << 11);
 267         unit |= ((lo & 0x7) << 8);
 268         debug_msg(DEBUG_REG_ACCESS, "pci:decode-unit ( '%s' ) -> 0 0 %x\n",
 269             buf, unit);
 270         PUSH(DS, 0);
 271         PUSH(DS, 0);
 272         PUSH(DS, unit);
 273 }
 274
 275 static void
 276 do_device_id(fcode_env_t *env)
 277 {
 278         uint32_t cfgadd;
 279         uint16_t ven_id, dev_id;
 280         char buf[40];
 281
 282         CHECK_DEPTH(env, 3, "pci:device-id");
 283         cfgadd = POP(DS);
 284         (void) POP(DS);
 285         (void) POP(DS);
 286         PUSH(DS, cfgadd + PCI_CONF_VENID);
 287         config_wfetch(env);
 288         ven_id = POP(DS);
 289         PUSH(DS, cfgadd + PCI_CONF_DEVID);
 290         config_wfetch(env);
 291         dev_id = POP(DS);
 292         sprintf(buf, "pci%x,%x", ven_id, dev_id);
 293         push_a_string(env, STRDUP(buf));
 294 }
 295
 296 static void
 297 do_class_id(fcode_env_t *env)
 298 {
 299         uint32_t cfgadd;
 300         uint8_t basclass, subclass, progclass;
 301         char buf[40];
 302
 303         CHECK_DEPTH(env, 3, "pci:class-id");
 304         cfgadd = POP(DS);
 305         (void) POP(DS);
 306         (void) POP(DS);
 307         PUSH(DS, cfgadd + PCI_CONF_BASCLASS);
 308         config_bfetch(env);
 309         basclass = POP(DS);
 310         PUSH(DS, cfgadd + PCI_CONF_SUBCLASS);
 311         config_bfetch(env);
 312         subclass = POP(DS);
 313         PUSH(DS, cfgadd + PCI_CONF_PROGCLASS);
 314         config_bfetch(env);
 315         progclass = POP(DS);
 316         sprintf(buf, "pciclass%02x%02x%02x", basclass, subclass, progclass);
 317         push_a_string(env, STRDUP(buf));
 318 }
 319
 320 #pragma init(_init)
 321
 322 static void
 323 _init(void)
 324 {
 325         fcode_env_t *env = initial_env;
 326
 327         ASSERT(env);
 328         ASSERT(env->current_device);
 329         NOTICE;
 330
 331         FORTH(0,        "config-l@",            config_lfetch);
 332         FORTH(0,        "config-l!",            config_lstore);
 333         FORTH(0,        "config-w@",            config_wfetch);
 334         FORTH(0,        "config-w!",            config_wstore);
 335         FORTH(0,        "config-b@",            config_bfetch);
 336         FORTH(0,        "config-b!",            config_bstore);
 337         FORTH(0,        "map-in",               do_map_in);
 338         FORTH(0,        "map-out",              do_map_out);
 339         FORTH(0,        "decode-unit",          do_decode_unit);
 340         FORTH(0,        "encode-unit",          do_encode_unit);
 341         FORTH(0,        "device-id",            do_device_id);
 342         FORTH(0,        "class-id",             do_class_id);
 343
 344         install_dma_methods(env);
 345 }