The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/pci/simos.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1998 Doug Rabson
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  * $FreeBSD$
   27  */
   28 
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/malloc.h>
   32 #include <sys/buf.h>
   33 #include <sys/proc.h>
   34 
   35 #include <cam/cam.h>
   36 #include <cam/cam_ccb.h>
   37 #include <cam/cam_sim.h>
   38 #include <cam/cam_xpt_sim.h>
   39 #include <cam/cam_debug.h>
   40 
   41 #include <cam/scsi/scsi_all.h>
   42 #include <cam/scsi/scsi_message.h>
   43 
   44 #include <machine/clock.h>
   45 #include <vm/vm.h>
   46 #include <vm/vm_param.h>
   47 #include <vm/pmap.h>
   48 #include <sys/kernel.h>
   49 
   50 #include <pci/simos.h>
   51 
   52 #include <pci/pcireg.h>
   53 #include <pci/pcivar.h>
   54 
   55 #include <machine/alpha_cpu.h>
   56 
   57 struct simos_softc {
   58         int                     sc_unit;
   59         SimOS_SCSI*             sc_regs;
   60 
   61         /*
   62          * SimOS only supports one pending command.
   63          */
   64         struct cam_sim         *sc_sim;
   65         struct cam_path        *sc_path;
   66         struct ccb_scsiio      *sc_pending;
   67 };
   68 
   69 struct simos_softc* simosp[10];
   70 
   71 static u_long simos_unit;
   72 
   73 static const char *simos_probe __P((pcici_t tag, pcidi_t type));
   74 static void simos_attach __P((pcici_t config_d, int unit));
   75 static void simos_action __P((struct cam_sim *sim, union ccb *ccb));
   76 static void simos_poll __P((struct cam_sim *sim));
   77 
   78 struct pci_device simos_driver = {
   79         "simos",
   80         simos_probe,
   81         simos_attach,
   82         &simos_unit,
   83         NULL
   84 };
   85 COMPAT_PCI_DRIVER (simos, simos_driver);
   86 
   87 static const char *
   88 simos_probe(pcici_t tag, pcidi_t type)
   89 {       
   90         switch (type) {
   91         case 0x1291|(0x1291<<16):
   92                 return "SimOS SCSI";
   93         default:
   94                 return NULL;
   95         }
   96                 
   97 }
   98 
   99 static void    
  100 simos_attach(pcici_t config_id, int unit)
  101 {
  102         struct simos_softc* sc;
  103         struct cam_devq *devq;
  104 
  105         sc = malloc(sizeof(struct simos_softc), M_DEVBUF, M_WAITOK);
  106         simosp[unit] = sc;
  107         bzero(sc, sizeof *sc);
  108 
  109         sc->sc_unit = unit;
  110         sc->sc_regs = (SimOS_SCSI*) SIMOS_SCSI_ADDR;
  111         sc->sc_pending = 0;
  112 
  113         devq = cam_simq_alloc(/*maxopenings*/1);
  114         if (devq == NULL)
  115                 return;
  116 
  117         sc->sc_sim = cam_sim_alloc(simos_action, simos_poll, "simos", sc, unit,
  118                                    /*untagged*/1, /*tagged*/0, devq);
  119         if (sc->sc_sim == NULL) {
  120                 cam_simq_free(devq);
  121                 return;
  122         }
  123 
  124         if (xpt_bus_register(sc->sc_sim, /*bus*/0) != CAM_SUCCESS) {
  125                 cam_sim_free(sc->sc_sim, /*free_devq*/TRUE);
  126                 return;
  127         }
  128 
  129         if (xpt_create_path(&sc->sc_path, /*periph*/NULL,
  130                             cam_sim_path(sc->sc_sim), CAM_TARGET_WILDCARD,
  131                             CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
  132                 xpt_bus_deregister(cam_sim_path(sc->sc_sim));
  133                 cam_sim_free(sc->sc_sim, /*free_devq*/TRUE);
  134                 return;
  135         }
  136 
  137         alpha_register_pci_scsi(config_id->bus, config_id->slot, sc->sc_sim);
  138 
  139         return;
  140 }
  141 
  142 static void
  143 simos_start(struct simos_softc* sc, struct ccb_scsiio *csio)
  144 {
  145         struct scsi_generic *cmd;
  146         int cmdlen;
  147         caddr_t data;
  148         int datalen;
  149         int s;
  150         u_int8_t* p;
  151         int i, count, target;
  152         vm_offset_t va;
  153         vm_size_t size;
  154 
  155         cmd = (struct scsi_generic *) &csio->cdb_io.cdb_bytes;
  156         cmdlen = csio->cdb_len;
  157         data = csio->data_ptr;
  158         datalen = csio->dxfer_len;
  159 
  160         /*
  161          * Simos doesn't understand some commands
  162          */
  163         if (cmd->opcode == START_STOP || cmd->opcode == PREVENT_ALLOW
  164             || cmd->opcode == SYNCHRONIZE_CACHE) {
  165                 csio->ccb_h.status = CAM_REQ_CMP;
  166                 xpt_done((union ccb *) csio);
  167                 return;
  168         }
  169 
  170         if (sc->sc_pending) {
  171                 /*
  172                  * Don't think this can happen.
  173                  */
  174                 printf("simos_start: can't start command while one is pending\n");
  175                 csio->ccb_h.status = CAM_BUSY;
  176                 xpt_done((union ccb *) csio);
  177                 return;
  178         }
  179 
  180         s = splcam();
  181         
  182         csio->ccb_h.status |= CAM_SIM_QUEUED;
  183         sc->sc_pending = csio;
  184 
  185         target = csio->ccb_h.target_id;
  186 
  187         /*
  188          * Copy the command into SimOS' buffer
  189          */
  190         p = (u_int8_t*) cmd;
  191         count = cmdlen;
  192         for (i = 0; i < count; i++)
  193                 sc->sc_regs->cmd[i] = *p++;
  194         sc->sc_regs->length = count;
  195         sc->sc_regs->target = target;
  196         sc->sc_regs->lun = csio->ccb_h.target_lun;
  197 
  198         /*
  199          * Setup the segment descriptors.
  200          */
  201         va = (vm_offset_t) data;
  202         size = datalen;
  203         i = 0;
  204         while (size > 0) {
  205                 vm_size_t len = PAGE_SIZE - (va & PAGE_MASK);
  206                 if (len > size)
  207                         len = size;
  208                 sc->sc_regs->sgMap[i].pAddr = vtophys(va);
  209                 sc->sc_regs->sgMap[i].len = len;
  210                 size -= len;
  211                 va += len;
  212                 i++;
  213         }
  214         sc->sc_regs->sgLen = i;
  215 
  216         /*
  217          * Start the i/o.
  218          */
  219         alpha_wmb();
  220         sc->sc_regs->startIO = 1;
  221         alpha_wmb();
  222 
  223         splx(s);
  224 }
  225 
  226 static void
  227 simos_done(struct simos_softc* sc)
  228 {
  229         struct ccb_scsiio* csio = sc->sc_pending;
  230         int s, done;
  231 
  232         /*
  233          * Spurious interrupt caused by my bogus interrupt broadcasting.
  234          */
  235         if (!csio)
  236                 return;
  237 
  238         sc->sc_pending = 0;
  239 
  240         done = sc->sc_regs->done[csio->ccb_h.target_id];
  241         if (!done)
  242                 return;
  243 
  244         s = splcam();
  245 
  246         if (done >> 16)
  247                 /* Error detected */
  248                 csio->ccb_h.status = CAM_CMD_TIMEOUT;
  249         else
  250                 csio->ccb_h.status = CAM_REQ_CMP;
  251 
  252         /*
  253          * Ack the interrupt to clear it.
  254          */
  255         sc->sc_regs->done[csio->ccb_h.target_id] = 1;
  256         alpha_wmb();
  257         
  258         xpt_done((union ccb *) csio);
  259 
  260         splx(s);
  261 }
  262 
  263 static void
  264 simos_action(struct cam_sim *sim, union ccb *ccb)
  265 {
  266         struct simos_softc* sc = (struct simos_softc *)sim->softc;
  267 
  268         switch (ccb->ccb_h.func_code) {
  269         case XPT_SCSI_IO:
  270         {
  271                 struct ccb_scsiio *csio;
  272 
  273                 csio = &ccb->csio;
  274                 simos_start(sc, csio);
  275                 break;
  276         }
  277 
  278         case XPT_CALC_GEOMETRY:
  279         {
  280                 struct    ccb_calc_geometry *ccg;
  281                 u_int32_t size_mb;
  282                 u_int32_t secs_per_cylinder;
  283 
  284                 ccg = &ccb->ccg;
  285                 size_mb = ccg->volume_size
  286                         / ((1024L * 1024L) / ccg->block_size);
  287 
  288                 ccg->heads = 64;
  289                 ccg->secs_per_track = 32;
  290 
  291                 secs_per_cylinder = ccg->heads * ccg->secs_per_track;
  292                 ccg->cylinders = ccg->volume_size / secs_per_cylinder;
  293 
  294                 ccb->ccb_h.status = CAM_REQ_CMP;
  295                 xpt_done(ccb);
  296                 break;
  297         }
  298 
  299         case XPT_RESET_BUS:
  300         {
  301                 ccb->ccb_h.status = CAM_REQ_CMP;
  302                 xpt_done(ccb);
  303                 break;
  304         }
  305 
  306         case XPT_PATH_INQ:
  307         {
  308                 struct ccb_pathinq *cpi = &ccb->cpi;
  309                 
  310                 cpi->version_num = 1; /* XXX??? */
  311                 cpi->max_target = 2;
  312                 cpi->max_lun = 0;
  313                 cpi->initiator_id = 7;
  314                 cpi->bus_id = sim->bus_id;
  315                 cpi->base_transfer_speed = 3300;
  316                 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
  317                 strncpy(cpi->hba_vid, "SimOS", HBA_IDLEN);
  318                 strncpy(cpi->dev_name, sim->sim_name, DEV_IDLEN);
  319                 cpi->unit_number = sim->unit_number;
  320 
  321                 cpi->ccb_h.status = CAM_REQ_CMP;
  322                 xpt_done(ccb);
  323                 break;
  324         }
  325 
  326         default:
  327                 ccb->ccb_h.status = CAM_REQ_INVALID;
  328                 xpt_done(ccb);
  329                 break;
  330         }
  331 }
  332 
  333 static void
  334 simos_poll(struct cam_sim *sim)
  335 {       
  336         simos_done(cam_sim_softc(sim));
  337 }
  338 
  339 void
  340 simos_intr(int unit)
  341 {
  342         /* XXX bogus */
  343         struct simos_softc* sc = simosp[unit];
  344 
  345         simos_done(sc);
  346 }

Cache object: 8beb19c464b2191f3f7a1798d629c50b


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.