Add tws(4), a driver for the LSI 3ware 9750 series SATA/SAS RAID controllers.
[dragonfly.git] / sys / dev / raid / tws / tws_cam.c
1 /*
2  * Copyright (c) 2010, LSI Corp.
3  * All rights reserved.
4  * Author : Manjunath Ranganathaiah
5  * Support: freebsdraid@lsi.com
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
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
16  *    distribution.
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.
20  *
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.
33  *
34  * $FreeBSD: src/sys/dev/tws/tws_cam.c,v 1.3 2007/05/09 04:16:32 mrangana Exp $
35  */
36
37 #include <dev/raid/tws/tws.h>
38 #include <dev/raid/tws/tws_services.h>
39 #include <dev/raid/tws/tws_hdm.h>
40 #include <dev/raid/tws/tws_user.h>
41 #include <bus/cam/cam.h>
42 #include <bus/cam/cam_ccb.h>
43 #include <bus/cam/cam_sim.h>
44 #include <bus/cam/cam_xpt_sim.h>
45 #include <bus/cam/cam_debug.h>
46 #include <bus/cam/cam_periph.h>
47
48 #include <bus/cam/scsi/scsi_all.h>
49 #include <bus/cam/scsi/scsi_message.h>
50
51 static int tws_cam_depth=(TWS_MAX_REQS - TWS_RESERVED_REQS);
52 static char tws_sev_str[5][8]={"","ERROR","WARNING","INFO","DEBUG"};
53
54 static void  tws_action(struct cam_sim *sim, union ccb *ccb);
55 static void  tws_poll(struct cam_sim *sim);
56 static void tws_bus_scan_cb(struct cam_periph *periph, union ccb *ccb);
57 static void tws_scsi_complete(struct tws_request *req);
58
59
60
61 void tws_unmap_request(struct tws_softc *sc, struct tws_request *req);
62 int32_t tws_map_request(struct tws_softc *sc, struct tws_request *req);
63 int tws_bus_scan(struct tws_softc *sc);
64 int tws_cam_attach(struct tws_softc *sc);
65 void tws_cam_detach(struct tws_softc *sc);
66 void tws_reset(void *arg);
67
68 static void tws_reset_cb(void *arg);
69 static void tws_reinit(void *arg);
70 static int32_t tws_execute_scsi(struct tws_softc *sc, union ccb *ccb);
71 static void tws_freeze_simq(struct tws_softc *sc);
72 static void tws_release_simq(struct tws_softc *sc);
73 static void tws_dmamap_data_load_cbfn(void *arg, bus_dma_segment_t *segs,
74                             int nseg, int error);
75 static void tws_fill_sg_list(struct tws_softc *sc, void *sgl_src,
76                             void *sgl_dest, u_int16_t num_sgl_entries);
77 static void tws_err_complete(struct tws_softc *sc, u_int64_t mfa);
78 static void tws_scsi_err_complete(struct tws_request *req,
79                                                struct tws_command_header *hdr);
80 static void tws_passthru_err_complete(struct tws_request *req,
81                                                struct tws_command_header *hdr);
82
83
84 static void tws_timeout(void *arg);
85 static void tws_intr_attn_aen(struct tws_softc *sc);
86 static void tws_intr_attn_error(struct tws_softc *sc);
87 static void tws_intr_resp(struct tws_softc *sc);
88 void tws_intr(void *arg);
89 void tws_cmd_complete(struct tws_request *req);
90 void tws_aen_complete(struct tws_request *req);
91 int tws_send_scsi_cmd(struct tws_softc *sc, int cmd);
92 void tws_getset_param_complete(struct tws_request *req);
93 int tws_set_param(struct tws_softc *sc, u_int32_t table_id, u_int32_t param_id,
94               u_int32_t param_size, void *data);
95 int tws_get_param(struct tws_softc *sc, u_int32_t table_id, u_int32_t param_id,
96               u_int32_t param_size, void *data);
97
98
99 extern struct tws_request *tws_get_request(struct tws_softc *sc,
100                                             u_int16_t type);
101 extern void *tws_release_request(struct tws_request *req);
102 extern int tws_submit_command(struct tws_softc *sc, struct tws_request *req);
103 extern boolean tws_get_response(struct tws_softc *sc,
104                                            u_int16_t *req_id, u_int64_t *mfa);
105 extern void tws_q_insert_tail(struct tws_softc *sc, struct tws_request *req,
106                                 u_int8_t q_type );
107 extern struct tws_request * tws_q_remove_request(struct tws_softc *sc,
108                                    struct tws_request *req, u_int8_t q_type );
109 extern void tws_send_event(struct tws_softc *sc, u_int8_t event);
110
111 extern struct tws_sense *
112 tws_find_sense_from_mfa(struct tws_softc *sc, u_int64_t mfa);
113
114 extern void tws_fetch_aen(void *arg);
115 extern void tws_disable_db_intr(struct tws_softc *sc);
116 extern void tws_enable_db_intr(struct tws_softc *sc);
117 extern void tws_passthru_complete(struct tws_request *req);
118 extern void tws_aen_synctime_with_host(struct tws_softc *sc);
119 extern void tws_circular_aenq_insert(struct tws_softc *sc,
120                     struct tws_circular_q *cq, struct tws_event_packet *aen);
121 extern int tws_use_32bit_sgls;
122 extern boolean tws_ctlr_reset(struct tws_softc *sc);
123 extern struct tws_request * tws_q_remove_tail(struct tws_softc *sc,
124                                                            u_int8_t q_type );
125 extern void tws_turn_off_interrupts(struct tws_softc *sc);
126 extern void tws_turn_on_interrupts(struct tws_softc *sc);
127 extern int tws_init_connect(struct tws_softc *sc, u_int16_t mc);
128 extern void tws_init_obfl_q(struct tws_softc *sc);
129 extern uint8_t tws_get_state(struct tws_softc *sc);
130 extern void tws_assert_soft_reset(struct tws_softc *sc);
131 extern boolean tws_ctlr_ready(struct tws_softc *sc);
132 extern u_int16_t tws_poll4_response(struct tws_softc *sc, u_int64_t *mfa);
133
134
135
136 int
137 tws_cam_attach(struct tws_softc *sc)
138 {
139     struct cam_devq *devq;
140     int error;
141
142     TWS_TRACE_DEBUG(sc, "entry", 0, sc);
143     /* Create a device queue for sim */
144
145     /*
146      * if the user sets cam depth to less than 1
147      * cam may get confused
148      */
149     if ( tws_cam_depth < 1 )
150         tws_cam_depth = 1;
151     if ( tws_cam_depth > (tws_queue_depth - TWS_RESERVED_REQS)  )
152         tws_cam_depth = tws_queue_depth - TWS_RESERVED_REQS;
153
154     TWS_TRACE_DEBUG(sc, "depths,ctlr,cam", tws_queue_depth, tws_cam_depth);
155
156     if ((devq = cam_simq_alloc(tws_cam_depth)) == NULL) {
157         tws_log(sc, CAM_SIMQ_ALLOC);
158         return(ENOMEM);
159     }
160
161    /*
162     * Create a SIM entry.  Though we can support tws_cam_depth
163     * simultaneous requests, we claim to be able to handle only
164     * (tws_cam_depth), so that we always have reserved  requests
165     * packet available to service ioctls and internal commands.
166     */
167     sc->sim = cam_sim_alloc(tws_action, tws_poll, "tws", sc,
168                       device_get_unit(sc->tws_dev),
169                       &sc->sim_lock,
170                       tws_cam_depth, 1, devq);
171                       /* 1, 1, devq); */
172     cam_simq_release(devq);
173     if (sc->sim == NULL) {
174         tws_log(sc, CAM_SIM_ALLOC);
175     }
176     /* Register the bus. */
177     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
178     if (xpt_bus_register(sc->sim, 0) != CAM_SUCCESS) {
179         cam_sim_free(sc->sim);
180         sc->sim = NULL; /* so cam_detach will not try to free it */
181         lockmgr(&sc->sim_lock, LK_RELEASE);
182         tws_log(sc, TWS_XPT_BUS_REGISTER);
183         return(ENXIO);
184     }
185     if (xpt_create_path(&sc->path, NULL, cam_sim_path(sc->sim),
186                          CAM_TARGET_WILDCARD,
187                          CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
188         xpt_bus_deregister(cam_sim_path(sc->sim));
189         cam_sim_free(sc->sim);
190         tws_log(sc, TWS_XPT_CREATE_PATH);
191         lockmgr(&sc->sim_lock, LK_RELEASE);
192         return(ENXIO);
193     }
194     if ((error = tws_bus_scan(sc))) {
195         tws_log(sc, TWS_BUS_SCAN_REQ);
196         lockmgr(&sc->sim_lock, LK_RELEASE);
197         return(error);
198     }
199     lockmgr(&sc->sim_lock, LK_RELEASE);
200
201     return(0);
202 }
203
204 void
205 tws_cam_detach(struct tws_softc *sc)
206 {
207     TWS_TRACE_DEBUG(sc, "entry", 0, 0);
208     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
209     if (sc->path)
210         xpt_free_path(sc->path);
211     if (sc->sim) {
212         xpt_bus_deregister(cam_sim_path(sc->sim));
213         cam_sim_free(sc->sim);
214     }
215     lockmgr(&sc->sim_lock, LK_RELEASE);
216 }
217
218 int
219 tws_bus_scan(struct tws_softc *sc)
220 {
221     struct cam_path *path;
222     union ccb       *ccb;
223
224     TWS_TRACE_DEBUG(sc, "entry", sc, 0);
225     KASSERT(sc->sim, ("sim not allocated"));
226     KKASSERT(lockstatus(&sc->sim_lock, curthread) != 0);
227
228     ccb = sc->scan_ccb;
229
230     bzero(ccb, sizeof(union ccb));
231     if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->sim),
232                   CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
233         kfree(ccb, M_TEMP);
234         /* lockmgr(&sc->sim_lock, LK_RELEASE); */
235         return(EIO);
236     }
237     xpt_setup_ccb(&ccb->ccb_h, path, 5);
238     ccb->ccb_h.func_code = XPT_SCAN_BUS;
239     ccb->ccb_h.cbfcnp = tws_bus_scan_cb;
240     ccb->crcn.flags = CAM_FLAG_NONE;
241     xpt_action(ccb);
242
243     return(0);
244 }
245
246 static void
247 tws_bus_scan_cb(struct cam_periph *periph, union ccb *ccb)
248 {
249     struct tws_softc *sc = periph->softc;
250
251     /* calling trace results in non-sleepable lock head panic
252        using printf to debug */
253
254     if (ccb->ccb_h.status != CAM_REQ_CMP) {
255         kprintf("cam_scan failure\n");
256
257         lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
258         tws_send_event(sc, TWS_SCAN_FAILURE);
259         lockmgr(&sc->gen_lock, LK_RELEASE);
260     }
261
262     xpt_free_path(ccb->ccb_h.path);
263 }
264
265 static void
266 tws_action(struct cam_sim *sim, union ccb *ccb)
267 {
268     struct tws_softc *sc = (struct tws_softc *)cam_sim_softc(sim);
269
270     switch( ccb->ccb_h.func_code ) {
271         case XPT_SCSI_IO:
272         {
273             if ( tws_execute_scsi(sc, ccb) )
274                 TWS_TRACE_DEBUG(sc, "execute scsi failed", 0, 0);
275             break;
276         }
277         case XPT_ABORT:
278         {
279             TWS_TRACE_DEBUG(sc, "abort i/o", 0, 0);
280             ccb->ccb_h.status = CAM_UA_ABORT;
281             xpt_done(ccb);
282             break;
283         }
284         case XPT_RESET_BUS:
285         {
286             TWS_TRACE_DEBUG(sc, "reset bus", sim, ccb);
287             break;
288         }
289         case XPT_SET_TRAN_SETTINGS:
290         {
291             TWS_TRACE_DEBUG(sc, "set tran settings", sim, ccb);
292             ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
293             xpt_done(ccb);
294
295             break;
296         }
297         case XPT_GET_TRAN_SETTINGS:
298         {
299             TWS_TRACE_DEBUG(sc, "get tran settings", sim, ccb);
300
301             ccb->cts.protocol = PROTO_SCSI;
302             ccb->cts.protocol_version = SCSI_REV_2;
303             ccb->cts.transport = XPORT_SPI;
304             ccb->cts.transport_version = 2;
305
306             ccb->cts.xport_specific.spi.valid = CTS_SPI_VALID_DISC;
307             ccb->cts.xport_specific.spi.flags = CTS_SPI_FLAGS_DISC_ENB;
308             ccb->cts.proto_specific.scsi.valid = CTS_SCSI_VALID_TQ;
309             ccb->cts.proto_specific.scsi.flags = CTS_SCSI_FLAGS_TAG_ENB;
310             ccb->ccb_h.status = CAM_REQ_CMP;
311             xpt_done(ccb);
312
313             break;
314         }
315         case XPT_CALC_GEOMETRY:
316         {
317             TWS_TRACE_DEBUG(sc, "calc geometry(ccb,block-size)", ccb,
318                                           ccb->ccg.block_size);
319             cam_calc_geometry(&ccb->ccg, 1/* extended */);
320             xpt_done(ccb);
321
322             break;
323         }
324         case XPT_PATH_INQ:
325         {
326             TWS_TRACE_DEBUG(sc, "path inquiry", sim, ccb);
327             ccb->cpi.version_num = 1;
328             ccb->cpi.hba_inquiry = 0;
329             ccb->cpi.target_sprt = 0;
330             ccb->cpi.hba_misc = 0;
331             ccb->cpi.hba_eng_cnt = 0;
332             ccb->cpi.max_target = TWS_MAX_NUM_UNITS;
333             ccb->cpi.max_lun = TWS_MAX_NUM_LUNS - 1;
334             ccb->cpi.unit_number = cam_sim_unit(sim);
335             ccb->cpi.bus_id = cam_sim_bus(sim);
336             ccb->cpi.initiator_id = TWS_SCSI_INITIATOR_ID;
337             ccb->cpi.base_transfer_speed = 300000;
338             strncpy(ccb->cpi.sim_vid, "FreeBSD", SIM_IDLEN);
339             strncpy(ccb->cpi.hba_vid, "3ware", HBA_IDLEN);
340             strncpy(ccb->cpi.dev_name, cam_sim_name(sim), DEV_IDLEN);
341             ccb->cpi.transport = XPORT_SPI;
342             ccb->cpi.transport_version = 2;
343             ccb->cpi.protocol = PROTO_SCSI;
344             ccb->cpi.protocol_version = SCSI_REV_2;
345             ccb->ccb_h.status = CAM_REQ_CMP;
346             xpt_done(ccb);
347
348             break;
349         }
350         default:
351             TWS_TRACE_DEBUG(sc, "default", sim, ccb);
352             ccb->ccb_h.status = CAM_REQ_INVALID;
353             xpt_done(ccb);
354             break;
355     }
356 }
357
358 static void
359 tws_scsi_complete(struct tws_request *req)
360 {
361     struct tws_softc *sc = req->sc;
362
363     lockmgr(&sc->q_lock, LK_EXCLUSIVE);
364     tws_q_remove_request(sc, req, TWS_BUSY_Q);
365     lockmgr(&sc->q_lock, LK_RELEASE);
366
367     callout_stop(&req->ccb_ptr->ccb_h.timeout_ch);
368     tws_unmap_request(req->sc, req);
369
370
371     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
372     req->ccb_ptr->ccb_h.status = CAM_REQ_CMP;
373     xpt_done(req->ccb_ptr);
374     lockmgr(&sc->sim_lock, LK_RELEASE);
375
376     lockmgr(&sc->q_lock, LK_EXCLUSIVE);
377     tws_q_insert_tail(sc, req, TWS_FREE_Q);
378     lockmgr(&sc->q_lock, LK_RELEASE);
379
380 }
381
382 void
383 tws_getset_param_complete(struct tws_request *req)
384 {
385     struct tws_softc *sc = req->sc;
386
387     TWS_TRACE_DEBUG(sc, "getset complete", req, req->request_id);
388
389     callout_stop(&req->thandle);
390     tws_unmap_request(sc, req);
391
392     kfree(req->data, M_TWS);
393
394     lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
395     req->state = TWS_REQ_STATE_FREE;
396     lockmgr(&sc->gen_lock, LK_RELEASE);
397
398 }
399
400 void
401 tws_aen_complete(struct tws_request *req)
402 {
403     struct tws_softc *sc = req->sc;
404     struct tws_command_header *sense;
405     struct tws_event_packet event;
406     u_int16_t aen_code=0;
407
408     TWS_TRACE_DEBUG(sc, "aen complete", 0, req->request_id);
409
410     callout_stop(&req->thandle);
411     tws_unmap_request(sc, req);
412
413     sense = (struct tws_command_header *)req->data;
414
415     TWS_TRACE_DEBUG(sc,"sense code, key",sense->sense_data[0],
416                                    sense->sense_data[2]);
417     TWS_TRACE_DEBUG(sc,"sense rid, seve",sense->header_desc.request_id,
418                                    sense->status_block.res__severity);
419     TWS_TRACE_DEBUG(sc,"sense srcnum, error",sense->status_block.srcnum,
420                                    sense->status_block.error);
421     TWS_TRACE_DEBUG(sc,"sense shdr, ssense",sense->header_desc.size_header,
422                                    sense->header_desc.size_sense);
423
424     aen_code = sense->status_block.error;
425
426     switch ( aen_code ) {
427         case TWS_AEN_SYNC_TIME_WITH_HOST :
428             tws_aen_synctime_with_host(sc);
429             break;
430         case TWS_AEN_QUEUE_EMPTY :
431             break;
432         default :
433             bzero(&event, sizeof(struct tws_event_packet));
434             event.sequence_id = sc->seq_id;
435             event.time_stamp_sec = (u_int32_t)TWS_LOCAL_TIME;
436             event.aen_code = sense->status_block.error;
437             event.severity = sense->status_block.res__severity & 0x7;
438             event.event_src = TWS_SRC_CTRL_EVENT;
439             strcpy(event.severity_str, tws_sev_str[event.severity]);
440             event.retrieved = TWS_AEN_NOT_RETRIEVED;
441
442             bcopy(sense->err_specific_desc, event.parameter_data,
443                                     TWS_ERROR_SPECIFIC_DESC_LEN);
444             event.parameter_data[TWS_ERROR_SPECIFIC_DESC_LEN - 1] = '\0';
445             event.parameter_len = (u_int8_t)strlen(event.parameter_data)+1;
446
447             if ( event.parameter_len < TWS_ERROR_SPECIFIC_DESC_LEN ) {
448                 event.parameter_len += ((u_int8_t)strlen(event.parameter_data +
449                                                 event.parameter_len) + 1);
450             }
451
452             device_printf(sc->tws_dev, "%s: (0x%02X: 0x%04X): %s: %s\n",
453                 event.severity_str,
454                 event.event_src,
455                 event.aen_code,
456                 event.parameter_data +
457                      (strlen(event.parameter_data) + 1),
458                 event.parameter_data);
459
460             lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
461             tws_circular_aenq_insert(sc, &sc->aen_q, &event);
462             sc->seq_id++;
463             lockmgr(&sc->gen_lock, LK_RELEASE);
464             break;
465
466     }
467
468     kfree(req->data, M_TWS);
469
470     lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
471     req->state = TWS_REQ_STATE_FREE;
472     lockmgr(&sc->gen_lock, LK_RELEASE);
473
474     if ( aen_code != TWS_AEN_QUEUE_EMPTY ) {
475         /* timeout(tws_fetch_aen, sc, 1);*/
476         sc->stats.num_aens++;
477         tws_fetch_aen((void *)sc);
478     }
479
480 }
481
482 void
483 tws_cmd_complete(struct tws_request *req)
484 {
485     struct tws_softc *sc = req->sc;
486
487     callout_stop(&req->ccb_ptr->ccb_h.timeout_ch);
488     tws_unmap_request(sc, req);
489
490 }
491
492 static void
493 tws_err_complete(struct tws_softc *sc, u_int64_t mfa)
494 {
495
496     struct tws_command_header *hdr;
497     struct tws_sense *sen;
498     struct tws_request *req;
499     u_int16_t req_id;
500     u_int32_t reg, status;
501
502     if ( !mfa ) {
503         TWS_TRACE_DEBUG(sc, "null mfa", 0, mfa);
504         return;
505     } else {
506         /* lookup the sense */
507         sen = tws_find_sense_from_mfa(sc, mfa);
508         if ( sen == NULL ) {
509             TWS_TRACE_DEBUG(sc, "found null req", 0, mfa);
510             return;
511         }
512         hdr = sen->hdr;
513         TWS_TRACE_DEBUG(sc, "sen, hdr", sen, hdr);
514         req_id = hdr->header_desc.request_id;
515         req = &sc->reqs[req_id];
516         TWS_TRACE_DEBUG(sc, "req, id", req, req_id);
517         if ( req->error_code != TWS_REQ_SUBMIT_SUCCESS )
518             TWS_TRACE_DEBUG(sc, "submit failure?", 0, req->error_code);
519     }
520
521     switch (req->type) {
522         case TWS_PASSTHRU_REQ :
523             tws_passthru_err_complete(req, hdr);
524             break;
525         case TWS_GETSET_PARAM_REQ :
526             tws_getset_param_complete(req);
527             break;
528         case TWS_SCSI_IO_REQ :
529             tws_scsi_err_complete(req, hdr);
530             break;
531
532     }
533
534     lockmgr(&sc->io_lock, LK_EXCLUSIVE);
535     hdr->header_desc.size_header = 128;
536     reg = (u_int32_t)( mfa>>32);
537     tws_write_reg(sc, TWS_I2O0_HOBQPH, reg, 4);
538     reg = (u_int32_t)(mfa);
539     tws_write_reg(sc, TWS_I2O0_HOBQPL, reg, 4);
540
541     status = tws_read_reg(sc, TWS_I2O0_STATUS, 4);
542     if ( status & TWS_BIT13 ) {
543         TWS_TRACE_DEBUG(sc, "OBFL Overrun", status, TWS_I2O0_STATUS);
544         sc->obfl_q_overrun = true;
545         sen->posted = false;
546     }
547     lockmgr(&sc->io_lock, LK_RELEASE);
548
549 }
550
551 static void
552 tws_scsi_err_complete(struct tws_request *req, struct tws_command_header *hdr)
553 {
554     u_int8_t *sense_data;
555     struct tws_softc *sc = req->sc;
556     union ccb *ccb = req->ccb_ptr;
557
558     TWS_TRACE_DEBUG(sc, "sbe, cmd_status", hdr->status_block.error,
559                                  req->cmd_pkt->cmd.pkt_a.status);
560     if ( hdr->status_block.error == TWS_ERROR_LOGICAL_UNIT_NOT_SUPPORTED ||
561          hdr->status_block.error == TWS_ERROR_UNIT_OFFLINE ) {
562
563         if ( ccb->ccb_h.target_lun ) {
564             TWS_TRACE_DEBUG(sc, "invalid lun error",0,0);
565             ccb->ccb_h.status |= CAM_LUN_INVALID;
566         } else {
567             TWS_TRACE_DEBUG(sc, "invalid target error",0,0);
568             ccb->ccb_h.status |= CAM_TID_INVALID;
569         }
570
571     } else {
572         TWS_TRACE_DEBUG(sc, "scsi status  error",0,0);
573         ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
574         if (((ccb->csio.cdb_io.cdb_bytes[0] == 0x1A) &&
575               (hdr->status_block.error == TWS_ERROR_NOT_SUPPORTED))) {
576             ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
577             TWS_TRACE_DEBUG(sc, "page mode not supported",0,0);
578         }
579     }
580
581     /* if there were no error simply mark complete error */
582     if (ccb->ccb_h.status == 0)
583         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
584
585     sense_data = (u_int8_t *)&ccb->csio.sense_data;
586     if (sense_data) {
587         memcpy(sense_data, hdr->sense_data, TWS_SENSE_DATA_LENGTH );
588         ccb->csio.sense_len = TWS_SENSE_DATA_LENGTH;
589         ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
590     }
591     ccb->csio.scsi_status = req->cmd_pkt->cmd.pkt_a.status;
592
593     ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
594     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
595     xpt_done(ccb);
596     lockmgr(&sc->sim_lock, LK_RELEASE);
597
598     callout_stop(&req->ccb_ptr->ccb_h.timeout_ch);
599     tws_unmap_request(req->sc, req);
600     lockmgr(&sc->q_lock, LK_EXCLUSIVE);
601     tws_q_remove_request(sc, req, TWS_BUSY_Q);
602     tws_q_insert_tail(sc, req, TWS_FREE_Q);
603     lockmgr(&sc->q_lock, LK_RELEASE);
604
605 }
606
607 static void
608 tws_passthru_err_complete(struct tws_request *req,
609                                           struct tws_command_header *hdr)
610 {
611
612     TWS_TRACE_DEBUG(req->sc, "entry", hdr, req->request_id);
613     req->error_code = hdr->status_block.error;
614     memcpy(&(req->cmd_pkt->hdr), hdr, sizeof(struct tws_command_header));
615     tws_passthru_complete(req);
616 }
617
618 static void
619 tws_drain_busy_queue(struct tws_softc *sc)
620 {
621
622     struct tws_request *req;
623     TWS_TRACE_DEBUG(sc, "entry", 0, 0);
624
625     lockmgr(&sc->q_lock, LK_EXCLUSIVE);
626     req = tws_q_remove_tail(sc, TWS_BUSY_Q);
627     lockmgr(&sc->q_lock, LK_RELEASE);
628     while ( req ) {
629         callout_stop(&req->ccb_ptr->ccb_h.timeout_ch);
630         tws_unmap_request(req->sc, req);
631
632         TWS_TRACE_DEBUG(sc, "drained", 0, req->request_id);
633
634         lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
635         req->ccb_ptr->ccb_h.status = CAM_REQUEUE_REQ;
636         xpt_done(req->ccb_ptr);
637         lockmgr(&sc->sim_lock, LK_RELEASE);
638
639         lockmgr(&sc->q_lock, LK_EXCLUSIVE);
640         tws_q_insert_tail(sc, req, TWS_FREE_Q);
641         req = tws_q_remove_tail(sc, TWS_BUSY_Q);
642         lockmgr(&sc->q_lock, LK_RELEASE);
643     }
644
645 }
646
647 static void
648 tws_drain_reserved_reqs(struct tws_softc *sc)
649 {
650
651     struct tws_request *r;
652
653     r = &sc->reqs[1];
654     if ( r->state != TWS_REQ_STATE_FREE ) {
655         TWS_TRACE_DEBUG(sc, "drained aen req", 0, 0);
656         callout_stop(&r->thandle);
657         tws_unmap_request(sc, r);
658         kfree(r->data, M_TWS);
659         lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
660         r->state = TWS_REQ_STATE_FREE;
661         lockmgr(&sc->gen_lock, LK_RELEASE);
662     }
663     r = &sc->reqs[2];
664     if ( r->state != TWS_REQ_STATE_FREE ) {
665         TWS_TRACE_DEBUG(sc, "drained passthru req", 0, 0);
666         r->error_code = TWS_REQ_REQUEUE;
667         tws_passthru_complete(r);
668     }
669     r = &sc->reqs[3];
670     if ( r->state != TWS_REQ_STATE_FREE ) {
671         TWS_TRACE_DEBUG(sc, "drained set param req", 0, 0);
672         tws_getset_param_complete(r);
673     }
674
675 }
676
677 static void
678 tws_drain_response_queue(struct tws_softc *sc)
679 {
680     tws_intr_resp(sc);
681 }
682
683
684 static int32_t
685 tws_execute_scsi(struct tws_softc *sc, union ccb *ccb)
686 {
687     struct tws_command_packet *cmd_pkt;
688     struct tws_request *req;
689     struct ccb_hdr *ccb_h = &(ccb->ccb_h);
690     struct ccb_scsiio *csio = &(ccb->csio);
691     int error;
692     u_int16_t lun;
693
694     KKASSERT(lockstatus(&sc->sim_lock, curthread) != 0);
695     if (ccb_h->target_id >= TWS_MAX_NUM_UNITS) {
696         TWS_TRACE_DEBUG(sc, "traget id too big", ccb_h->target_id, ccb_h->target_lun);
697         ccb_h->status |= CAM_TID_INVALID;
698         xpt_done(ccb);
699         return(0);
700     }
701     if (ccb_h->target_lun >= TWS_MAX_NUM_LUNS) {
702         TWS_TRACE_DEBUG(sc, "target lun 2 big", ccb_h->target_id, ccb_h->target_lun);
703         ccb_h->status |= CAM_LUN_INVALID;
704         xpt_done(ccb);
705         return(0);
706     }
707
708     if(ccb_h->flags & CAM_CDB_PHYS) {
709         TWS_TRACE_DEBUG(sc, "cdb phy", ccb_h->target_id, ccb_h->target_lun);
710         ccb_h->status = CAM_REQ_CMP_ERR;
711         xpt_done(ccb);
712         return(0);
713     }
714
715     /*
716      * We are going to work on this request.  Mark it as enqueued (though
717      * we don't actually queue it...)
718      */
719     ccb_h->status |= CAM_SIM_QUEUED;
720
721     req = tws_get_request(sc, TWS_SCSI_IO_REQ);
722     if ( !req ) {
723         TWS_TRACE_DEBUG(sc, "no reqs", ccb_h->target_id, ccb_h->target_lun);
724         /* tws_freeze_simq(sc); */
725         ccb_h->status |= CAM_REQUEUE_REQ;
726         xpt_done(ccb);
727         return(0);
728     }
729
730     if((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
731         if(ccb_h->flags & CAM_DIR_IN)
732             req->flags = TWS_DIR_IN;
733         else
734             req->flags = TWS_DIR_OUT;
735     } else {
736         req->flags = TWS_DIR_NONE; /* no data */
737     }
738
739     req->type = TWS_SCSI_IO_REQ;
740     req->cb = tws_scsi_complete;
741
742     cmd_pkt = req->cmd_pkt;
743     /* cmd_pkt->hdr.header_desc.size_header = 128; */
744     cmd_pkt->cmd.pkt_a.res__opcode = TWS_FW_CMD_EXECUTE_SCSI;
745     cmd_pkt->cmd.pkt_a.unit = ccb_h->target_id;
746     cmd_pkt->cmd.pkt_a.status = 0;
747     cmd_pkt->cmd.pkt_a.sgl_offset = 16;
748
749     /* lower nibble */
750     lun = ccb_h->target_lun & 0XF;
751     lun = lun << 12;
752     cmd_pkt->cmd.pkt_a.lun_l4__req_id = lun | req->request_id;
753     /* upper nibble */
754     lun = ccb_h->target_lun & 0XF0;
755     lun = lun << 8;
756     cmd_pkt->cmd.pkt_a.lun_h4__sgl_entries = lun;
757
758 #ifdef TWS_DEBUG
759     if ( csio->cdb_len > 16 )
760          TWS_TRACE(sc, "cdb len too big", ccb_h->target_id, csio->cdb_len);
761 #endif
762
763     if(ccb_h->flags & CAM_CDB_POINTER)
764         bcopy(csio->cdb_io.cdb_ptr, cmd_pkt->cmd.pkt_a.cdb, csio->cdb_len);
765     else
766         bcopy(csio->cdb_io.cdb_bytes, cmd_pkt->cmd.pkt_a.cdb, csio->cdb_len);
767
768     if (!(ccb_h->flags & CAM_DATA_PHYS)) {
769          /* Virtual data addresses.  Need to convert them... */
770          if (!(ccb_h->flags & CAM_SCATTER_VALID)) {
771              if (csio->dxfer_len > TWS_MAX_IO_SIZE) {
772                  TWS_TRACE(sc, "I/O is big", csio->dxfer_len, 0);
773                  tws_release_request(req);
774                  ccb_h->status = CAM_REQ_TOO_BIG;
775                  xpt_done(ccb);
776                  return(0);
777              }
778
779              req->length = csio->dxfer_len;
780              if (req->length) {
781                  req->data = csio->data_ptr;
782                  /* there is 1 sgl_entrie */
783                  /* cmd_pkt->cmd.pkt_a.lun_h4__sgl_entries |= 1; */
784              }
785          } else {
786              TWS_TRACE_DEBUG(sc, "got sglist", ccb_h->target_id, ccb_h->target_lun);
787              tws_release_request(req);
788              ccb_h->status = CAM_REQ_CMP_ERR;
789              xpt_done(ccb);
790              return(0);
791          }
792     } else {
793          /* Data addresses are physical. */
794          TWS_TRACE_DEBUG(sc, "Phy data addr", ccb_h->target_id, ccb_h->target_lun);
795          tws_release_request(req);
796          ccb_h->status = CAM_REQ_CMP_ERR;
797          ccb_h->status |= CAM_RELEASE_SIMQ;
798          ccb_h->status &= ~CAM_SIM_QUEUED;
799          xpt_done(ccb);
800          return(0);
801     }
802     /* save ccb ptr */
803     req->ccb_ptr = ccb;
804     /*
805      * tws_map_load_data_callback will fill in the SGL,
806      * and submit the I/O.
807      */
808     sc->stats.scsi_ios++;
809     callout_reset(&ccb_h->timeout_ch, (ccb_h->timeout * hz)/1000, tws_timeout,
810         req);
811     error = tws_map_request(sc, req);
812     return(error);
813 }
814
815
816 int
817 tws_send_scsi_cmd(struct tws_softc *sc, int cmd)
818 {
819
820     struct tws_request *req;
821     struct tws_command_packet *cmd_pkt;
822     int error;
823
824     TWS_TRACE_DEBUG(sc, "entry",sc, cmd);
825     req = tws_get_request(sc, TWS_AEN_FETCH_REQ);
826
827     if ( req == NULL )
828         return(ENOMEM);
829
830     req->type = TWS_AEN_FETCH_REQ;
831     req->cb = tws_aen_complete;
832
833     cmd_pkt = req->cmd_pkt;
834     cmd_pkt->cmd.pkt_a.res__opcode = TWS_FW_CMD_EXECUTE_SCSI;
835     cmd_pkt->cmd.pkt_a.status = 0;
836     cmd_pkt->cmd.pkt_a.unit = 0;
837     cmd_pkt->cmd.pkt_a.sgl_offset = 16;
838     cmd_pkt->cmd.pkt_a.lun_l4__req_id = req->request_id;
839
840     cmd_pkt->cmd.pkt_a.cdb[0] = (u_int8_t)cmd;
841     cmd_pkt->cmd.pkt_a.cdb[4] = 128;
842
843     req->length = TWS_SECTOR_SIZE;
844     req->data = kmalloc(TWS_SECTOR_SIZE, M_TWS, M_NOWAIT);
845     if ( req->data == NULL )
846         return(ENOMEM);
847     bzero(req->data, TWS_SECTOR_SIZE);
848     req->flags = TWS_DIR_IN;
849
850     callout_reset(&req->thandle, (TWS_IO_TIMEOUT * hz), tws_timeout, req);
851     error = tws_map_request(sc, req);
852     return(error);
853
854 }
855
856 int
857 tws_set_param(struct tws_softc *sc, u_int32_t table_id, u_int32_t param_id,
858               u_int32_t param_size, void *data)
859 {
860     struct tws_request *req;
861     struct tws_command_packet *cmd_pkt;
862     union tws_command_giga *cmd;
863     struct tws_getset_param *param;
864     int error;
865
866     req = tws_get_request(sc, TWS_GETSET_PARAM_REQ);
867     if ( req == NULL ) {
868         TWS_TRACE_DEBUG(sc, "null req", 0, 0);
869         return(ENOMEM);
870     }
871
872     req->length = TWS_SECTOR_SIZE;
873     req->data = kmalloc(TWS_SECTOR_SIZE, M_TWS, M_NOWAIT);
874     if ( req->data == NULL )
875         return(ENOMEM);
876     bzero(req->data, TWS_SECTOR_SIZE);
877     param = (struct tws_getset_param *)req->data;
878
879     req->cb = tws_getset_param_complete;
880     req->flags = TWS_DIR_OUT;
881     cmd_pkt = req->cmd_pkt;
882
883     cmd = &cmd_pkt->cmd.pkt_g;
884     cmd->param.sgl_off__opcode =
885             BUILD_SGL_OFF__OPCODE(2, TWS_FW_CMD_SET_PARAM);
886     cmd->param.request_id = (u_int8_t)req->request_id;
887     cmd->param.host_id__unit = 0;
888     cmd->param.param_count = 1;
889     cmd->param.size = 2; /* map routine will add sgls */
890
891     /* Specify which parameter we want to set. */
892     param->table_id = (table_id | TWS_9K_PARAM_DESCRIPTOR);
893     param->parameter_id = (u_int8_t)(param_id);
894     param->parameter_size_bytes = (u_int16_t)param_size;
895     memcpy(param->data, data, param_size);
896
897     callout_reset(&req->thandle, (TWS_IO_TIMEOUT * hz), tws_timeout, req);
898     error = tws_map_request(sc, req);
899     return(error);
900
901 }
902
903 int
904 tws_get_param(struct tws_softc *sc, u_int32_t table_id, u_int32_t param_id,
905               u_int32_t param_size, void *data)
906 {
907     struct tws_request *req;
908     struct tws_command_packet *cmd_pkt;
909     union tws_command_giga *cmd;
910     struct tws_getset_param *param;
911     u_int16_t reqid;
912     u_int64_t mfa;
913     int error = SUCCESS;
914
915
916     req = tws_get_request(sc, TWS_GETSET_PARAM_REQ);
917     if ( req == NULL ) {
918         TWS_TRACE_DEBUG(sc, "null req", 0, 0);
919         return(FAILURE);
920     }
921
922     req->length = TWS_SECTOR_SIZE;
923     req->data = kmalloc(TWS_SECTOR_SIZE, M_TWS, M_NOWAIT);
924     if ( req->data == NULL )
925         return(FAILURE);
926     bzero(req->data, TWS_SECTOR_SIZE);
927     param = (struct tws_getset_param *)req->data;
928
929     req->cb = NULL;
930     req->flags = TWS_DIR_IN;
931     cmd_pkt = req->cmd_pkt;
932
933     cmd = &cmd_pkt->cmd.pkt_g;
934     cmd->param.sgl_off__opcode =
935             BUILD_SGL_OFF__OPCODE(2, TWS_FW_CMD_GET_PARAM);
936     cmd->param.request_id = (u_int8_t)req->request_id;
937     cmd->param.host_id__unit = 0;
938     cmd->param.param_count = 1;
939     cmd->param.size = 2; /* map routine will add sgls */
940
941     /* Specify which parameter we want to set. */
942     param->table_id = (table_id | TWS_9K_PARAM_DESCRIPTOR);
943     param->parameter_id = (u_int8_t)(param_id);
944     param->parameter_size_bytes = (u_int16_t)param_size;
945
946     tws_map_request(sc, req);
947     reqid = tws_poll4_response(sc, &mfa);
948     tws_unmap_request(sc, req);
949
950     if ( reqid == TWS_GETSET_PARAM_REQ ) {
951         memcpy(data, param->data, param_size);
952     } else {
953         error = FAILURE;
954
955     }
956
957     kfree(req->data, M_TWS);
958     lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
959     req->state = TWS_REQ_STATE_FREE;
960     lockmgr(&sc->gen_lock, LK_RELEASE);
961     return(error);
962
963 }
964
965 void
966 tws_unmap_request(struct tws_softc *sc, struct tws_request *req)
967 {
968
969     if (req->data != NULL) {
970         if ( req->flags & TWS_DIR_IN )
971             bus_dmamap_sync(sc->data_tag, req->dma_map,
972                                             BUS_DMASYNC_POSTREAD);
973         if ( req->flags & TWS_DIR_OUT )
974             bus_dmamap_sync(sc->data_tag, req->dma_map,
975                                             BUS_DMASYNC_POSTWRITE);
976         lockmgr(&sc->io_lock, LK_EXCLUSIVE);
977         bus_dmamap_unload(sc->data_tag, req->dma_map);
978         lockmgr(&sc->io_lock, LK_RELEASE);
979     }
980 }
981
982 int32_t
983 tws_map_request(struct tws_softc *sc, struct tws_request *req)
984 {
985     int32_t error = 0;
986
987
988     /* If the command involves data, map that too. */
989     if (req->data != NULL) {
990         /*
991          * Map the data buffer into bus space and build the SG list.
992          */
993         lockmgr(&sc->io_lock, LK_EXCLUSIVE);
994         error = bus_dmamap_load(sc->data_tag, req->dma_map,
995                                 req->data, req->length,
996                                 tws_dmamap_data_load_cbfn, req,
997                                 BUS_DMA_WAITOK);
998         lockmgr(&sc->io_lock, LK_RELEASE);
999
1000         if (error == EINPROGRESS) {
1001             TWS_TRACE(sc, "in progress", 0, error);
1002             /* tws_freeze_simq(sc); */
1003             error = TWS_REQ_ERR_INPROGRESS;
1004         }
1005     } else { /* no data involved */
1006         error = tws_submit_command(sc, req);
1007     }
1008     req->error_code = error;
1009     return(error);
1010 }
1011
1012
1013 static void
1014 tws_dmamap_data_load_cbfn(void *arg, bus_dma_segment_t *segs,
1015                             int nseg, int error)
1016 {
1017
1018     struct tws_request *req = (struct tws_request *)arg;
1019     struct tws_softc *sc = req->sc;
1020     u_int16_t sgls = nseg;
1021     void *sgl_ptr;
1022     struct tws_cmd_generic *gcmd;
1023
1024     if ( error == EFBIG )
1025         TWS_TRACE(sc, "not enough data segs", 0, nseg);
1026
1027
1028     if ( req->flags & TWS_DIR_IN )
1029         bus_dmamap_sync(req->sc->data_tag, req->dma_map,
1030                                             BUS_DMASYNC_PREREAD);
1031     if ( req->flags & TWS_DIR_OUT )
1032         bus_dmamap_sync(req->sc->data_tag, req->dma_map,
1033                                         BUS_DMASYNC_PREWRITE);
1034     if ( segs ) {
1035         if ( (req->type == TWS_PASSTHRU_REQ &&
1036              GET_OPCODE(req->cmd_pkt->cmd.pkt_a.res__opcode) !=
1037                             TWS_FW_CMD_EXECUTE_SCSI) ||
1038               req->type == TWS_GETSET_PARAM_REQ) {
1039             gcmd = &req->cmd_pkt->cmd.pkt_g.generic;
1040             sgl_ptr = (u_int32_t *)(gcmd) + gcmd->size;
1041             gcmd->size += sgls *
1042                           ((req->sc->is64bit && !tws_use_32bit_sgls) ? 4 :2 );
1043             tws_fill_sg_list(req->sc, (void *)segs, sgl_ptr, sgls);
1044
1045         } else {
1046             tws_fill_sg_list(req->sc, (void *)segs,
1047                       (void *)req->cmd_pkt->cmd.pkt_a.sg_list, sgls);
1048             req->cmd_pkt->cmd.pkt_a.lun_h4__sgl_entries |= sgls ;
1049         }
1050     }
1051
1052
1053     req->error_code = tws_submit_command(req->sc, req);
1054
1055 }
1056
1057
1058 static void
1059 tws_fill_sg_list(struct tws_softc *sc, void *sgl_src, void *sgl_dest,
1060                           u_int16_t num_sgl_entries)
1061 {
1062     int i;
1063
1064     if ( sc->is64bit ) {
1065         struct tws_sg_desc64 *sgl_s = (struct tws_sg_desc64 *)sgl_src;
1066
1067         if ( !tws_use_32bit_sgls ) {
1068             struct tws_sg_desc64 *sgl_d = (struct tws_sg_desc64 *)sgl_dest;
1069             if ( num_sgl_entries > TWS_MAX_64BIT_SG_ELEMENTS )
1070                 TWS_TRACE(sc, "64bit sg overflow", num_sgl_entries, 0);
1071             for (i = 0; i < num_sgl_entries; i++) {
1072                 sgl_d[i].address = sgl_s->address;
1073                 sgl_d[i].length = sgl_s->length;
1074                 sgl_d[i].flag = 0;
1075                 sgl_d[i].reserved = 0;
1076                 sgl_s = (struct tws_sg_desc64 *) (((u_int8_t *)sgl_s) +
1077                                                sizeof(bus_dma_segment_t));
1078             }
1079         } else {
1080             struct tws_sg_desc32 *sgl_d = (struct tws_sg_desc32 *)sgl_dest;
1081             if ( num_sgl_entries > TWS_MAX_32BIT_SG_ELEMENTS )
1082                 TWS_TRACE(sc, "32bit sg overflow", num_sgl_entries, 0);
1083             for (i = 0; i < num_sgl_entries; i++) {
1084                 sgl_d[i].address = sgl_s->address;
1085                 sgl_d[i].length = sgl_s->length;
1086                 sgl_d[i].flag = 0;
1087                 sgl_s = (struct tws_sg_desc64 *) (((u_int8_t *)sgl_s) +
1088                                                sizeof(bus_dma_segment_t));
1089             }
1090         }
1091     } else {
1092         struct tws_sg_desc32 *sgl_s = (struct tws_sg_desc32 *)sgl_src;
1093         struct tws_sg_desc32 *sgl_d = (struct tws_sg_desc32 *)sgl_dest;
1094
1095         if ( num_sgl_entries > TWS_MAX_32BIT_SG_ELEMENTS )
1096             TWS_TRACE(sc, "32bit sg overflow", num_sgl_entries, 0);
1097
1098
1099         for (i = 0; i < num_sgl_entries; i++) {
1100             sgl_d[i].address = sgl_s[i].address;
1101             sgl_d[i].length = sgl_s[i].length;
1102             sgl_d[i].flag = 0;
1103         }
1104     }
1105 }
1106
1107
1108 void
1109 tws_intr(void *arg)
1110 {
1111     struct tws_softc *sc = (struct tws_softc *)arg;
1112     u_int32_t histat=0, db=0;
1113
1114     KASSERT(sc, ("null softc"));
1115
1116     sc->stats.num_intrs++;
1117     histat = tws_read_reg(sc, TWS_I2O0_HISTAT, 4);
1118     if ( histat & TWS_BIT2 ) {
1119         TWS_TRACE_DEBUG(sc, "door bell :)", histat, TWS_I2O0_HISTAT);
1120         db = tws_read_reg(sc, TWS_I2O0_IOBDB, 4);
1121         if ( db & TWS_BIT21 ) {
1122             tws_intr_attn_error(sc);
1123             return;
1124         }
1125         if ( db & TWS_BIT18 ) {
1126             tws_intr_attn_aen(sc);
1127         }
1128     }
1129
1130     if ( histat & TWS_BIT3 ) {
1131         tws_intr_resp(sc);
1132     }
1133 }
1134
1135 static void
1136 tws_intr_attn_aen(struct tws_softc *sc)
1137 {
1138     u_int32_t db=0;
1139
1140     /* maskoff db intrs untill all the aens are fetched */
1141     /* tws_disable_db_intr(sc); */
1142     tws_fetch_aen((void *)sc);
1143     tws_write_reg(sc, TWS_I2O0_HOBDBC, TWS_BIT18, 4);
1144     db = tws_read_reg(sc, TWS_I2O0_IOBDB, 4);
1145
1146 }
1147
1148 static void
1149 tws_intr_attn_error(struct tws_softc *sc)
1150 {
1151     u_int32_t db=0;
1152
1153     TWS_TRACE(sc, "attn error", 0, 0);
1154     tws_write_reg(sc, TWS_I2O0_HOBDBC, ~0, 4);
1155     db = tws_read_reg(sc, TWS_I2O0_IOBDB, 4);
1156     device_printf(sc->tws_dev, "Micro controller error.\n");
1157     tws_reset(sc);
1158 }
1159
1160 static void
1161 tws_intr_resp(struct tws_softc *sc)
1162 {
1163     u_int16_t req_id;
1164     u_int64_t mfa;
1165
1166     while ( tws_get_response(sc, &req_id, &mfa) ) {
1167         sc->stats.reqs_out++;
1168         if ( req_id == TWS_INVALID_REQID ) {
1169             TWS_TRACE_DEBUG(sc, "invalid req_id", mfa, req_id);
1170             sc->stats.reqs_errored++;
1171             tws_err_complete(sc, mfa);
1172             continue;
1173         }
1174
1175         sc->reqs[req_id].cb(&sc->reqs[req_id]);
1176     }
1177
1178 }
1179
1180
1181 static void
1182 tws_poll(struct cam_sim *sim)
1183 {
1184     struct tws_softc *sc = (struct tws_softc *)cam_sim_softc(sim);
1185     TWS_TRACE_DEBUG(sc, "entry", 0, 0);
1186     tws_intr((void *) sc);
1187 }
1188
1189 void
1190 tws_timeout(void *arg)
1191 {
1192     struct tws_request *req = (struct tws_request *)arg;
1193     struct tws_softc *sc = req->sc;
1194
1195
1196     if ( tws_get_state(sc) != TWS_RESET ) {
1197         device_printf(sc->tws_dev, "Request timed out.\n");
1198         tws_reset((void *)sc);
1199     }
1200 }
1201
1202 void
1203 tws_reset(void *arg)
1204 {
1205
1206     struct tws_softc *sc = (struct tws_softc *)arg;
1207
1208     if ( tws_get_state(sc) == TWS_RESET ) {
1209         return;
1210     }
1211     device_printf(sc->tws_dev,  "Resetting controller\n");
1212     lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
1213     tws_send_event(sc, TWS_RESET_START);
1214     lockmgr(&sc->gen_lock, LK_RELEASE);
1215
1216     tws_turn_off_interrupts(sc);
1217     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
1218     tws_freeze_simq(sc);
1219     lockmgr(&sc->sim_lock, LK_RELEASE);
1220
1221     tws_assert_soft_reset(sc);
1222     callout_reset(&sc->reset_cb_handle, hz/10, tws_reset_cb, sc);
1223 }
1224
1225 static void
1226 tws_reset_cb(void *arg)
1227 {
1228
1229     struct tws_softc *sc = (struct tws_softc *)arg;
1230     u_int32_t reg;
1231
1232     if ( tws_get_state(sc) != TWS_RESET ) {
1233         return;
1234     }
1235     reg = tws_read_reg(sc, TWS_I2O0_SCRPD3, 4);
1236     if (!( reg & TWS_BIT13 )) {
1237         callout_reset(&sc->reset_cb_handle, hz/10, tws_reset_cb, sc);
1238         return;
1239     }
1240     tws_drain_response_queue(sc);
1241     tws_drain_busy_queue(sc);
1242     tws_drain_reserved_reqs(sc);
1243     callout_reset(&sc->reinit_handle, 5*hz, tws_reinit, sc);
1244 }
1245
1246 static void
1247 tws_reinit(void *arg)
1248 {
1249
1250     struct tws_softc *sc = (struct tws_softc *)arg;
1251     static int timeout_val=0, try=2  ;
1252
1253     if ( !tws_ctlr_ready(sc) ) {
1254         timeout_val += 5;
1255         if ( timeout_val >= TWS_RESET_TIMEOUT ) {
1256            timeout_val = 0;
1257            if ( try )
1258                tws_assert_soft_reset(sc);
1259            try--;
1260         }
1261         callout_reset(&sc->reinit_handle, 5*hz, tws_reinit, sc);
1262         return;
1263     }
1264
1265     timeout_val=0;
1266     try = 2;
1267     sc->obfl_q_overrun = false;
1268     if ( tws_init_connect(sc, tws_queue_depth) ) {
1269         TWS_TRACE_DEBUG(sc, "initConnect failed", 0, sc->is64bit);
1270     }
1271     tws_init_obfl_q(sc);
1272
1273     lockmgr(&sc->sim_lock, LK_EXCLUSIVE);
1274     tws_release_simq(sc);
1275     lockmgr(&sc->sim_lock, LK_RELEASE);
1276     tws_turn_on_interrupts(sc);
1277
1278     lockmgr(&sc->gen_lock, LK_EXCLUSIVE);
1279     tws_send_event(sc, TWS_RESET_COMPLETE);
1280     lockmgr(&sc->gen_lock, LK_RELEASE);
1281     if ( sc->chan ) {
1282         sc->chan = 0;
1283         wakeup((void *)&sc->chan);
1284     }
1285
1286 }
1287
1288
1289 static void
1290 tws_freeze_simq(struct tws_softc *sc)
1291 {
1292
1293     TWS_TRACE_DEBUG(sc, "freezeing", 0, 0);
1294     KKASSERT(lockstatus(&sc->sim_lock, curthread) != 0);
1295     xpt_freeze_simq(sc->sim, 1);
1296
1297 }
1298 static void
1299 tws_release_simq(struct tws_softc *sc)
1300 {
1301
1302     TWS_TRACE_DEBUG(sc, "unfreezeing", 0, 0);
1303     KKASSERT(lockstatus(&sc->sim_lock, curthread) != 0);
1304     xpt_release_simq(sc->sim, 1);
1305
1306 }
1307
1308
1309 TUNABLE_INT("hw.tws.cam_depth", &tws_cam_depth);