sys/dev/disk/ispfw/ispfw.c

   1 /* $FreeBSD: src/sys/dev/ispfw/ispfw.c,v 1.2.2.5 2002/10/12 00:13:09 mjacob Exp $ */
   2 /* $DragonFly: src/sys/dev/disk/ispfw/ispfw.c,v 1.7 2006/09/05 03:48:10 dillon Exp $ */
   3 /*
   4  * ISP Firmware Helper Pseudo Device for FreeBSD
   5  *
   6  * Copyright (c) 2000, by Matthew Jacob
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice immediately at the beginning of the file, without modification,
  14  *    this list of conditions, and the following disclaimer.
  15  * 2. 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 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/buf.h>
  34 #include <sys/disk.h>
  35 #include <sys/kernel.h>
  36 #include <sys/malloc.h>
  37 #include <sys/linker.h>
  38
  39 #include "asm_1040.h"
  40 #include "asm_1080.h"
  41 #include "asm_12160.h"
  42 #include "asm_2100.h"
  43 #include "asm_2200.h"
  44 #include "asm_2300.h"
  45
  46 #define ISPFW_VERSION   0
  47
  48 #define PCI_PRODUCT_QLOGIC_ISP1020      0x1020
  49 #define PCI_PRODUCT_QLOGIC_ISP1080      0x1080
  50 #define PCI_PRODUCT_QLOGIC_ISP10160     0x1016
  51 #define PCI_PRODUCT_QLOGIC_ISP12160     0x1216
  52 #define PCI_PRODUCT_QLOGIC_ISP1240      0x1240
  53 #define PCI_PRODUCT_QLOGIC_ISP1280      0x1280
  54 #define PCI_PRODUCT_QLOGIC_ISP2100      0x2100
  55 #define PCI_PRODUCT_QLOGIC_ISP2200      0x2200
  56 #define PCI_PRODUCT_QLOGIC_ISP2300      0x2300
  57 #define PCI_PRODUCT_QLOGIC_ISP2312      0x2312
  58
  59 typedef void ispfwfunc (int, int, int, const u_int16_t **);
  60 extern ispfwfunc *isp_get_firmware_p;
  61 static void isp_get_firmware (int, int, int, const u_int16_t **);
  62
  63 static int ncallers = 0;
  64 static const u_int16_t ***callp = NULL;
  65 static int addcaller(const u_int16_t **);
  66
  67 static int
  68 addcaller(const u_int16_t **caller)
  69 {
  70         const u_int16_t ***newcallp;
  71         int i;
  72         for (i = 0; i < ncallers; i++) {
  73                 if (callp[i] == caller)
  74                         return (1);
  75         }
  76         newcallp = kmalloc((ncallers + 1) * sizeof (const u_int16_t ***),
  77             M_DEVBUF, M_WAITOK);
  78         for (i = 0; i < ncallers; i++) {
  79                 newcallp[i] = callp[i];
  80         }
  81         newcallp[ncallers] = caller;
  82         if (ncallers++)
  83                 kfree(callp, M_DEVBUF);
  84         callp = newcallp;
  85         return (1);
  86 }
  87
  88 static void
  89 isp_get_firmware(int version, int tgtmode, int devid, const u_int16_t **ptrp)
  90 {
  91         const u_int16_t *rp = NULL;
  92
  93         if (version == ISPFW_VERSION) {
  94                 switch (devid) {
  95                 case PCI_PRODUCT_QLOGIC_ISP1020:
  96                         if (tgtmode)
  97                                 rp = isp_1040_risc_code_it;
  98                         else
  99                                 rp = isp_1040_risc_code;
 100                         break;
 101                 case PCI_PRODUCT_QLOGIC_ISP1080:
 102                 case PCI_PRODUCT_QLOGIC_ISP1240:
 103                 case PCI_PRODUCT_QLOGIC_ISP1280:
 104                         if (tgtmode)
 105                                 rp = isp_1080_risc_code_it;
 106                         else
 107                                 rp = isp_1080_risc_code;
 108                         break;
 109                 case PCI_PRODUCT_QLOGIC_ISP10160:
 110                 case PCI_PRODUCT_QLOGIC_ISP12160:
 111                         if (tgtmode)
 112                                 rp = isp_12160_risc_code_it;
 113                         else
 114                                 rp = isp_12160_risc_code;
 115                         break;
 116                 case PCI_PRODUCT_QLOGIC_ISP2100:
 117                         rp = isp_2100_risc_code;
 118                         break;
 119                 case PCI_PRODUCT_QLOGIC_ISP2200:
 120                         rp = isp_2200_risc_code;
 121                         break;
 122                 case PCI_PRODUCT_QLOGIC_ISP2300:
 123                 case PCI_PRODUCT_QLOGIC_ISP2312:
 124                         rp = isp_2300_risc_code;
 125                         break;
 126                 default:
 127                         break;
 128                 }
 129         }
 130         if (rp && addcaller(ptrp)) {
 131                 *ptrp = rp;
 132         }
 133 }
 134
 135 static int
 136 isp_module_handler(module_t mod, int what, void *arg)
 137 {
 138         switch (what) {
 139         case MOD_LOAD:
 140                 isp_get_firmware_p = isp_get_firmware;
 141                 break;
 142         case MOD_UNLOAD:
 143                 isp_get_firmware_p = NULL;
 144                 if (ncallers)  {
 145                         int i;
 146                         for (i = 0; i < ncallers; i++) {
 147                                 *callp[i] = NULL;
 148                         }
 149                         kfree(callp, M_DEVBUF);
 150                 }
 151                 break;
 152         default:
 153                 break;
 154         }
 155         return (0);
 156 }
 157 static moduledata_t ispfw_mod = {
 158         "ispfw", isp_module_handler, NULL
 159 };
 160 DECLARE_MODULE(ispfw, ispfw_mod, SI_SUB_DRIVERS, SI_ORDER_THIRD);