2 * Copyright (c) 2010, LSI Corp.
4 * Author : Manjunath Ranganathaiah
5 * Support: freebsdraid@lsi.com
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of the <ORGANIZATION> nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
37 #include <dev/tws/tws.h>
38 #include <dev/tws/tws_services.h>
39 #include <dev/tws/tws_hdm.h>
40 #include <dev/tws/tws_user.h>
43 int tws_ioctl(struct cdev *dev, long unsigned int cmd, caddr_t buf, int flags,
45 void tws_passthru_complete(struct tws_request *req);
46 extern void tws_circular_aenq_insert(struct tws_softc *sc,
47 struct tws_circular_q *cq, struct tws_event_packet *aen);
50 static int tws_passthru(struct tws_softc *sc, void *buf);
51 static int tws_ioctl_aen(struct tws_softc *sc, u_long cmd, void *buf);
53 extern int tws_bus_scan(struct tws_softc *sc);
54 extern struct tws_request *tws_get_request(struct tws_softc *sc,
56 extern int32_t tws_map_request(struct tws_softc *sc, struct tws_request *req);
57 extern void tws_unmap_request(struct tws_softc *sc, struct tws_request *req);
58 extern uint8_t tws_get_state(struct tws_softc *sc);
59 extern void tws_timeout(void *arg);
62 tws_ioctl(struct cdev *dev, u_long cmd, caddr_t buf, int flags,
65 struct tws_softc *sc = (struct tws_softc *)(dev->si_drv1);
68 TWS_TRACE_DEBUG(sc, "entry", sc, cmd);
71 case TWS_IOCTL_FIRMWARE_PASS_THROUGH :
72 error = tws_passthru(sc, (void *)buf);
74 case TWS_IOCTL_SCAN_BUS :
75 TWS_TRACE_DEBUG(sc, "scan-bus", 0, 0);
76 error = tws_bus_scan(sc);
79 TWS_TRACE_DEBUG(sc, "ioctl-aen", cmd, buf);
80 error = tws_ioctl_aen(sc, cmd, (void *)buf);
88 tws_passthru(struct tws_softc *sc, void *buf)
90 struct tws_request *req;
91 struct tws_ioctl_no_data_buf *ubuf = (struct tws_ioctl_no_data_buf *)buf;
96 if ( tws_get_state(sc) != TWS_ONLINE) {
100 //==============================================================================================
104 req = tws_get_request(sc, TWS_REQ_TYPE_PASSTHRU);
106 sc->chan = (void *)sc;
107 error = tsleep(sc->chan, 0, "tws_sleep", TWS_IOCTL_TIMEOUT*hz);
108 if ( error == EWOULDBLOCK ) {
112 // Make sure we are still ready for new commands...
113 if ( tws_get_state(sc) != TWS_ONLINE) {
120 req->length = (ubuf->driver_pkt.buffer_length + 511) & ~511;
121 TWS_TRACE_DEBUG(sc, "datal,rid", req->length, req->request_id);
123 req->data = sc->ioctl_data_mem;
124 req->dma_map = sc->ioctl_data_map;
126 //==========================================================================================
127 // Copy data in from user space
129 error = copyin(ubuf->pdata, req->data, req->length);
132 //==============================================================================================
133 // Set command fields
135 req->flags = TWS_DIR_IN | TWS_DIR_OUT;
136 req->cb = tws_passthru_complete;
138 memcpy(&req->cmd_pkt->cmd, &ubuf->cmd_pkt.cmd,
139 sizeof(struct tws_command_apache));
141 if ( GET_OPCODE(req->cmd_pkt->cmd.pkt_a.res__opcode) ==
142 TWS_FW_CMD_EXECUTE_SCSI ) {
143 lun4 = req->cmd_pkt->cmd.pkt_a.lun_l4__req_id & 0xF000;
144 req->cmd_pkt->cmd.pkt_a.lun_l4__req_id = lun4 | req->request_id;
146 req->cmd_pkt->cmd.pkt_g.generic.request_id = (u_int8_t) req->request_id;
149 //==============================================================================================
150 // Send command to controller
152 error = tws_map_request(sc, req);
154 ubuf->driver_pkt.os_status = error;
158 if ( req->state == TWS_REQ_STATE_COMPLETE ) {
159 ubuf->driver_pkt.os_status = req->error_code;
163 mtx_lock(&sc->gen_lock);
164 error = mtx_sleep(req, &sc->gen_lock, 0, "tws_passthru", TWS_IOCTL_TIMEOUT*hz);
165 mtx_unlock(&sc->gen_lock);
166 if (( req->state != TWS_REQ_STATE_COMPLETE ) && ( error == EWOULDBLOCK )) {
167 TWS_TRACE_DEBUG(sc, "msleep timeout", error, req->request_id);
168 tws_timeout((void*) req);
172 if ( req->error_code == TWS_REQ_RET_RESET ) {
174 req->error_code = EBUSY;
175 TWS_TRACE_DEBUG(sc, "ioctl reset", error, req->request_id);
178 tws_unmap_request(sc, req);
180 //==============================================================================================
181 // Return command status to user space
183 memcpy(&ubuf->cmd_pkt.hdr, &req->cmd_pkt->hdr, sizeof(struct tws_command_apache));
184 memcpy(&ubuf->cmd_pkt.cmd, &req->cmd_pkt->cmd, sizeof(struct tws_command_apache));
188 //==========================================================================================
189 // Copy data out to user space
192 error = copyout(req->data, ubuf->pdata, ubuf->driver_pkt.buffer_length);
196 TWS_TRACE_DEBUG(sc, "errored", error, 0);
198 if ( req->error_code != TWS_REQ_RET_SUBMIT_SUCCESS )
199 ubuf->driver_pkt.os_status = error;
201 //==============================================================================================
204 req->state = TWS_REQ_STATE_FREE;
206 wakeup_one(sc->chan);
212 tws_passthru_complete(struct tws_request *req)
214 req->state = TWS_REQ_STATE_COMPLETE;
220 tws_retrive_aen(struct tws_softc *sc, u_long cmd,
221 struct tws_ioctl_packet *ubuf)
224 struct tws_event_packet eventp, *qp;
226 if ( sc->aen_q.head == sc->aen_q.tail ) {
227 ubuf->driver_pkt.status = TWS_AEN_NO_EVENTS;
231 ubuf->driver_pkt.status = 0;
234 * once this flag is set cli will not display alarms
235 * needs a revisit from tools?
237 if ( sc->aen_q.overflow ) {
238 ubuf->driver_pkt.status = TWS_AEN_OVERFLOW;
239 sc->aen_q.overflow = 0; /* reset */
242 qp = (struct tws_event_packet *)sc->aen_q.q;
245 case TWS_IOCTL_GET_FIRST_EVENT :
246 index = sc->aen_q.head;
248 case TWS_IOCTL_GET_LAST_EVENT :
250 index = (sc->aen_q.depth + sc->aen_q.tail - 1) % sc->aen_q.depth;
252 case TWS_IOCTL_GET_NEXT_EVENT :
253 memcpy(&eventp, ubuf->data_buf, sizeof(struct tws_event_packet));
254 index = sc->aen_q.head;
256 if ( qp[index].sequence_id ==
257 (eventp.sequence_id + 1) )
259 index = (index+1) % sc->aen_q.depth;
260 }while ( index != sc->aen_q.tail );
261 if ( index == sc->aen_q.tail ) {
262 ubuf->driver_pkt.status = TWS_AEN_NO_EVENTS;
266 case TWS_IOCTL_GET_PREVIOUS_EVENT :
267 memcpy(&eventp, ubuf->data_buf, sizeof(struct tws_event_packet));
268 index = sc->aen_q.head;
270 if ( qp[index].sequence_id ==
271 (eventp.sequence_id - 1) )
273 index = (index+1) % sc->aen_q.depth;
274 }while ( index != sc->aen_q.tail );
275 if ( index == sc->aen_q.tail ) {
276 ubuf->driver_pkt.status = TWS_AEN_NO_EVENTS;
281 TWS_TRACE_DEBUG(sc, "not a valid event", sc, cmd);
282 ubuf->driver_pkt.status = TWS_AEN_NO_EVENTS;
286 memcpy(ubuf->data_buf, &qp[index],
287 sizeof(struct tws_event_packet));
288 qp[index].retrieved = TWS_AEN_RETRIEVED;
295 tws_ioctl_aen(struct tws_softc *sc, u_long cmd, void *buf)
298 struct tws_ioctl_packet *ubuf = (struct tws_ioctl_packet *)buf;
299 struct tws_compatibility_packet cpkt;
300 struct tws_lock_packet lpkt;
303 mtx_lock(&sc->gen_lock);
304 ubuf->driver_pkt.status = 0;
306 case TWS_IOCTL_GET_FIRST_EVENT :
307 case TWS_IOCTL_GET_LAST_EVENT :
308 case TWS_IOCTL_GET_NEXT_EVENT :
309 case TWS_IOCTL_GET_PREVIOUS_EVENT :
310 tws_retrive_aen(sc,cmd,ubuf);
312 case TWS_IOCTL_GET_LOCK :
313 ctime = TWS_LOCAL_TIME;
314 memcpy(&lpkt, ubuf->data_buf, sizeof(struct tws_lock_packet));
315 if ( (sc->ioctl_lock.lock == TWS_IOCTL_LOCK_FREE) ||
317 (ctime >= sc->ioctl_lock.timeout) ) {
318 sc->ioctl_lock.lock = TWS_IOCTL_LOCK_HELD;
319 sc->ioctl_lock.timeout = ctime + (lpkt.timeout_msec / 1000);
320 lpkt.time_remaining_msec = lpkt.timeout_msec;
322 lpkt.time_remaining_msec = (u_int32_t)
323 ((sc->ioctl_lock.timeout - ctime) * 1000);
324 ubuf->driver_pkt.status = TWS_IOCTL_LOCK_ALREADY_HELD;
328 case TWS_IOCTL_RELEASE_LOCK :
329 if (sc->ioctl_lock.lock == TWS_IOCTL_LOCK_FREE) {
330 ubuf->driver_pkt.status = TWS_IOCTL_LOCK_NOT_HELD;
332 sc->ioctl_lock.lock = TWS_IOCTL_LOCK_FREE;
333 ubuf->driver_pkt.status = 0;
336 case TWS_IOCTL_GET_COMPATIBILITY_INFO :
337 TWS_TRACE_DEBUG(sc, "get comp info", sc, cmd);
339 memcpy( cpkt.driver_version, TWS_DRIVER_VERSION_STRING,
340 sizeof(TWS_DRIVER_VERSION_STRING));
341 cpkt.working_srl = sc->cinfo.working_srl;
342 cpkt.working_branch = sc->cinfo.working_branch;
343 cpkt.working_build = sc->cinfo.working_build;
344 cpkt.driver_srl_high = TWS_CURRENT_FW_SRL;
345 cpkt.driver_branch_high = TWS_CURRENT_FW_BRANCH;
346 cpkt.driver_build_high = TWS_CURRENT_FW_BUILD;
347 cpkt.driver_srl_low = TWS_BASE_FW_SRL;
348 cpkt.driver_branch_low = TWS_BASE_FW_BRANCH;
349 cpkt.driver_build_low = TWS_BASE_FW_BUILD;
350 cpkt.fw_on_ctlr_srl = sc->cinfo.fw_on_ctlr_srl;
351 cpkt.fw_on_ctlr_branch = sc->cinfo.fw_on_ctlr_branch;
352 cpkt.fw_on_ctlr_build = sc->cinfo.fw_on_ctlr_build;
353 ubuf->driver_pkt.status = 0;
354 int len = sizeof(struct tws_compatibility_packet);
355 if ( ubuf->driver_pkt.buffer_length < len )
356 len = ubuf->driver_pkt.buffer_length;
357 memcpy(ubuf->data_buf, &cpkt, len);
361 TWS_TRACE_DEBUG(sc, "not valid cmd", cmd,
362 TWS_IOCTL_GET_COMPATIBILITY_INFO);
366 mtx_unlock(&sc->gen_lock);
372 tws_circular_aenq_insert(struct tws_softc *sc, struct tws_circular_q *cq,
373 struct tws_event_packet *aen)
376 struct tws_event_packet *q = (struct tws_event_packet *)cq->q;
377 volatile u_int16_t head, tail;
379 mtx_assert(&sc->gen_lock, MA_OWNED);
383 retr = q[tail].retrieved;
385 memcpy(&q[tail], aen, sizeof(struct tws_event_packet));
386 tail = (tail+1) % cq->depth;
388 if ( head == tail ) { /* q is full */
389 if ( retr != TWS_AEN_RETRIEVED )
391 cq->head = (head+1) % cq->depth;