1 /*- 2 * Copyright (c) 2000 Michael Smith 3 * Copyright (c) 2000 BSDi 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: src/sys/dev/twe/twevar.h,v 1.1.2.4 2002/03/07 09:57:02 msmith Exp $ 28 * $DragonFly: src/sys/dev/raid/twe/twevar.h,v 1.3 2004/01/05 17:40:00 drhodus Exp $ 29 */ 30 31 #ifdef TWE_DEBUG 32 #define debug(level, fmt, args...) \ 33 do { \ 34 if (level <= TWE_DEBUG) printf("%s: " fmt "\n", __func__ , ##args); \ 35 } while(0) 36 #define debug_called(level) \ 37 do { \ 38 if (level <= TWE_DEBUG) printf("%s: called\n", __func__); \ 39 } while(0) 40 #else 41 #define debug(level, fmt, args...) 42 #define debug_called(level) 43 #endif 44 45 /* 46 * Structure describing a logical unit as attached to the controller 47 */ 48 struct twe_drive 49 { 50 /* unit properties */ 51 u_int32_t td_size; 52 int td_cylinders; 53 int td_heads; 54 int td_sectors; 55 int td_unit; 56 57 /* unit state and type */ 58 u_int8_t td_state; 59 u_int8_t td_type; 60 61 /* handle for attached driver */ 62 device_t td_disk; 63 }; 64 65 /* 66 * Per-command control structure. 67 * 68 * Note that due to alignment constraints on the tc_command field, this *must* be 64-byte aligned. 69 * We achieve this by placing the command at the beginning of the structure, and using malloc() 70 * to allocate each structure. 71 */ 72 struct twe_request 73 { 74 /* controller command */ 75 TWE_Command tr_command; /* command as submitted to controller */ 76 77 /* command payload */ 78 void *tr_data; /* data buffer */ 79 void *tr_realdata; /* copy of real data buffer pointer for alignment fixup */ 80 size_t tr_length; 81 82 TAILQ_ENTRY(twe_request) tr_link; /* list linkage */ 83 struct twe_softc *tr_sc; /* controller that owns us */ 84 int tr_status; /* command status */ 85 #define TWE_CMD_SETUP 0 /* being assembled */ 86 #define TWE_CMD_BUSY 1 /* submitted to controller */ 87 #define TWE_CMD_COMPLETE 2 /* completed by controller (maybe with error) */ 88 int tr_flags; 89 #define TWE_CMD_DATAIN (1<<0) 90 #define TWE_CMD_DATAOUT (1<<1) 91 #define TWE_CMD_ALIGNBUF (1<<2) /* data in bio is misaligned, have to copy to/from private buffer */ 92 #define TWE_CMD_SLEEPER (1<<3) /* owner is sleeping on this command */ 93 void (* tr_complete)(struct twe_request *tr); /* completion handler */ 94 void *tr_private; /* submitter-private data or wait channel */ 95 96 TWE_PLATFORM_REQUEST /* platform-specific request elements */ 97 }; 98 99 /* 100 * Per-controller state. 101 */ 102 struct twe_softc 103 { 104 /* controller queues and arrays */ 105 TAILQ_HEAD(, twe_request) twe_free; /* command structures available for reuse */ 106 twe_bioq twe_bioq; /* outstanding I/O operations */ 107 TAILQ_HEAD(, twe_request) twe_ready; /* requests ready for the controller */ 108 TAILQ_HEAD(, twe_request) twe_busy; /* requests busy in the controller */ 109 TAILQ_HEAD(, twe_request) twe_complete; /* active commands (busy or waiting for completion) */ 110 struct twe_request *twe_lookup[TWE_Q_LENGTH]; /* commands indexed by request ID */ 111 struct twe_drive twe_drive[TWE_MAX_UNITS]; /* attached drives */ 112 113 /* asynchronous event handling */ 114 u_int16_t twe_aen_queue[TWE_Q_LENGTH]; /* AENs queued for userland tool(s) */ 115 int twe_aen_head, twe_aen_tail; /* ringbuffer pointers for AEN queue */ 116 int twe_wait_aen; /* wait-for-aen notification */ 117 118 /* controller status */ 119 int twe_state; 120 #define TWE_STATE_INTEN (1<<0) /* interrupts have been enabled */ 121 #define TWE_STATE_SHUTDOWN (1<<1) /* controller is shut down */ 122 #define TWE_STATE_OPEN (1<<2) /* control device is open */ 123 #define TWE_STATE_SUSPEND (1<<3) /* controller is suspended */ 124 int twe_host_id; 125 struct twe_qstat twe_qstat[TWEQ_COUNT]; /* queue statistics */ 126 127 TWE_PLATFORM_SOFTC /* platform-specific softc elements */ 128 }; 129 130 /* 131 * Interface betwen driver core and platform-dependant code. 132 */ 133 extern int twe_setup(struct twe_softc *sc); /* do early driver/controller setup */ 134 extern void twe_init(struct twe_softc *sc); /* init controller */ 135 extern void twe_deinit(struct twe_softc *sc); /* stop controller */ 136 extern void twe_intr(struct twe_softc *sc); /* hardware interrupt signalled */ 137 extern void twe_startio(struct twe_softc *sc); 138 extern int twe_dump_blocks(struct twe_softc *sc, int unit, /* crashdump block write */ 139 u_int32_t lba, void *data, int nblks); 140 extern int twe_ioctl(struct twe_softc *sc, int cmd, 141 void *addr); /* handle user request */ 142 extern void twe_describe_controller(struct twe_softc *sc); /* print controller info */ 143 extern void twe_print_controller(struct twe_softc *sc); 144 extern void twe_enable_interrupts(struct twe_softc *sc); /* enable controller interrupts */ 145 extern void twe_disable_interrupts(struct twe_softc *sc); /* disable controller interrupts */ 146 147 extern void twe_attach_drive(struct twe_softc *sc, 148 struct twe_drive *dr); /* attach drive when found in twe_add_unit */ 149 extern void twe_detach_drive(struct twe_softc *sc, 150 int unit); /* detach drive */ 151 extern void twe_clear_pci_parity_error(struct twe_softc *sc); 152 extern void twe_clear_pci_abort(struct twe_softc *sc); 153 extern void twed_intr(twe_bio *bp); /* return bio from core */ 154 extern struct twe_request *twe_allocate_request(struct twe_softc *sc); /* allocate request structure */ 155 extern void twe_free_request(struct twe_request *tr); /* free request structure */ 156 extern void twe_map_request(struct twe_request *tr); /* make request visible to controller, do s/g */ 157 extern void twe_unmap_request(struct twe_request *tr); /* cleanup after transfer, unmap */ 158 159 /******************************************************************************** 160 * Queue primitives 161 */ 162 #define TWEQ_ADD(sc, qname) \ 163 do { \ 164 struct twe_qstat *qs = &(sc)->twe_qstat[qname]; \ 165 \ 166 qs->q_length++; \ 167 if (qs->q_length > qs->q_max) \ 168 qs->q_max = qs->q_length; \ 169 } while(0) 170 171 #define TWEQ_REMOVE(sc, qname) (sc)->twe_qstat[qname].q_length-- 172 #define TWEQ_INIT(sc, qname) \ 173 do { \ 174 sc->twe_qstat[qname].q_length = 0; \ 175 sc->twe_qstat[qname].q_max = 0; \ 176 } while(0) 177 178 179 #define TWEQ_REQUEST_QUEUE(name, index) \ 180 static __inline void \ 181 twe_initq_ ## name (struct twe_softc *sc) \ 182 { \ 183 TAILQ_INIT(&sc->twe_ ## name); \ 184 TWEQ_INIT(sc, index); \ 185 } \ 186 static __inline void \ 187 twe_enqueue_ ## name (struct twe_request *tr) \ 188 { \ 189 int s; \ 190 \ 191 s = splbio(); \ 192 TAILQ_INSERT_TAIL(&tr->tr_sc->twe_ ## name, tr, tr_link); \ 193 TWEQ_ADD(tr->tr_sc, index); \ 194 splx(s); \ 195 } \ 196 static __inline void \ 197 twe_requeue_ ## name (struct twe_request *tr) \ 198 { \ 199 int s; \ 200 \ 201 s = splbio(); \ 202 TAILQ_INSERT_HEAD(&tr->tr_sc->twe_ ## name, tr, tr_link); \ 203 TWEQ_ADD(tr->tr_sc, index); \ 204 splx(s); \ 205 } \ 206 static __inline struct twe_request * \ 207 twe_dequeue_ ## name (struct twe_softc *sc) \ 208 { \ 209 struct twe_request *tr; \ 210 int s; \ 211 \ 212 s = splbio(); \ 213 if ((tr = TAILQ_FIRST(&sc->twe_ ## name)) != NULL) { \ 214 TAILQ_REMOVE(&sc->twe_ ## name, tr, tr_link); \ 215 TWEQ_REMOVE(sc, index); \ 216 } \ 217 splx(s); \ 218 return(tr); \ 219 } \ 220 static __inline void \ 221 twe_remove_ ## name (struct twe_request *tr) \ 222 { \ 223 int s; \ 224 \ 225 s = splbio(); \ 226 TAILQ_REMOVE(&tr->tr_sc->twe_ ## name, tr, tr_link); \ 227 TWEQ_REMOVE(tr->tr_sc, index); \ 228 splx(s); \ 229 } 230 231 TWEQ_REQUEST_QUEUE(free, TWEQ_FREE) 232 TWEQ_REQUEST_QUEUE(ready, TWEQ_READY) 233 TWEQ_REQUEST_QUEUE(busy, TWEQ_BUSY) 234 TWEQ_REQUEST_QUEUE(complete, TWEQ_COMPLETE) 235 236 237 /* 238 * outstanding bio queue 239 */ 240 static __inline void 241 twe_initq_bio(struct twe_softc *sc) 242 { 243 TWE_BIO_QINIT(sc->twe_bioq); 244 TWEQ_INIT(sc, TWEQ_BIO); 245 } 246 247 static __inline void 248 twe_enqueue_bio(struct twe_softc *sc, twe_bio *bp) 249 { 250 int s; 251 252 s = splbio(); 253 TWE_BIO_QINSERT(sc->twe_bioq, bp); 254 TWEQ_ADD(sc, TWEQ_BIO); 255 splx(s); 256 } 257 258 static __inline twe_bio * 259 twe_dequeue_bio(struct twe_softc *sc) 260 { 261 int s; 262 twe_bio *bp; 263 264 s = splbio(); 265 if ((bp = TWE_BIO_QFIRST(sc->twe_bioq)) != NULL) { 266 TWE_BIO_QREMOVE(sc->twe_bioq, bp); 267 TWEQ_REMOVE(sc, TWEQ_BIO); 268 } 269 splx(s); 270 return(bp); 271 } 272