mfi(4): Fix a bug in the disk initialization code.
[dragonfly.git] / sys / dev / raid / mfi / mfivar.h
1 /*-
2  * Copyright (c) 2006 IronPort Systems
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 /*-
27  * Copyright (c) 2007 LSI Corp.
28  * Copyright (c) 2007 Rajesh Prabhakaran.
29  * All rights reserved.
30  *
31  * Redistribution and use in source and binary forms, with or without
32  * modification, are permitted provided that the following conditions
33  * are met:
34  * 1. Redistributions of source code must retain the above copyright
35  *    notice, this list of conditions and the following disclaimer.
36  * 2. Redistributions in binary form must reproduce the above copyright
37  *    notice, this list of conditions and the following disclaimer in the
38  *    documentation and/or other materials provided with the distribution.
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  */
52 /*-
53  * Redistribution and use in source and binary forms, with or without
54  * modification, are permitted provided that the following conditions
55  * are met:
56  *
57  *            Copyright 1994-2009 The FreeBSD Project.
58  *            All rights reserved.
59  *
60  * 1. Redistributions of source code must retain the above copyright
61  *    notice, this list of conditions and the following disclaimer.
62  * 2. Redistributions in binary form must reproduce the above copyright
63  *    notice, this list of conditions and the following disclaimer in the
64  *    documentation and/or other materials provided with the distribution.
65  *
66  *    THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT``AS IS'' AND
67  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
68  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
69  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FREEBSD PROJECT OR
70  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
71  * EXEMPLARY,OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
72  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
73  * PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY THEORY
74  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
75  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
76  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
77  *
78  * The views and conclusions contained in the software and documentation
79  * are those of the authors and should not be interpreted as representing
80  * official policies,either expressed or implied, of the FreeBSD Project.
81  *
82  * $FreeBSD: src/sys/dev/mfi/mfivar.h,v 1.13 2009/07/10 08:18:08 scottl Exp $
83  */
84
85 #ifndef _MFIVAR_H
86 #define _MFIVAR_H
87
88 #include <sys/devicestat.h>
89 #include <sys/disk.h>
90 #include <sys/eventhandler.h>
91 #include <sys/lock.h>
92 #include <sys/sysctl.h>
93
94 /*
95  * SCSI structures and definitions are used from here, but no linking
96  * requirements are made to CAM.
97  */
98 #include <bus/cam/scsi/scsi_all.h>
99
100 struct mfi_hwcomms {
101         uint32_t                hw_pi;
102         uint32_t                hw_ci;
103         uint32_t                hw_reply_q[1];
104 };
105
106 struct mfi_softc;
107 struct disk;
108 struct ccb_hdr;
109
110 struct mfi_command {
111         TAILQ_ENTRY(mfi_command) cm_link;
112         time_t                  cm_timestamp;
113         struct mfi_softc        *cm_sc;
114         union mfi_frame         *cm_frame;
115 #if defined(__x86_64__)
116         uint64_t                cm_frame_busaddr;
117 #else
118         uint32_t                cm_frame_busaddr;
119 #endif
120         struct mfi_sense        *cm_sense;
121 #if defined(__x86_64__)
122         uint64_t                cm_sense_busaddr;
123 #else
124         uint32_t                cm_sense_busaddr;
125 #endif
126         bus_dmamap_t            cm_dmamap;
127         union mfi_sgl           *cm_sg;
128         void                    *cm_data;
129         int                     cm_len;
130         int                     cm_total_frame_size;
131         int                     cm_extra_frames;
132         int                     cm_flags;
133 #define MFI_CMD_MAPPED          (1<<0)
134 #define MFI_CMD_DATAIN          (1<<1)
135 #define MFI_CMD_DATAOUT         (1<<2)
136 #define MFI_CMD_COMPLETED       (1<<3)
137 #define MFI_CMD_POLLED          (1<<4)
138 #define MFI_ON_MFIQ_FREE        (1<<5)
139 #define MFI_ON_MFIQ_READY       (1<<6)
140 #define MFI_ON_MFIQ_BUSY        (1<<7)
141 #define MFI_ON_MFIQ_MASK        ((1<<5)|(1<<6)|(1<<7))
142         int                     cm_aen_abort;
143         void                    (* cm_complete)(struct mfi_command *cm);
144         void                    *cm_private;
145         int                     cm_index;
146         int                     cm_error;
147 };
148
149 /*
150  * XXX swildner
151  *
152  * At the moment we rely on mfi_disk and mfi_system_pd having the same size.
153  * A future cleanup should merge them.
154  */
155 struct mfi_disk {
156         TAILQ_ENTRY(mfi_disk)   ld_link;
157         device_t        ld_dev;
158         cdev_t          ld_dev_t;
159         int             ld_id;
160         int             ld_unit;
161         struct mfi_softc *ld_controller;
162         struct mfi_ld_info      *ld_info;
163         struct disk     ld_disk;
164         struct devstat  ld_devstat;
165         int             ld_flags;
166 #define MFI_DISK_FLAGS_OPEN     0x01
167 #define MFI_DISK_FLAGS_DISABLED 0x02
168 #define MFI_DISK_FLAGS_SYSPD    0x04
169 };
170
171 struct mfi_system_pd {
172         TAILQ_ENTRY(mfi_system_pd)      pd_link;
173         device_t        pd_dev;
174         cdev_t          pd_dev_t;
175         int             pd_id;
176         int             pd_unit;
177         struct mfi_softc *pd_controller;
178         struct mfi_pd_info      *pd_info;
179         struct disk     pd_disk;
180         struct devstat  pd_devstat;
181         int             pd_flags;
182 };
183
184 struct mfi_aen {
185         TAILQ_ENTRY(mfi_aen) aen_link;
186         struct proc                     *p;
187 };
188
189 struct mfi_softc {
190         device_t                        mfi_dev;
191         int                             mfi_flags;
192 #define MFI_FLAGS_SG64          (1<<0)
193 #define MFI_FLAGS_QFRZN         (1<<1)
194 #define MFI_FLAGS_OPEN          (1<<2)
195 #define MFI_FLAGS_STOP          (1<<3)
196 #define MFI_FLAGS_1064R         (1<<4)
197 #define MFI_FLAGS_1078          (1<<5)
198 #define MFI_FLAGS_GEN2          (1<<6)
199 #define MFI_FLAGS_SKINNY        (1<<7)
200
201         struct mfi_hwcomms              *mfi_comms;
202         TAILQ_HEAD(,mfi_command)        mfi_free;
203         TAILQ_HEAD(,mfi_command)        mfi_ready;
204         TAILQ_HEAD(,mfi_command)        mfi_busy;
205         struct bio_queue_head           mfi_bioq;
206         struct mfi_qstat                mfi_qstat[MFIQ_COUNT];
207
208         struct resource                 *mfi_regs_resource;
209         bus_space_handle_t              mfi_bhandle;
210         bus_space_tag_t                 mfi_btag;
211         int                             mfi_regs_rid;
212
213         bus_dma_tag_t                   mfi_parent_dmat;
214         bus_dma_tag_t                   mfi_buffer_dmat;
215
216         bus_dma_tag_t                   mfi_comms_dmat;
217         bus_dmamap_t                    mfi_comms_dmamap;
218         uint32_t                        mfi_comms_busaddr;
219
220         bus_dma_tag_t                   mfi_frames_dmat;
221         bus_dmamap_t                    mfi_frames_dmamap;
222         uint32_t                        mfi_frames_busaddr;
223         union mfi_frame                 *mfi_frames;
224
225         TAILQ_HEAD(,mfi_aen)            mfi_aen_pids;
226         struct mfi_command              *mfi_aen_cm;
227         struct mfi_command              *mfi_skinny_cm;
228         uint32_t                        mfi_aen_triggered;
229         uint32_t                        mfi_poll_waiting;
230         struct kqinfo                   mfi_kq;
231         int                             mfi_delete_busy_volumes;
232         int                             mfi_keep_deleted_volumes;
233         int                             mfi_detaching;
234
235         bus_dma_tag_t                   mfi_sense_dmat;
236         bus_dmamap_t                    mfi_sense_dmamap;
237         uint32_t                        mfi_sense_busaddr;
238         struct mfi_sense                *mfi_sense;
239
240         struct resource                 *mfi_irq;
241         void                            *mfi_intr;
242         int                             mfi_irq_rid;
243
244         struct intr_config_hook         mfi_ich;
245         eventhandler_tag                eh;
246
247         /*
248          * Allocation for the command array.  Used as an indexable array to
249          * recover completed commands.
250          */
251         struct mfi_command              *mfi_commands;
252         /*
253          * How many commands were actually allocated
254          */
255         int                             mfi_total_cmds;
256         /*
257          * How many commands the firmware can handle.  Also how big the reply
258          * queue is, minus 1.
259          */
260         int                             mfi_max_fw_cmds;
261         /*
262          * How many S/G elements we'll ever actually use
263          */
264         int                             mfi_max_sge;
265         /*
266          * How many bytes a compound frame is, including all of the extra frames
267          * that are used for S/G elements.
268          */
269         int                             mfi_cmd_size;
270         /*
271          * How large an S/G element is.  Used to calculate the number of single
272          * frames in a command.
273          */
274         int                             mfi_sge_size;
275         /*
276          * Max number of sectors that the firmware allows
277          */
278         uint32_t                        mfi_max_io;
279
280         TAILQ_HEAD(,mfi_disk)           mfi_ld_tqh;
281         TAILQ_HEAD(,mfi_system_pd)      mfi_syspd_tqh;
282         eventhandler_tag                mfi_eh;
283         struct cdev                     *mfi_cdev;
284
285         TAILQ_HEAD(, ccb_hdr)           mfi_cam_ccbq;
286         struct mfi_command *            (* mfi_cam_start)(void *);
287         struct callout                  mfi_watchdog_callout;
288         struct lock                     mfi_io_lock;
289         struct lock                     mfi_config_lock;
290
291         struct sysctl_ctx_list          mfi_sysctl_ctx;
292         struct sysctl_oid               *mfi_sysctl_tree;
293
294         /* Controller type specific interfaces */
295         void    (*mfi_enable_intr)(struct mfi_softc *sc);
296         int32_t (*mfi_read_fw_status)(struct mfi_softc *sc);
297         int     (*mfi_check_clear_intr)(struct mfi_softc *sc);
298         void    (*mfi_issue_cmd)(struct mfi_softc *sc,uint32_t bus_add,uint32_t frame_cnt);
299 };
300
301 extern int mfi_attach(struct mfi_softc *);
302 extern void mfi_free(struct mfi_softc *);
303 extern int mfi_shutdown(struct mfi_softc *);
304 extern void mfi_startio(struct mfi_softc *);
305 extern void mfi_disk_complete(struct bio *);
306 extern int mfi_disk_disable(struct mfi_disk *);
307 extern void mfi_disk_enable(struct mfi_disk *);
308 extern int mfi_dump_blocks(struct mfi_softc *, int id, uint64_t, void *, int);
309 extern int mfi_syspd_disable(struct mfi_system_pd *);
310 extern void mfi_syspd_enable(struct mfi_system_pd *);
311 extern int mfi_dump_syspd_blocks(struct mfi_softc *, int id, uint64_t, void *, int);
312
313 #define MFIQ_ADD(sc, qname)                                     \
314         do {                                                    \
315                 struct mfi_qstat *qs;                           \
316                                                                 \
317                 qs = &(sc)->mfi_qstat[qname];                   \
318                 qs->q_length++;                                 \
319                 if (qs->q_length > qs->q_max)                   \
320                         qs->q_max = qs->q_length;               \
321         } while (0)
322
323 #define MFIQ_REMOVE(sc, qname)  (sc)->mfi_qstat[qname].q_length--
324
325 #define MFIQ_INIT(sc, qname)                                    \
326         do {                                                    \
327                 sc->mfi_qstat[qname].q_length = 0;              \
328                 sc->mfi_qstat[qname].q_max = 0;                 \
329         } while (0)
330
331 #define MFIQ_COMMAND_QUEUE(name, index)                                 \
332         static __inline void                                            \
333         mfi_initq_ ## name (struct mfi_softc *sc)                       \
334         {                                                               \
335                 TAILQ_INIT(&sc->mfi_ ## name);                          \
336                 MFIQ_INIT(sc, index);                                   \
337         }                                                               \
338         static __inline void                                            \
339         mfi_enqueue_ ## name (struct mfi_command *cm)                   \
340         {                                                               \
341                 if ((cm->cm_flags & MFI_ON_MFIQ_MASK) != 0) {           \
342                         kprintf("command %p is on another queue, "      \
343                             "flags = %#x\n", cm, cm->cm_flags);         \
344                         panic("command is on another queue");           \
345                 }                                                       \
346                 TAILQ_INSERT_TAIL(&cm->cm_sc->mfi_ ## name, cm, cm_link); \
347                 cm->cm_flags |= MFI_ON_ ## index;                       \
348                 MFIQ_ADD(cm->cm_sc, index);                             \
349         }                                                               \
350         static __inline void                                            \
351         mfi_requeue_ ## name (struct mfi_command *cm)                   \
352         {                                                               \
353                 if ((cm->cm_flags & MFI_ON_MFIQ_MASK) != 0) {           \
354                         kprintf("command %p is on another queue, "      \
355                             "flags = %#x\n", cm, cm->cm_flags);         \
356                         panic("command is on another queue");           \
357                 }                                                       \
358                 TAILQ_INSERT_HEAD(&cm->cm_sc->mfi_ ## name, cm, cm_link); \
359                 cm->cm_flags |= MFI_ON_ ## index;                       \
360                 MFIQ_ADD(cm->cm_sc, index);                             \
361         }                                                               \
362         static __inline struct mfi_command *                            \
363         mfi_dequeue_ ## name (struct mfi_softc *sc)                     \
364         {                                                               \
365                 struct mfi_command *cm;                                 \
366                                                                         \
367                 if ((cm = TAILQ_FIRST(&sc->mfi_ ## name)) != NULL) {    \
368                         if ((cm->cm_flags & MFI_ON_ ## index) == 0) {   \
369                                 kprintf("command %p not in queue, "     \
370                                     "flags = %#x, bit = %#x\n", cm,     \
371                                     cm->cm_flags, MFI_ON_ ## index);    \
372                                 panic("command not in queue");          \
373                         }                                               \
374                         TAILQ_REMOVE(&sc->mfi_ ## name, cm, cm_link);   \
375                         cm->cm_flags &= ~MFI_ON_ ## index;              \
376                         MFIQ_REMOVE(sc, index);                         \
377                 }                                                       \
378                 return (cm);                                            \
379         }                                                               \
380         static __inline void                                            \
381         mfi_remove_ ## name (struct mfi_command *cm)                    \
382         {                                                               \
383                 if ((cm->cm_flags & MFI_ON_ ## index) == 0) {           \
384                         kprintf("command %p not in queue, flags = %#x, " \
385                             "bit = %#x\n", cm, cm->cm_flags,            \
386                             MFI_ON_ ## index);                          \
387                         panic("command not in queue");                  \
388                 }                                                       \
389                 TAILQ_REMOVE(&cm->cm_sc->mfi_ ## name, cm, cm_link);    \
390                 cm->cm_flags &= ~MFI_ON_ ## index;                      \
391                 MFIQ_REMOVE(cm->cm_sc, index);                          \
392         }                                                               \
393 struct hack
394
395 MFIQ_COMMAND_QUEUE(free, MFIQ_FREE);
396 MFIQ_COMMAND_QUEUE(ready, MFIQ_READY);
397 MFIQ_COMMAND_QUEUE(busy, MFIQ_BUSY);
398
399 static __inline void
400 mfi_initq_bio(struct mfi_softc *sc)
401 {
402         bioq_init(&sc->mfi_bioq);
403         MFIQ_INIT(sc, MFIQ_BIO);
404 }
405
406 static __inline void
407 mfi_enqueue_bio(struct mfi_softc *sc, struct bio *bp)
408 {
409         bioq_insert_tail(&sc->mfi_bioq, bp);
410         MFIQ_ADD(sc, MFIQ_BIO);
411 }
412
413 static __inline struct bio *
414 mfi_dequeue_bio(struct mfi_softc *sc)
415 {
416         struct bio *bp;
417
418         if ((bp = bioq_first(&sc->mfi_bioq)) != NULL) {
419                 bioq_remove(&sc->mfi_bioq, bp);
420                 MFIQ_REMOVE(sc, MFIQ_BIO);
421         }
422         return (bp);
423 }
424
425 static __inline void
426 mfi_print_sense(struct mfi_softc *sc, void *sense)
427 {
428         int error, key, asc, ascq;
429
430         scsi_extract_sense((struct scsi_sense_data *)sense,
431             &error, &key, &asc, &ascq);
432         device_printf(sc->mfi_dev, "sense error %d, sense_key %d, "
433             "asc %d, ascq %d\n", error, key, asc, ascq);
434 }
435
436
437 #define MFI_WRITE4(sc, reg, val)        bus_space_write_4((sc)->mfi_btag, \
438         sc->mfi_bhandle, (reg), (val))
439 #define MFI_READ4(sc, reg)              bus_space_read_4((sc)->mfi_btag, \
440         (sc)->mfi_bhandle, (reg))
441 #define MFI_WRITE2(sc, reg, val)        bus_space_write_2((sc)->mfi_btag, \
442         sc->mfi_bhandle, (reg), (val))
443 #define MFI_READ2(sc, reg)              bus_space_read_2((sc)->mfi_btag, \
444         (sc)->mfi_bhandle, (reg))
445 #define MFI_WRITE1(sc, reg, val)        bus_space_write_1((sc)->mfi_btag, \
446         sc->mfi_bhandle, (reg), (val))
447 #define MFI_READ1(sc, reg)              bus_space_read_1((sc)->mfi_btag, \
448         (sc)->mfi_bhandle, (reg))
449
450 MALLOC_DECLARE(M_MFIBUF);
451
452 #define MFI_CMD_TIMEOUT 30
453 #define MFI_MAXPHYS (128 * 1024)
454 #define SKINNY_MEMORY 0x02000000
455
456 #ifdef MFI_DEBUG
457 extern void mfi_print_cmd(struct mfi_command *cm);
458 extern void mfi_dump_cmds(struct mfi_softc *sc);
459 extern void mfi_validate_sg(struct mfi_softc *, struct mfi_command *, const char *, int );
460 #define MFI_PRINT_CMD(cm)       mfi_print_cmd(cm)
461 #define MFI_DUMP_CMDS(sc)       mfi_dump_cmds(sc)
462 #define MFI_VALIDATE_CMD(sc, cm) mfi_validate_sg(sc, cm, __FUNCTION__, __LINE__)
463 #else
464 #define MFI_PRINT_CMD(cm)
465 #define MFI_DUMP_CMDS(sc)
466 #define MFI_VALIDATE_CMD(sc, cm)
467 #endif
468
469 extern void mfi_release_command(struct mfi_command *cm);
470
471 #endif /* _MFIVAR_H */