Style(9) cleanup to src/sys/vfs, stage 20/21: umapfs.
[dragonfly.git] / sys / dev / raid / twa / twa.h
1 /*-
2  * Copyright (c) 2003-04 3ware, Inc.
3  * Copyright (c) 2000 Michael Smith
4  * Copyright (c) 2000 BSDi
5  * All rights reserved.
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  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  *      $FreeBSD$
29  * $DragonFly: src/sys/dev/raid/twa/twa.h,v 1.1 2004/04/16 20:13:16 drhodus Exp $
30  */
31
32 /*
33  * 3ware driver for 9000 series storage controllers.
34  *
35  * Author: Vinod Kashyap
36  */
37
38
39 /*
40  * The scheme for the driver version is:
41  * <major change>.<external release>.<3ware internal release>.<development release>
42  */
43 #define TWA_DRIVER_VERSION_STRING               "2.40.00.000"
44
45 #define TWA_CDEV_MAJOR                          187
46
47 #define TWA_REQUEST_TIMEOUT_PERIOD              60 /* seconds */
48 #define TWA_MESSAGE_SOURCE_CONTROLLER_ERROR     3
49 #define TWA_MESSAGE_SOURCE_CONTROLLER_EVENT     4
50 #define TWA_MESSAGE_SOURCE_FREEBSD_DRIVER       6
51 #define TWA_MESSAGE_SOURCE_FREEBSD_OS           9
52
53 #define TWA_MALLOC_CLASS                        M_TWA
54
55 /* Macros for bus-space calls. */
56 #define TWA_READ_REGISTER(sc, offset)           \
57         (u_int32_t)bus_space_read_4(sc->twa_bus_tag, sc->twa_bus_handle, offset)
58 #define TWA_WRITE_REGISTER(sc, offset, val)     \
59         bus_space_write_4(sc->twa_bus_tag, sc->twa_bus_handle, offset, (u_int32_t)val)
60
61 /* Possible values of tr->tr_status. */
62 #define TWA_CMD_SETUP           0x0     /* being assembled */
63 #define TWA_CMD_BUSY            0x1     /* submitted to controller */
64 #define TWA_CMD_PENDING         0x2     /* in pending queue */
65 #define TWA_CMD_COMPLETE        0x3     /* completed by controller (maybe with error) */
66
67 /* Possible values of tr->tr_flags. */
68 #define TWA_CMD_DATA_IN                 (1<<0)  /* read request */
69 #define TWA_CMD_DATA_OUT                (1<<1)  /* write request */
70 #define TWA_CMD_DATA_COPY_NEEDED        (1<<2)  /* data in ccb is misaligned, have to copy to/from private buffer */
71 #define TWA_CMD_SLEEP_ON_REQUEST        (1<<3)  /* owner is sleeping on this command */
72 #define TWA_CMD_IN_PROGRESS             (1<<4)  /* bus_dmamap_load returned EINPROGRESS */
73
74 /* Possible values of tr->tr_cmd_pkt_type. */
75 #define TWA_CMD_PKT_TYPE_7K             (1<<0)
76 #define TWA_CMD_PKT_TYPE_9K             (1<<1)
77 #define TWA_CMD_PKT_TYPE_INTERNAL       (1<<2)
78 #define TWA_CMD_PKT_TYPE_IOCTL          (1<<3)
79 #define TWA_CMD_PKT_TYPE_EXTERNAL       (1<<4)
80
81 /* Possible values of sc->twa_state. */
82 #define TWA_STATE_INTR_ENABLED          (1<<0)  /* interrupts have been enabled */
83 #define TWA_STATE_SHUTDOWN              (1<<1)  /* controller is shut down */
84 #define TWA_STATE_OPEN                  (1<<2)  /* control device is open */
85 #define TWA_STATE_SUSPEND               (1<<3)  /* controller is suspended */
86 #define TWA_STATE_SIMQ_FROZEN           (1<<4)  /* simq frozen */
87
88 /* Possible values of sc->twa_ioctl_lock.lock. */
89 #define TWA_LOCK_FREE           0x0     /* lock is free */
90 #define TWA_LOCK_HELD           0x1     /* lock is held */
91
92
93 /* Error/AEN message structure. */
94 struct twa_message {
95         u_int32_t       code;
96         char            *message;
97 };
98
99 #ifdef TWA_DEBUG
100 struct twa_q_statistics {
101         u_int32_t       q_length;
102         u_int32_t       q_max;
103 };
104
105 #define TWAQ_FREE       0
106 #define TWAQ_BUSY       1
107 #define TWAQ_PENDING    2
108 #define TWAQ_COMPLETE   3
109 #define TWAQ_COUNT      4       /* total number of queues */
110 #endif /* TWA_DEBUG */
111
112 /* Driver's request packet. */
113 struct twa_request {
114         struct twa_command_packet *tr_command;  /* ptr to cmd pkt submitted to controller */
115         u_int32_t               tr_request_id;  /* request id for tracking with firmware */
116
117         void                    *tr_data;       /* ptr to data being passed to firmware */
118         size_t                  tr_length;      /* length of buffer being passed to firmware */
119
120         void                    *tr_real_data;  /* ptr to, and length of data passed */
121         size_t                  tr_real_length; /* to us from above, in case a buffer copy
122                                                         was done due to non-compliance to 
123                                                         alignment requirements */
124
125         TAILQ_ENTRY(twa_request) tr_link;       /* to link this request in a list */
126         struct twa_softc        *tr_sc;         /* controller that owns us */
127
128         u_int32_t               tr_status;      /* command status */
129         u_int32_t               tr_flags;       /* request flags */
130         u_int32_t               tr_error;       /* error encountered before request submission */
131         u_int32_t               tr_cmd_pkt_type;/* type of request */
132         void                    *tr_private;    /* request specific data to use during callback */
133         void                    (*tr_callback)(struct twa_request *tr);/* callback handler */
134         bus_addr_t              tr_cmd_phys;    /* physical address of command in controller space */
135         bus_dmamap_t            tr_dma_map;     /* DMA map for data */
136 } __attribute__ ((packed));
137
138
139 /* Per-controller structure. */
140 struct twa_softc {
141         /* Request queues and arrays. */
142         TAILQ_HEAD(, twa_request) twa_free;     /* free request packets */
143         TAILQ_HEAD(, twa_request) twa_busy;     /* requests busy in the controller */
144         TAILQ_HEAD(, twa_request) twa_pending;  /* internal requests pending */
145         TAILQ_HEAD(, twa_request) twa_complete; /* requests completed by firmware (not by us) */
146
147         struct twa_request      *twa_lookup[TWA_Q_LENGTH];/* requests indexed by request_id */
148
149         struct twa_request      *twa_req_buf;
150         struct twa_command_packet *twa_cmd_pkt_buf;
151
152         /* AEN handler fields. */
153         struct twa_event_packet *twa_aen_queue[TWA_Q_LENGTH];/* circular queue of AENs from firmware */
154         uint16_t                working_srl;    /* driver & firmware negotiated srl */
155         uint16_t                working_branch; /* branch # of the firmware that the driver is compatible with */
156         uint16_t                working_build;  /* build # of the firmware that the driver is compatible with */
157         u_int32_t               twa_operating_mode; /* base mode/current mode */
158         u_int32_t               twa_aen_head;   /* AEN queue head */
159         u_int32_t               twa_aen_tail;   /* AEN queue tail */
160         u_int32_t               twa_current_sequence_id;/* index of the last event + 1 */
161         u_int32_t               twa_aen_queue_overflow; /* indicates if unretrieved events were overwritten */
162         u_int32_t               twa_aen_queue_wrapped;  /* indicates if AEN queue ever wrapped */
163         u_int32_t               twa_wait_timeout; /* identifier for calling tsleep */
164
165         /* Controller state. */
166         u_int32_t               twa_state;
167 #ifdef TWA_DEBUG
168         struct twa_q_statistics twa_qstats[TWAQ_COUNT]; /* queue statistics */
169 #endif /* TWA_DEBUG */
170         struct {
171                 u_int32_t       lock;   /* lock state */
172                 u_int32_t       timeout;/* time at which the lock will become available,
173                                                 even if not released */
174         } twa_ioctl_lock;       /* lock for use by user applications, for synchronization
175                                         between ioctl calls */
176     
177         device_t                twa_bus_dev;    /* bus device */
178         dev_t                   twa_ctrl_dev;   /* control device */
179         struct resource         *twa_io_res;    /* register interface window */
180         bus_space_handle_t      twa_bus_handle; /* bus space handle */
181         bus_space_tag_t         twa_bus_tag;    /* bus space tag */
182         bus_dma_tag_t           twa_dma_tag;    /* data buffer DMA tag */
183         bus_dmamap_t            twa_cmd_map;    /* DMA map for the array of cmd pkts */
184         bus_addr_t              twa_cmd_pkt_phys;/* phys addr of first of array of cmd pkts */
185         struct resource         *twa_irq_res;   /* interrupt resource*/
186         void                    *twa_intr_handle;/* interrupt handle */
187         struct intr_config_hook twa_ich;        /* delayed-startup hook */
188
189         struct sysctl_ctx_list  twa_sysctl_ctx;
190         struct sysctl_oid       *twa_sysctl_tree;
191
192         struct cam_sim          *twa_sim;       /* sim for this controller */
193         struct cam_path         *twa_path;      /* peripheral, path, tgt, lun
194                                                 associated with this controller */
195 };
196
197
198 /*
199  * Queue primitives
200  */
201
202 #ifdef TWA_DEBUG
203
204 #define TWAQ_INIT(sc, qname)                            \
205         do {                                            \
206                 sc->twa_qstats[qname].q_length = 0;     \
207                 sc->twa_qstats[qname].q_max = 0;        \
208         } while(0)
209
210 #define TWAQ_ADD(sc, qname)                                     \
211         do {                                                    \
212         struct twa_q_statistics *qs = &(sc)->twa_qstats[qname]; \
213                                                                 \
214                 qs->q_length++;                                 \
215                 if (qs->q_length > qs->q_max)                   \
216                         qs->q_max = qs->q_length;               \
217         } while(0)
218
219 #define TWAQ_REMOVE(sc, qname)  (sc)->twa_qstats[qname].q_length--
220
221 #else /* TWA_DEBUG */
222
223 #define TWAQ_INIT(sc, qname)
224 #define TWAQ_ADD(sc, qname)
225 #define TWAQ_REMOVE(sc, qname)
226
227 #endif /* TWA_DEBUG */
228
229 #define TWAQ_REQUEST_QUEUE(name, index)                                 \
230 static __inline void twa_initq_ ## name(struct twa_softc *sc)           \
231 {                                                                       \
232         TAILQ_INIT(&sc->twa_ ## name);                                  \
233         TWAQ_INIT(sc, index);                                           \
234 }                                                                       \
235 static __inline void twa_enqueue_ ## name(struct twa_request *tr)       \
236 {                                                                       \
237         int     s;                                                      \
238                                                                         \
239         s = splcam();                                                   \
240         TAILQ_INSERT_TAIL(&tr->tr_sc->twa_ ## name, tr, tr_link);       \
241         TWAQ_ADD(tr->tr_sc, index);                                     \
242         splx(s);                                                        \
243 }                                                                       \
244 static __inline void twa_requeue_ ## name(struct twa_request *tr)       \
245 {                                                                       \
246         int     s;                                                      \
247                                                                         \
248         s = splcam();                                                   \
249         TAILQ_INSERT_HEAD(&tr->tr_sc->twa_ ## name, tr, tr_link);       \
250         TWAQ_ADD(tr->tr_sc, index);                                     \
251         splx(s);                                                        \
252 }                                                                       \
253 static __inline struct twa_request *twa_dequeue_ ## name(struct twa_softc *sc)\
254 {                                                                       \
255         struct twa_request      *tr;                                    \
256         int                     s;                                      \
257                                                                         \
258         s = splcam();                                                   \
259         if ((tr = TAILQ_FIRST(&sc->twa_ ## name)) != NULL) {            \
260                 TAILQ_REMOVE(&sc->twa_ ## name, tr, tr_link);           \
261                 TWAQ_REMOVE(sc, index);                                 \
262         }                                                               \
263         splx(s);                                                        \
264         return(tr);                                                     \
265 }                                                                       \
266 static __inline void twa_remove_ ## name(struct twa_request *tr)        \
267 {                                                                       \
268         int     s;                                                      \
269                                                                         \
270         s = splcam();                                                   \
271         TAILQ_REMOVE(&tr->tr_sc->twa_ ## name, tr, tr_link);            \
272         TWAQ_REMOVE(tr->tr_sc, index);                                  \
273         splx(s);                                                        \
274 }
275
276 TWAQ_REQUEST_QUEUE(free, TWAQ_FREE)
277 TWAQ_REQUEST_QUEUE(busy, TWAQ_BUSY)
278 TWAQ_REQUEST_QUEUE(pending, TWAQ_PENDING)
279 TWAQ_REQUEST_QUEUE(complete, TWAQ_COMPLETE)
280
281
282 #ifdef TWA_DEBUG
283
284 extern u_int8_t twa_dbg_level;
285 extern u_int8_t twa_call_dbg_level;
286
287 /* Printf with the bus device in question. */
288 #define twa_dbg_dprint(dbg_level, sc, fmt, args...)             \
289         do {                                                    \
290                 if (dbg_level <= twa_dbg_level)                 \
291                         device_printf(sc->twa_bus_dev,          \
292                                 "%s: " fmt "\n", __func__ , ##args);\
293         } while(0)
294
295 #define twa_dbg_dprint_enter(dbg_level, sc)                     \
296         do {                                                    \
297                 if (dbg_level <= twa_call_dbg_level)            \
298                         device_printf(sc->twa_bus_dev,          \
299                                 "%s: entered.\n", __func__);    \
300         } while(0)
301
302 #define twa_dbg_dprint_exit(dbg_level, sc)                      \
303         do {                                                    \
304                 if (dbg_level <= twa_call_dbg_level)            \
305                         device_printf(sc->twa_bus_dev,          \
306                                 "%s: exiting.\n", __func__);    \
307         } while(0)
308
309 #define twa_dbg_print(dbg_level, fmt, args...)                  \
310         do {                                                    \
311                 if (dbg_level <= twa_dbg_level)                 \
312                         printf("%s: " fmt "\n", __func__ , ##args);\
313         } while(0)
314
315 #else
316 #define twa_dbg_dprint(dbg_level, sc, fmt, args...)
317 #define twa_dbg_dprint_enter(dbg_level, sc)
318 #define twa_dbg_dprint_exit(dbg_level, sc)
319 #define twa_dbg_print(dbg_level, fmt, args...)
320 #endif
321
322 #define twa_printf(sc, fmt, args...)    \
323         device_printf(sc->twa_bus_dev, fmt, ##args)