Merge branch 'vendor/LIBPCAP' (early part)
[dragonfly.git] / 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.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 }