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