usr.sbin/mlxcontrol/interface.c

   1 /*-
   2  * Copyright (c) 1999 Michael Smith
   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: src/usr.sbin/mlxcontrol/interface.c,v 1.3 2008/09/12 17:40:17 sepotvin Exp $
  27  */
  28
  29 #include <fcntl.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <cam/scsi/scsi_all.h>
  35
  36 #include <dev/raid/mlx/mlxio.h>
  37 #include <dev/raid/mlx/mlxreg.h>
  38
  39 #include "mlxcontrol.h"
  40
  41 /********************************************************************************
  42  * Iterate over all mlx devices, call (func) with each ones' path and (arg)
  43  */
  44 void
  45 mlx_foreach(void (*func)(int unit, void *arg), void *arg)
  46 {
  47     int         i, fd;
  48
  49     /* limit total count for sanity */
  50     for (i = 0; i < 64; i++) {
  51         /* verify we can open it */
  52         if ((fd = open(ctrlrpath(i), 0)) >= 0)
  53             close(fd);
  54         /* if we can, do */
  55         if (fd >= 0) {
  56             func(i, arg);
  57         }
  58     }
  59 }
  60
  61 /********************************************************************************
  62  * Open the controller (unit) and give the fd to (func) along with (arg)
  63  */
  64 void
  65 mlx_perform(int unit, void (*func)(int fd, void *arg), void *arg)
  66 {
  67     int         fd;
  68
  69     if ((fd = open(ctrlrpath(unit), 0)) >= 0) {
  70         func(fd, arg);
  71         close(fd);
  72     }
  73 }
  74
  75 /********************************************************************************
  76  * Iterate over all mlxd devices, call (func) with each ones' path and (arg)
  77  */
  78 void
  79 mlxd_foreach_ctrlr(int unit, void *arg)
  80 {
  81     struct mlxd_foreach_action  *ma = (struct mlxd_foreach_action *)arg;
  82     int                         i, fd, ctrlfd;
  83
  84     /* Get the device */
  85     if ((ctrlfd = open(ctrlrpath(unit), 0)) < 0)
  86         return;
  87
  88     for (i = -1; ;) {
  89         /* Get the unit number of the next child device */
  90         if (ioctl(ctrlfd, MLX_NEXT_CHILD, &i) < 0) {
  91             close(ctrlfd);
  92             return;
  93         }
  94
  95         /* check that we can open this unit */
  96         if ((fd = open(drivepath(i), 0)) >= 0)
  97             close(fd);
  98         /* if we can, do */
  99         if (fd >= 0) {
 100             ma->func(i, ma->arg);
 101         }
 102     }
 103 }
 104
 105 void
 106 mlxd_foreach(void (*func)(int unit, void *arg), void *arg)
 107 {
 108     struct mlxd_foreach_action ma;
 109
 110     ma.func = func;
 111     ma.arg = arg;
 112     mlx_foreach(mlxd_foreach_ctrlr, &ma);
 113 }
 114
 115 /********************************************************************************
 116  * Find the controller that manages the drive (unit), return controller number
 117  * and system drive number on that controller.
 118  */
 119 static struct
 120 {
 121     int         unit;
 122     int         ctrlr;
 123     int         sysdrive;
 124 } mlxd_find_ctrlr_param;
 125
 126 static void
 127 mlxd_find_ctrlr_search(int unit, void *arg __unused)
 128 {
 129     int                         i, fd;
 130
 131     /* Get the device */
 132     if ((fd = open(ctrlrpath(unit), 0)) >= 0) {
 133         for (i = -1; ;) {
 134             /* Get the unit number of the next child device */
 135             if (ioctl(fd, MLX_NEXT_CHILD, &i) < 0)
 136                 break;
 137
 138             /* is this child the unit we want? */
 139             if (i == mlxd_find_ctrlr_param.unit) {
 140                 mlxd_find_ctrlr_param.ctrlr = unit;
 141                 if (ioctl(fd, MLX_GET_SYSDRIVE, &i) == 0)
 142                     mlxd_find_ctrlr_param.sysdrive = i;
 143             }
 144         }
 145         close(fd);
 146     }
 147 }
 148
 149 int
 150 mlxd_find_ctrlr(int unit, int *ctrlr, int *sysdrive)
 151 {
 152     mlxd_find_ctrlr_param.unit = unit;
 153     mlxd_find_ctrlr_param.ctrlr = -1;
 154     mlxd_find_ctrlr_param.sysdrive = -1;
 155
 156     mlx_foreach(mlxd_find_ctrlr_search, NULL);
 157     if ((mlxd_find_ctrlr_param.ctrlr != -1) && (mlxd_find_ctrlr_param.sysdrive != -1)) {
 158         *ctrlr = mlxd_find_ctrlr_param.ctrlr;
 159         *sysdrive = mlxd_find_ctrlr_param.sysdrive;
 160         return(0);
 161     }
 162     return(1);
 163 }
 164
 165
 166 /********************************************************************************
 167  * Send a command to the controller on (fd)
 168  */
 169
 170 void
 171 mlx_command(int fd, void *arg)
 172 {
 173     struct mlx_usercommand      *cmd = (struct mlx_usercommand *)arg;
 174     int                         error;
 175
 176     error = ioctl(fd, MLX_COMMAND, cmd);
 177     if (error != 0)
 178         cmd->mu_error = error;
 179 }
 180
 181 /********************************************************************************
 182  * Perform an ENQUIRY2 command and return information related to the controller
 183  * (unit)
 184  */
 185 int
 186 mlx_enquiry(int unit, struct mlx_enquiry2 *enq)
 187 {
 188     struct mlx_usercommand      cmd;
 189
 190     /* build the command */
 191     cmd.mu_datasize = sizeof(*enq);
 192     cmd.mu_buf = enq;
 193     cmd.mu_bufptr = 8;
 194     cmd.mu_command[0] = MLX_CMD_ENQUIRY2;
 195
 196     /* hand it off for processing */
 197     mlx_perform(unit, mlx_command, &cmd);
 198
 199     return(cmd.mu_status != 0);
 200 }
 201
 202
 203 /********************************************************************************
 204  * Perform a READ CONFIGURATION command and return information related to the controller
 205  * (unit)
 206  */
 207 int
 208 mlx_read_configuration(int unit, struct mlx_core_cfg *cfg)
 209 {
 210     struct mlx_usercommand      cmd;
 211
 212     /* build the command */
 213     cmd.mu_datasize = sizeof(*cfg);
 214     cmd.mu_buf = cfg;
 215     cmd.mu_bufptr = 8;
 216     cmd.mu_command[0] = MLX_CMD_READ_CONFIG;
 217
 218     /* hand it off for processing */
 219     mlx_perform(unit, mlx_command, &cmd);
 220
 221     return(cmd.mu_status != 0);
 222 }
 223
 224 /********************************************************************************
 225  * Perform a SCSI INQUIRY command and return pointers to the relevant data.
 226  */
 227 int
 228 mlx_scsi_inquiry(int unit, int channel, int target, char **vendor, char **device, char **revision)
 229 {
 230     struct mlx_usercommand      cmd;
 231     static struct {
 232             struct mlx_dcdb             dcdb;
 233             union {
 234                 struct scsi_inquiry_data        inq;
 235                 u_int8_t                        pad[SHORT_INQUIRY_LENGTH];
 236             } d;
 237     } __attribute__ ((packed))          dcdb_cmd;
 238     struct scsi_inquiry         *inq_cmd = (struct scsi_inquiry *)&dcdb_cmd.dcdb.dcdb_cdb[0];
 239
 240     /* build the command */
 241     cmd.mu_datasize = sizeof(dcdb_cmd);
 242     cmd.mu_buf = &dcdb_cmd;
 243     cmd.mu_command[0] = MLX_CMD_DIRECT_CDB;
 244
 245     /* build the DCDB */
 246     bzero(&dcdb_cmd, sizeof(dcdb_cmd));
 247     dcdb_cmd.dcdb.dcdb_channel = channel;
 248     dcdb_cmd.dcdb.dcdb_target = target;
 249     dcdb_cmd.dcdb.dcdb_flags = MLX_DCDB_DATA_IN | MLX_DCDB_TIMEOUT_10S;
 250     dcdb_cmd.dcdb.dcdb_datasize = SHORT_INQUIRY_LENGTH;
 251     dcdb_cmd.dcdb.dcdb_cdb_length = 6;
 252     dcdb_cmd.dcdb.dcdb_sense_length = SSD_FULL_SIZE;
 253
 254     /* build the cdb */
 255     inq_cmd->opcode = INQUIRY;
 256     inq_cmd->length = SHORT_INQUIRY_LENGTH;
 257
 258     /* hand it off for processing */
 259     mlx_perform(unit, mlx_command, &cmd);
 260
 261     if (cmd.mu_status == 0) {
 262         *vendor = &dcdb_cmd.d.inq.vendor[0];
 263         *device = &dcdb_cmd.d.inq.product[0];
 264         *revision = &dcdb_cmd.d.inq.revision[0];
 265     }
 266     return(cmd.mu_status);
 267 }
 268
 269 /********************************************************************************
 270  * Perform a GET DEVICE STATE command and return pointers to the relevant data.
 271  */
 272 int
 273 mlx_get_device_state(int unit, int channel, int target, struct mlx_phys_drv *drv)
 274 {
 275     struct mlx_usercommand      cmd;
 276
 277     /* build the command */
 278     cmd.mu_datasize = sizeof(*drv);
 279     cmd.mu_buf = drv;
 280     cmd.mu_bufptr = 8;
 281     cmd.mu_command[0] = MLX_CMD_DEVICE_STATE;
 282     cmd.mu_command[2] = channel;
 283     cmd.mu_command[3] = target;
 284
 285     /* hand it off for processing */
 286     mlx_perform(unit, mlx_command, &cmd);
 287
 288     return(cmd.mu_status != 0);
 289 }