sys/dev/raid/iir/iir_ctrl.c

   1 /* $FreeBSD: src/sys/dev/iir/iir_ctrl.c,v 1.2.2.4 2002/05/05 08:18:12 asmodai Exp $ */
   2 /*
   3  *       Copyright (c) 2000-01 Intel Corporation
   4  *       All Rights Reserved
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions, and the following disclaimer,
  11  *    without modification, immediately at the beginning of the file.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 /*
  32  * iir_ctrl.c: Control functions and /dev entry points for /dev/iir*
  33  *
  34  * Written by: Achim Leubner <achim.leubner@intel.com>
  35  * Fixes/Additions: Boji Tony Kannanthanam <boji.t.kannanthanam@intel.com>
  36  *
  37  * TODO:
  38  */
  39
  40 #ident "$Id: iir_ctrl.c 1.2 2001/07/18 11:17:22 achim Exp $"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/malloc.h>
  45 #include <sys/kernel.h>
  46 #include <sys/uio.h>
  47 #include <sys/conf.h>
  48 #include <sys/stat.h>
  49 #include <sys/disklabel.h>
  50 #include <machine/bus.h>
  51 #include <vm/vm.h>
  52 #include <vm/vm_kern.h>
  53 #include <vm/vm_extern.h>
  54 #include <vm/pmap.h>
  55
  56 #include <dev/iir/iir.h>
  57
  58 /* Entry points and other prototypes */
  59 static struct gdt_softc *gdt_minor2softc(int minor_no);
  60
  61 static d_open_t         iir_open;
  62 static d_close_t        iir_close;
  63 static d_write_t        iir_write;
  64 static d_read_t         iir_read;
  65 static d_ioctl_t        iir_ioctl;
  66
  67 #define CDEV_MAJOR          IIR_CDEV_MAJOR
  68
  69 /* Normally, this is a static structure.  But we need it in pci/iir_pci.c */
  70 static struct cdevsw iir_cdevsw = {
  71         /* open */      iir_open,
  72         /* close */     iir_close,
  73         /* read */      iir_read,
  74         /* write */     iir_write,
  75         /* ioctl */     iir_ioctl,
  76         /* poll */      nopoll,
  77         /* mmap */      nommap,
  78         /* strategy */  nostrategy,
  79         /* name */      "iir",
  80         /* maj */       CDEV_MAJOR,
  81         /* dump */      nodump,
  82         /* psize */     nopsize,
  83         /* flags */     0,
  84         /* bmaj */      -1
  85 };
  86
  87 static int iir_devsw_installed = 0;
  88 #ifndef SDEV_PER_HBA
  89 static int sdev_made = 0;
  90 #endif
  91 extern int gdt_cnt;
  92 extern char ostype[];
  93 extern char osrelease[];
  94 extern gdt_statist_t gdt_stat;
  95
  96 /*
  97  * Given a controller number,
  98  * make a special device and return the dev_t
  99  */
 100 dev_t
 101 gdt_make_dev(int unit)
 102 {
 103     dev_t dev;
 104
 105 #ifdef SDEV_PER_HBA
 106     dev = make_dev(&iir_cdevsw, hba2minor(unit), UID_ROOT, GID_OPERATOR,
 107                    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, "iir%d", unit);
 108 #else
 109     if (sdev_made)
 110         return (0);
 111     dev = make_dev(&iir_cdevsw, 0, UID_ROOT, GID_OPERATOR,
 112                    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, "iir");
 113     sdev_made = 1;
 114 #endif
 115     return (dev);
 116 }
 117
 118 void
 119 gdt_destroy_dev(dev_t dev)
 120 {
 121     if (dev != NULL)
 122         destroy_dev(dev);
 123 }
 124
 125 /*
 126  * Given a minor device number,
 127  * return the pointer to its softc structure
 128  */
 129 static struct gdt_softc *
 130 gdt_minor2softc(int minor_no)
 131 {
 132     struct gdt_softc *gdt;
 133     int hanum;
 134
 135 #ifdef SDEV_PER_HBA
 136     hanum = minor2hba(minor_no);
 137 #else
 138     hanum = minor_no;
 139 #endif
 140
 141     for (gdt = TAILQ_FIRST(&gdt_softcs);
 142          gdt != NULL && gdt->sc_hanum != hanum;
 143          gdt = TAILQ_NEXT(gdt, links));
 144
 145     return (gdt);
 146 }
 147
 148 static int
 149 iir_open(dev_t dev, int flags, int fmt, d_thread_t * p)
 150 {
 151     GDT_DPRINTF(GDT_D_DEBUG, ("iir_open()\n"));
 152
 153 #ifdef SDEV_PER_HBA
 154     int minor_no;
 155     struct gdt_softc *gdt;
 156
 157     minor_no = minor(dev);
 158     gdt = gdt_minor2softc(minor_no);
 159     if (gdt == NULL)
 160         return (ENXIO);
 161 #endif
 162
 163     return (0);
 164 }
 165
 166 static int
 167 iir_close(dev_t dev, int flags, int fmt, d_thread_t * p)
 168 {
 169     GDT_DPRINTF(GDT_D_DEBUG, ("iir_close()\n"));
 170
 171 #ifdef SDEV_PER_HBA
 172     int minor_no;
 173     struct gdt_softc *gdt;
 174
 175     minor_no = minor(dev);
 176     gdt = gdt_minor2softc(minor_no);
 177     if (gdt == NULL)
 178         return (ENXIO);
 179 #endif
 180
 181     return (0);
 182 }
 183
 184 static int
 185 iir_write(dev_t dev, struct uio * uio, int ioflag)
 186 {
 187     GDT_DPRINTF(GDT_D_DEBUG, ("iir_write()\n"));
 188
 189 #ifdef SDEV_PER_HBA
 190     int minor_no;
 191     struct gdt_softc *gdt;
 192
 193     minor_no = minor(dev);
 194     gdt = gdt_minor2softc(minor_no);
 195     if (gdt == NULL)
 196         return (ENXIO);
 197 #endif
 198
 199     return (0);
 200 }
 201
 202 static int
 203 iir_read(dev_t dev, struct uio * uio, int ioflag)
 204 {
 205     GDT_DPRINTF(GDT_D_DEBUG, ("iir_read()\n"));
 206
 207 #ifdef SDEV_PER_HBA
 208     int minor_no;
 209     struct gdt_softc *gdt;
 210
 211     minor_no = minor(dev);
 212     gdt = gdt_minor2softc(minor_no);
 213     if (gdt == NULL)
 214         return (ENXIO);
 215 #endif
 216
 217     return (0);
 218 }
 219
 220 /**
 221  * This is the control syscall interface.
 222  * It should be binary compatible with UnixWare,
 223  * if not totally syntatically so.
 224  */
 225
 226 static int
 227 iir_ioctl(dev_t dev, u_long cmd, caddr_t cmdarg, int flags, d_thread_t * p)
 228 {
 229     GDT_DPRINTF(GDT_D_DEBUG, ("iir_ioctl() cmd 0x%lx\n",cmd));
 230
 231 #ifdef SDEV_PER_HBA
 232     int minor_no;
 233     struct gdt_softc *gdt;
 234
 235     minor_no = minor(dev);
 236     gdt = gdt_minor2softc(minor_no);
 237     if (gdt == NULL)
 238         return (ENXIO);
 239 #endif
 240     ++gdt_stat.io_count_act;
 241     if (gdt_stat.io_count_act > gdt_stat.io_count_max)
 242         gdt_stat.io_count_max = gdt_stat.io_count_act;
 243
 244     switch (cmd) {
 245       case GDT_IOCTL_GENERAL:
 246         {
 247             gdt_ucmd_t *ucmd;
 248             struct gdt_softc *gdt;
 249             int lock;
 250
 251             ucmd = (gdt_ucmd_t *)cmdarg;
 252             gdt = gdt_minor2softc(ucmd->io_node);
 253             if (gdt == NULL)
 254                 return (ENXIO);
 255             lock = splcam();
 256             TAILQ_INSERT_TAIL(&gdt->sc_ucmd_queue, ucmd, links);
 257             ucmd->complete_flag = FALSE;
 258             splx(lock);
 259             gdt_next(gdt);
 260             if (!ucmd->complete_flag)
 261                 (void) tsleep((void *)ucmd, PCATCH | PRIBIO, "iirucw", 0);
 262             break;
 263         }
 264
 265       case GDT_IOCTL_DRVERS:
 266         *(int *)cmdarg =
 267             (IIR_DRIVER_VERSION << 8) | IIR_DRIVER_SUBVERSION;
 268         break;
 269
 270       case GDT_IOCTL_CTRTYPE:
 271         {
 272             gdt_ctrt_t *p;
 273             struct gdt_softc *gdt;
 274
 275             p = (gdt_ctrt_t *)cmdarg;
 276             gdt = gdt_minor2softc(p->io_node);
 277             if (gdt == NULL)
 278                 return (ENXIO);
 279             p->oem_id = 0x8000;
 280             p->type = 0xfd;
 281             p->info = (gdt->sc_bus << 8) | (gdt->sc_slot << 3);
 282             p->ext_type = 0x6000 | gdt->sc_subdevice;
 283             p->device_id = gdt->sc_device;
 284             p->sub_device_id = gdt->sc_subdevice;
 285             break;
 286         }
 287
 288       case GDT_IOCTL_OSVERS:
 289         {
 290             gdt_osv_t *p;
 291
 292             p = (gdt_osv_t *)cmdarg;
 293             p->oscode = 10;
 294             p->version = osrelease[0] - '0';
 295             if (osrelease[1] == '.')
 296                 p->subversion = osrelease[2] - '0';
 297             else
 298                 p->subversion = 0;
 299             if (osrelease[3] == '.')
 300                 p->revision = osrelease[4] - '0';
 301             else
 302                 p->revision = 0;
 303             strcpy(p->name, ostype);
 304             break;
 305         }
 306
 307       case GDT_IOCTL_CTRCNT:
 308         *(int *)cmdarg = gdt_cnt;
 309         break;
 310
 311       case GDT_IOCTL_EVENT:
 312         {
 313             gdt_event_t *p;
 314             int lock;
 315
 316             p = (gdt_event_t *)cmdarg;
 317             if (p->erase == 0xff) {
 318                 if (p->dvr.event_source == GDT_ES_TEST)
 319                     p->dvr.event_data.size = sizeof(p->dvr.event_data.eu.test);
 320                 else if (p->dvr.event_source == GDT_ES_DRIVER)
 321                     p->dvr.event_data.size= sizeof(p->dvr.event_data.eu.driver);
 322                 else if (p->dvr.event_source == GDT_ES_SYNC)
 323                     p->dvr.event_data.size = sizeof(p->dvr.event_data.eu.sync);
 324                 else
 325                     p->dvr.event_data.size = sizeof(p->dvr.event_data.eu.async);
 326                 lock = splcam();
 327                 gdt_store_event(p->dvr.event_source, p->dvr.event_idx,
 328                                 &p->dvr.event_data);
 329                 splx(lock);
 330             } else if (p->erase == 0xfe) {
 331                 lock = splcam();
 332                 gdt_clear_events();
 333                 splx(lock);
 334             } else if (p->erase == 0) {
 335                 p->handle = gdt_read_event(p->handle, &p->dvr);
 336             } else {
 337                 gdt_readapp_event((u_int8_t)p->erase, &p->dvr);
 338             }
 339             break;
 340         }
 341
 342       case GDT_IOCTL_STATIST:
 343         {
 344             gdt_statist_t *p;
 345
 346             p = (gdt_statist_t *)cmdarg;
 347             bcopy(&gdt_stat, p, sizeof(gdt_statist_t));
 348             break;
 349         }
 350
 351       default:
 352         break;
 353     }
 354
 355     --gdt_stat.io_count_act;
 356     return (0);
 357 }
 358
 359 static void
 360 iir_drvinit(void *unused)
 361 {
 362     GDT_DPRINTF(GDT_D_DEBUG, ("iir_drvinit()\n"));
 363
 364     if (!iir_devsw_installed) {
 365         /* Add the I/O (data) channel */
 366         cdevsw_add(&iir_cdevsw);
 367         iir_devsw_installed = 1;
 368     }
 369 }
 370
 371 SYSINIT(iir_dev, SI_SUB_DRIVERS, SI_ORDER_MIDDLE + CDEV_MAJOR, iir_drvinit, NULL)