92b6f190e707b7b9cbcf449754ea8ed121c2b841
[dragonfly.git] / sys / dev / raid / mfi / mfireg.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  * $FreeBSD: src/sys/dev/mfi/mfireg.h,v 1.16 2011/07/14 20:20:33 jhb Exp $
53  */
54
55 #ifndef _MFIREG_H
56 #define _MFIREG_H
57
58 /*
59  * MegaRAID SAS MFI firmware definitions
60  *
61  * Calling this driver 'MegaRAID SAS' is a bit misleading.  It's a completely
62  * new firmware interface from the old AMI MegaRAID one, and there is no
63  * reason why this interface should be limited to just SAS.  In any case, LSI
64  * seems to also call this interface 'MFI', so that will be used here.
65  */
66
67 /*
68  * Start with the register set.  All registers are 32 bits wide.
69  * The usual Intel IOP style setup.
70  */
71 #define MFI_IMSG0       0x10    /* Inbound message 0 */
72 #define MFI_IMSG1       0x14    /* Inbound message 1 */
73 #define MFI_OMSG0       0x18    /* Outbound message 0 */
74 #define MFI_OMSG1       0x1c    /* Outbound message 1 */
75 #define MFI_IDB         0x20    /* Inbound doorbell */
76 #define MFI_ISTS        0x24    /* Inbound interrupt status */
77 #define MFI_IMSK        0x28    /* Inbound interrupt mask */
78 #define MFI_ODB         0x2c    /* Outbound doorbell */
79 #define MFI_OSTS        0x30    /* Outbound interrupt status */
80 #define MFI_OMSK        0x34    /* Outbound interrupt mask */
81 #define MFI_IQP         0x40    /* Inbound queue port */
82 #define MFI_OQP         0x44    /* Outbound queue port */
83
84 /*
85  * 1078 specific related register
86  */
87 #define MFI_ODR0        0x9c            /* outbound doorbell register0 */
88 #define MFI_ODCR0       0xa0            /* outbound doorbell clear register0  */
89 #define MFI_OSP0        0xb0            /* outbound scratch pad0  */
90 #define MFI_1078_EIM    0x80000004      /* 1078 enable intrrupt mask  */
91 #define MFI_RMI         0x2             /* reply message interrupt  */
92 #define MFI_1078_RM     0x80000000      /* reply 1078 message interrupt  */
93 #define MFI_ODC         0x4             /* outbound doorbell change interrupt */
94
95 /*
96  * GEN2 specific changes
97  */
98 #define MFI_GEN2_EIM    0x00000005      /* GEN2 enable interrupt mask */
99 #define MFI_GEN2_RM     0x00000001      /* reply GEN2 message interrupt */
100
101 /* Bits for MFI_OSTS */
102 #define MFI_OSTS_INTR_VALID     0x00000002
103
104 /*
105  * Firmware state values.  Found in OMSG0 during initialization.
106  */
107 #define MFI_FWSTATE_MASK                0xf0000000
108 #define MFI_FWSTATE_UNDEFINED           0x00000000
109 #define MFI_FWSTATE_BB_INIT             0x10000000
110 #define MFI_FWSTATE_FW_INIT             0x40000000
111 #define MFI_FWSTATE_WAIT_HANDSHAKE      0x60000000
112 #define MFI_FWSTATE_FW_INIT_2           0x70000000
113 #define MFI_FWSTATE_DEVICE_SCAN         0x80000000
114 #define MFI_FWSTATE_BOOT_MESSAGE_PENDING        0x90000000
115 #define MFI_FWSTATE_FLUSH_CACHE         0xa0000000
116 #define MFI_FWSTATE_READY               0xb0000000
117 #define MFI_FWSTATE_OPERATIONAL         0xc0000000
118 #define MFI_FWSTATE_FAULT               0xf0000000
119 #define MFI_FWSTATE_MAXSGL_MASK         0x00ff0000
120 #define MFI_FWSTATE_MAXCMD_MASK         0x0000ffff
121
122 /*
123  * Control bits to drive the card to ready state.  These go into the IDB
124  * register.
125  */
126 #define MFI_FWINIT_ABORT        0x00000000 /* Abort all pending commands */
127 #define MFI_FWINIT_READY        0x00000002 /* Move from operational to ready */
128 #define MFI_FWINIT_MFIMODE      0x00000004 /* unknown */
129 #define MFI_FWINIT_CLEAR_HANDSHAKE 0x00000008 /* Respond to WAIT_HANDSHAKE */
130 #define MFI_FWINIT_HOTPLUG      0x00000010
131
132 /* MFI Commands */
133 typedef enum {
134         MFI_CMD_INIT =          0x00,
135         MFI_CMD_LD_READ,
136         MFI_CMD_LD_WRITE,
137         MFI_CMD_LD_SCSI_IO,
138         MFI_CMD_PD_SCSI_IO,
139         MFI_CMD_DCMD,
140         MFI_CMD_ABORT,
141         MFI_CMD_SMP,
142         MFI_CMD_STP
143 } mfi_cmd_t;
144
145 /* Direct commands */
146 typedef enum {
147         MFI_DCMD_CTRL_GETINFO =         0x01010000,
148         MFI_DCMD_CTRL_MFC_DEFAULTS_GET =0x010e0201,
149         MFI_DCMD_CTRL_MFC_DEFAULTS_SET =0x010e0202,
150         MFI_DCMD_CTRL_FLUSHCACHE =      0x01101000,
151         MFI_DCMD_CTRL_SHUTDOWN =        0x01050000,
152         MFI_DCMD_CTRL_EVENT_GETINFO =   0x01040100,
153         MFI_DCMD_CTRL_EVENT_GET =       0x01040300,
154         MFI_DCMD_CTRL_EVENT_WAIT =      0x01040500,
155         MFI_DCMD_PR_GET_STATUS =        0x01070100,
156         MFI_DCMD_PR_GET_PROPERTIES =    0x01070200,
157         MFI_DCMD_PR_SET_PROPERTIES =    0x01070300,
158         MFI_DCMD_PR_START =             0x01070400,
159         MFI_DCMD_PR_STOP =              0x01070500,
160         MFI_DCMD_TIME_SECS_GET =        0x01080201,
161         MFI_DCMD_FLASH_FW_OPEN =        0x010f0100,
162         MFI_DCMD_FLASH_FW_DOWNLOAD =    0x010f0200,
163         MFI_DCMD_FLASH_FW_FLASH =       0x010f0300,
164         MFI_DCMD_FLASH_FW_CLOSE =       0x010f0400,
165         MFI_DCMD_PD_GET_LIST =          0x02010000,
166         MFI_DCMD_PD_GET_INFO =          0x02020000,
167         MFI_DCMD_PD_STATE_SET =         0x02030100,
168         MFI_DCMD_PD_REBUILD_START =     0x02040100,
169         MFI_DCMD_PD_REBUILD_ABORT =     0x02040200,
170         MFI_DCMD_PD_CLEAR_START =       0x02050100,
171         MFI_DCMD_PD_CLEAR_ABORT =       0x02050200,
172         MFI_DCMD_PD_GET_PROGRESS =      0x02060000,
173         MFI_DCMD_PD_LOCATE_START =      0x02070100,
174         MFI_DCMD_PD_LOCATE_STOP =       0x02070200,
175         MFI_DCMD_LD_GET_LIST =          0x03010000,
176         MFI_DCMD_LD_GET_INFO =          0x03020000,
177         MFI_DCMD_LD_GET_PROP =          0x03030000,
178         MFI_DCMD_LD_SET_PROP =          0x03040000,
179         MFI_DCMD_LD_INIT_START =        0x03060100,
180         MFI_DCMD_LD_DELETE =            0x03090000,
181         MFI_DCMD_CFG_READ =             0x04010000,
182         MFI_DCMD_CFG_ADD =              0x04020000,
183         MFI_DCMD_CFG_CLEAR =            0x04030000,
184         MFI_DCMD_CFG_MAKE_SPARE =       0x04040000,
185         MFI_DCMD_CFG_REMOVE_SPARE =     0x04050000,
186         MFI_DCMD_CFG_FOREIGN_IMPORT =   0x04060400,
187         MFI_DCMD_BBU_GET_STATUS =       0x05010000,
188         MFI_DCMD_BBU_GET_CAPACITY_INFO =0x05020000,
189         MFI_DCMD_BBU_GET_DESIGN_INFO =  0x05030000,
190         MFI_DCMD_CLUSTER =              0x08000000,
191         MFI_DCMD_CLUSTER_RESET_ALL =    0x08010100,
192         MFI_DCMD_CLUSTER_RESET_LD =     0x08010200
193 } mfi_dcmd_t;
194
195 /* Modifiers for MFI_DCMD_CTRL_FLUSHCACHE */
196 #define MFI_FLUSHCACHE_CTRL     0x01
197 #define MFI_FLUSHCACHE_DISK     0x02
198
199 /* Modifiers for MFI_DCMD_CTRL_SHUTDOWN */
200 #define MFI_SHUTDOWN_SPINDOWN   0x01
201
202 /*
203  * MFI Frame flags
204  */
205 #define MFI_FRAME_POST_IN_REPLY_QUEUE           0x0000
206 #define MFI_FRAME_DONT_POST_IN_REPLY_QUEUE      0x0001
207 #define MFI_FRAME_SGL32                         0x0000
208 #define MFI_FRAME_SGL64                         0x0002
209 #define MFI_FRAME_SENSE32                       0x0000
210 #define MFI_FRAME_SENSE64                       0x0004
211 #define MFI_FRAME_DIR_NONE                      0x0000
212 #define MFI_FRAME_DIR_WRITE                     0x0008
213 #define MFI_FRAME_DIR_READ                      0x0010
214 #define MFI_FRAME_DIR_BOTH                      0x0018
215
216 /* MFI Status codes */
217 typedef enum {
218         MFI_STAT_OK =                   0x00,
219         MFI_STAT_INVALID_CMD,
220         MFI_STAT_INVALID_DCMD,
221         MFI_STAT_INVALID_PARAMETER,
222         MFI_STAT_INVALID_SEQUENCE_NUMBER,
223         MFI_STAT_ABORT_NOT_POSSIBLE,
224         MFI_STAT_APP_HOST_CODE_NOT_FOUND,
225         MFI_STAT_APP_IN_USE,
226         MFI_STAT_APP_NOT_INITIALIZED,
227         MFI_STAT_ARRAY_INDEX_INVALID,
228         MFI_STAT_ARRAY_ROW_NOT_EMPTY,
229         MFI_STAT_CONFIG_RESOURCE_CONFLICT,
230         MFI_STAT_DEVICE_NOT_FOUND,
231         MFI_STAT_DRIVE_TOO_SMALL,
232         MFI_STAT_FLASH_ALLOC_FAIL,
233         MFI_STAT_FLASH_BUSY,
234         MFI_STAT_FLASH_ERROR =          0x10,
235         MFI_STAT_FLASH_IMAGE_BAD,
236         MFI_STAT_FLASH_IMAGE_INCOMPLETE,
237         MFI_STAT_FLASH_NOT_OPEN,
238         MFI_STAT_FLASH_NOT_STARTED,
239         MFI_STAT_FLUSH_FAILED,
240         MFI_STAT_HOST_CODE_NOT_FOUNT,
241         MFI_STAT_LD_CC_IN_PROGRESS,
242         MFI_STAT_LD_INIT_IN_PROGRESS,
243         MFI_STAT_LD_LBA_OUT_OF_RANGE,
244         MFI_STAT_LD_MAX_CONFIGURED,
245         MFI_STAT_LD_NOT_OPTIMAL,
246         MFI_STAT_LD_RBLD_IN_PROGRESS,
247         MFI_STAT_LD_RECON_IN_PROGRESS,
248         MFI_STAT_LD_WRONG_RAID_LEVEL,
249         MFI_STAT_MAX_SPARES_EXCEEDED,
250         MFI_STAT_MEMORY_NOT_AVAILABLE = 0x20,
251         MFI_STAT_MFC_HW_ERROR,
252         MFI_STAT_NO_HW_PRESENT,
253         MFI_STAT_NOT_FOUND,
254         MFI_STAT_NOT_IN_ENCL,
255         MFI_STAT_PD_CLEAR_IN_PROGRESS,
256         MFI_STAT_PD_TYPE_WRONG,
257         MFI_STAT_PR_DISABLED,
258         MFI_STAT_ROW_INDEX_INVALID,
259         MFI_STAT_SAS_CONFIG_INVALID_ACTION,
260         MFI_STAT_SAS_CONFIG_INVALID_DATA,
261         MFI_STAT_SAS_CONFIG_INVALID_PAGE,
262         MFI_STAT_SAS_CONFIG_INVALID_TYPE,
263         MFI_STAT_SCSI_DONE_WITH_ERROR,
264         MFI_STAT_SCSI_IO_FAILED,
265         MFI_STAT_SCSI_RESERVATION_CONFLICT,
266         MFI_STAT_SHUTDOWN_FAILED =      0x30,
267         MFI_STAT_TIME_NOT_SET,
268         MFI_STAT_WRONG_STATE,
269         MFI_STAT_LD_OFFLINE,
270         MFI_STAT_PEER_NOTIFICATION_REJECTED,
271         MFI_STAT_PEER_NOTIFICATION_FAILED,
272         MFI_STAT_RESERVATION_IN_PROGRESS,
273         MFI_STAT_I2C_ERRORS_DETECTED,
274         MFI_STAT_PCI_ERRORS_DETECTED,
275         MFI_STAT_DIAG_FAILED,
276         MFI_STAT_BOOT_MSG_PENDING,
277         MFI_STAT_FOREIGN_CONFIG_INCOMPLETE,
278         MFI_STAT_INVALID_STATUS =       0xFF
279 } mfi_status_t;
280
281 typedef enum {
282         MFI_EVT_CLASS_DEBUG =           -2,
283         MFI_EVT_CLASS_PROGRESS =        -1,
284         MFI_EVT_CLASS_INFO =            0,
285         MFI_EVT_CLASS_WARNING =         1,
286         MFI_EVT_CLASS_CRITICAL =        2,
287         MFI_EVT_CLASS_FATAL =           3,
288         MFI_EVT_CLASS_DEAD =            4
289 } mfi_evt_class_t;
290
291 typedef enum {
292         MFI_EVT_LOCALE_LD =             0x0001,
293         MFI_EVT_LOCALE_PD =             0x0002,
294         MFI_EVT_LOCALE_ENCL =           0x0004,
295         MFI_EVT_LOCALE_BBU =            0x0008,
296         MFI_EVT_LOCALE_SAS =            0x0010,
297         MFI_EVT_LOCALE_CTRL =           0x0020,
298         MFI_EVT_LOCALE_CONFIG =         0x0040,
299         MFI_EVT_LOCALE_CLUSTER =        0x0080,
300         MFI_EVT_LOCALE_ALL =            0xffff
301 } mfi_evt_locale_t;
302
303 typedef enum {
304         MR_EVT_ARGS_NONE =              0x00,
305         MR_EVT_ARGS_CDB_SENSE,
306         MR_EVT_ARGS_LD,
307         MR_EVT_ARGS_LD_COUNT,
308         MR_EVT_ARGS_LD_LBA,
309         MR_EVT_ARGS_LD_OWNER,
310         MR_EVT_ARGS_LD_LBA_PD_LBA,
311         MR_EVT_ARGS_LD_PROG,
312         MR_EVT_ARGS_LD_STATE,
313         MR_EVT_ARGS_LD_STRIP,
314         MR_EVT_ARGS_PD,
315         MR_EVT_ARGS_PD_ERR,
316         MR_EVT_ARGS_PD_LBA,
317         MR_EVT_ARGS_PD_LBA_LD,
318         MR_EVT_ARGS_PD_PROG,
319         MR_EVT_ARGS_PD_STATE,
320         MR_EVT_ARGS_PCI,
321         MR_EVT_ARGS_RATE,
322         MR_EVT_ARGS_STR,
323         MR_EVT_ARGS_TIME,
324         MR_EVT_ARGS_ECC
325 } mfi_evt_args;
326
327 typedef enum {
328         MR_LD_CACHE_WRITE_BACK =        0x01,
329         MR_LD_CACHE_WRITE_ADAPTIVE =    0x02,
330         MR_LD_CACHE_READ_AHEAD =        0x04,
331         MR_LD_CACHE_READ_ADAPTIVE =     0x08,
332         MR_LD_CACHE_WRITE_CACHE_BAD_BBU=0x10,
333         MR_LD_CACHE_ALLOW_WRITE_CACHE = 0x20,
334         MR_LD_CACHE_ALLOW_READ_CACHE =  0x40
335 } mfi_ld_cache;
336 #define MR_LD_CACHE_MASK        0x7f
337
338 #define MR_LD_CACHE_POLICY_READ_AHEAD_NONE              0
339 #define MR_LD_CACHE_POLICY_READ_AHEAD_ALWAYS            MR_LD_CACHE_READ_AHEAD
340 #define MR_LD_CACHE_POLICY_READ_AHEAD_ADAPTIVE          \
341         (MR_LD_CACHE_READ_AHEAD | MR_LD_CACHE_READ_ADAPTIVE)
342 #define MR_LD_CACHE_POLICY_WRITE_THROUGH                0
343 #define MR_LD_CACHE_POLICY_WRITE_BACK                   MR_LD_CACHE_WRITE_BACK
344 #define MR_LD_CACHE_POLICY_IO_CACHED                    \
345         (MR_LD_CACHE_ALLOW_WRITE_CACHE | MR_LD_CACHE_ALLOW_READ_CACHE)
346 #define MR_LD_CACHE_POLICY_IO_DIRECT                    0
347
348 typedef enum {
349         MR_PD_CACHE_UNCHANGED  =        0,
350         MR_PD_CACHE_ENABLE =            1,
351         MR_PD_CACHE_DISABLE =           2
352 } mfi_pd_cache;
353
354 /*
355  * Other propertities and definitions
356  */
357 #define MFI_MAX_PD_CHANNELS     2
358 #define MFI_MAX_LD_CHANNELS     2
359 #define MFI_MAX_CHANNELS        (MFI_MAX_PD_CHANNELS + MFI_MAX_LD_CHANNELS)
360 #define MFI_MAX_CHANNEL_DEVS    128
361 #define MFI_DEFAULT_ID          -1
362 #define MFI_MAX_LUN             8
363 #define MFI_MAX_LD              64
364 #define MFI_MAX_PD              256
365
366 #define MFI_FRAME_SIZE          64
367 #define MFI_MBOX_SIZE           12
368
369 /* Firmware flashing can take 40s */
370 #define MFI_POLL_TIMEOUT_SECS   50
371
372 /* Allow for speedier math calculations */
373 #define MFI_SECTOR_LEN          512
374
375 /* Scatter Gather elements */
376 struct mfi_sg32 {
377         uint32_t        addr;
378         uint32_t        len;
379 } __packed;
380
381 struct mfi_sg64 {
382         uint64_t        addr;
383         uint32_t        len;
384 } __packed;
385
386 union mfi_sgl {
387         struct mfi_sg32 sg32[1];
388         struct mfi_sg64 sg64[1];
389 } __packed;
390
391 /* Message frames.  All messages have a common header */
392 struct mfi_frame_header {
393         uint8_t         cmd;
394         uint8_t         sense_len;
395         uint8_t         cmd_status;
396         uint8_t         scsi_status;
397         uint8_t         target_id;
398         uint8_t         lun_id;
399         uint8_t         cdb_len;
400         uint8_t         sg_count;
401         uint32_t        context;
402         uint32_t        pad0;
403         uint16_t        flags;
404 #define MFI_FRAME_DATAOUT       0x08
405 #define MFI_FRAME_DATAIN        0x10
406         uint16_t        timeout;
407         uint32_t        data_len;
408 } __packed;
409
410 struct mfi_init_frame {
411         struct mfi_frame_header header;
412         uint32_t        qinfo_new_addr_lo;
413         uint32_t        qinfo_new_addr_hi;
414         uint32_t        qinfo_old_addr_lo;
415         uint32_t        qinfo_old_addr_hi;
416         uint32_t        reserved[6];
417 } __packed;
418
419 #define MFI_IO_FRAME_SIZE 40
420 struct mfi_io_frame {
421         struct mfi_frame_header header;
422         uint32_t        sense_addr_lo;
423         uint32_t        sense_addr_hi;
424         uint32_t        lba_lo;
425         uint32_t        lba_hi;
426         union mfi_sgl   sgl;
427 } __packed;
428
429 #define MFI_PASS_FRAME_SIZE 48
430 struct mfi_pass_frame {
431         struct mfi_frame_header header;
432         uint32_t        sense_addr_lo;
433         uint32_t        sense_addr_hi;
434         uint8_t         cdb[16];
435         union mfi_sgl   sgl;
436 } __packed;
437
438 #define MFI_DCMD_FRAME_SIZE 40
439 struct mfi_dcmd_frame {
440         struct mfi_frame_header header;
441         uint32_t        opcode;
442         uint8_t         mbox[MFI_MBOX_SIZE];
443         union mfi_sgl   sgl;
444 } __packed;
445
446 struct mfi_abort_frame {
447         struct mfi_frame_header header;
448         uint32_t        abort_context;
449         uint32_t        pad;
450         uint32_t        abort_mfi_addr_lo;
451         uint32_t        abort_mfi_addr_hi;
452         uint32_t        reserved[6];
453 } __packed;
454
455 struct mfi_smp_frame {
456         struct mfi_frame_header header;
457         uint64_t        sas_addr;
458         union {
459                 struct mfi_sg32 sg32[2];
460                 struct mfi_sg64 sg64[2];
461         } sgl;
462 } __packed;
463
464 struct mfi_stp_frame {
465         struct mfi_frame_header header;
466         uint16_t        fis[10];
467         uint32_t        stp_flags;
468         union {
469                 struct mfi_sg32 sg32[2];
470                 struct mfi_sg64 sg64[2];
471         } sgl;
472 } __packed;
473
474 union mfi_frame {
475         struct mfi_frame_header header;
476         struct mfi_init_frame   init;
477         struct mfi_io_frame     io;
478         struct mfi_pass_frame   pass;
479         struct mfi_dcmd_frame   dcmd;
480         struct mfi_abort_frame  abort;
481         struct mfi_smp_frame    smp;
482         struct mfi_stp_frame    stp;
483         uint8_t                 bytes[MFI_FRAME_SIZE];
484 };
485
486 #define MFI_SENSE_LEN 128
487 struct mfi_sense {
488         uint8_t         data[MFI_SENSE_LEN];
489 };
490
491 /* The queue init structure that is passed with the init message */
492 struct mfi_init_qinfo {
493         uint32_t        flags;
494         uint32_t        rq_entries;
495         uint32_t        rq_addr_lo;
496         uint32_t        rq_addr_hi;
497         uint32_t        pi_addr_lo;
498         uint32_t        pi_addr_hi;
499         uint32_t        ci_addr_lo;
500         uint32_t        ci_addr_hi;
501 } __packed;
502
503 /* SAS (?) controller properties, part of mfi_ctrl_info */
504 struct mfi_ctrl_props {
505         uint16_t        seq_num;
506         uint16_t        pred_fail_poll_interval;
507         uint16_t        intr_throttle_cnt;
508         uint16_t        intr_throttle_timeout;
509         uint8_t         rebuild_rate;
510         uint8_t         patrol_read_rate;
511         uint8_t         bgi_rate;
512         uint8_t         cc_rate;
513         uint8_t         recon_rate;
514         uint8_t         cache_flush_interval;
515         uint8_t         spinup_drv_cnt;
516         uint8_t         spinup_delay;
517         uint8_t         cluster_enable;
518         uint8_t         coercion_mode;
519         uint8_t         alarm_enable;
520         uint8_t         disable_auto_rebuild;
521         uint8_t         disable_battery_warn;
522         uint8_t         ecc_bucket_size;
523         uint16_t        ecc_bucket_leak_rate;
524         uint8_t         restore_hotspare_on_insertion;
525         uint8_t         expose_encl_devices;
526         uint8_t         reserved[38];
527 } __packed;
528
529 /* PCI information about the card. */
530 struct mfi_info_pci {
531         uint16_t        vendor;
532         uint16_t        device;
533         uint16_t        subvendor;
534         uint16_t        subdevice;
535         uint8_t         reserved[24];
536 } __packed;
537
538 /* Host (front end) interface information */
539 struct mfi_info_host {
540         uint8_t         type;
541 #define MFI_INFO_HOST_PCIX      0x01
542 #define MFI_INFO_HOST_PCIE      0x02
543 #define MFI_INFO_HOST_ISCSI     0x04
544 #define MFI_INFO_HOST_SAS3G     0x08
545         uint8_t         reserved[6];
546         uint8_t         port_count;
547         uint64_t        port_addr[8];
548 } __packed;
549
550 /* Device (back end) interface information */
551 struct mfi_info_device {
552         uint8_t         type;
553 #define MFI_INFO_DEV_SPI        0x01
554 #define MFI_INFO_DEV_SAS3G      0x02
555 #define MFI_INFO_DEV_SATA1      0x04
556 #define MFI_INFO_DEV_SATA3G     0x08
557         uint8_t         reserved[6];
558         uint8_t         port_count;
559         uint64_t        port_addr[8];
560 } __packed;
561
562 /* Firmware component information */
563 struct mfi_info_component {
564         char             name[8];
565         char             version[32];
566         char             build_date[16];
567         char             build_time[16];
568 } __packed;
569
570 /* Controller default settings */
571 struct mfi_defaults {
572         uint64_t        sas_addr;
573         uint8_t         phy_polarity;
574         uint8_t         background_rate;
575         uint8_t         stripe_size;
576         uint8_t         flush_time;
577         uint8_t         write_back;
578         uint8_t         read_ahead;
579         uint8_t         cache_when_bbu_bad;
580         uint8_t         cached_io;
581         uint8_t         smart_mode;
582         uint8_t         alarm_disable;
583         uint8_t         coercion;
584         uint8_t         zrc_config;
585         uint8_t         dirty_led_shows_drive_activity;
586         uint8_t         bios_continue_on_error;
587         uint8_t         spindown_mode;
588         uint8_t         allowed_device_types;
589         uint8_t         allow_mix_in_enclosure;
590         uint8_t         allow_mix_in_ld;
591         uint8_t         allow_sata_in_cluster;
592         uint8_t         max_chained_enclosures;
593         uint8_t         disable_ctrl_r;
594         uint8_t         enabel_web_bios;
595         uint8_t         phy_polarity_split;
596         uint8_t         direct_pd_mapping;
597         uint8_t         bios_enumerate_lds;
598         uint8_t         restored_hot_spare_on_insertion;
599         uint8_t         expose_enclosure_devices;
600         uint8_t         maintain_pd_fail_history;
601         uint8_t         resv[28];
602 } __packed;
603
604 /* Controller default settings */
605 struct mfi_bios_data {
606         uint16_t        boot_target_id;
607         uint8_t         do_not_int_13;
608         uint8_t         continue_on_error;
609         uint8_t         verbose;
610         uint8_t         geometry;
611         uint8_t         expose_all_drives;
612         uint8_t         reserved[56];
613         uint8_t         check_sum;
614 } __packed;
615
616 /* SAS (?) controller info, returned from MFI_DCMD_CTRL_GETINFO. */
617 struct mfi_ctrl_info {
618         struct mfi_info_pci     pci;
619         struct mfi_info_host    host;
620         struct mfi_info_device  device;
621
622         /* Firmware components that are present and active. */
623         uint32_t                image_check_word;
624         uint32_t                image_component_count;
625         struct mfi_info_component image_component[8];
626
627         /* Firmware components that have been flashed but are inactive */
628         uint32_t                pending_image_component_count;
629         struct mfi_info_component pending_image_component[8];
630
631         uint8_t                 max_arms;
632         uint8_t                 max_spans;
633         uint8_t                 max_arrays;
634         uint8_t                 max_lds;
635         char                    product_name[80];
636         char                    serial_number[32];
637         uint32_t                hw_present;
638 #define MFI_INFO_HW_BBU         0x01
639 #define MFI_INFO_HW_ALARM       0x02
640 #define MFI_INFO_HW_NVRAM       0x04
641 #define MFI_INFO_HW_UART        0x08
642         uint32_t                current_fw_time;
643         uint16_t                max_cmds;
644         uint16_t                max_sg_elements;
645         uint32_t                max_request_size;
646         uint16_t                lds_present;
647         uint16_t                lds_degraded;
648         uint16_t                lds_offline;
649         uint16_t                pd_present;
650         uint16_t                pd_disks_present;
651         uint16_t                pd_disks_pred_failure;
652         uint16_t                pd_disks_failed;
653         uint16_t                nvram_size;
654         uint16_t                memory_size;
655         uint16_t                flash_size;
656         uint16_t                ram_correctable_errors;
657         uint16_t                ram_uncorrectable_errors;
658         uint8_t                 cluster_allowed;
659         uint8_t                 cluster_active;
660         uint16_t                max_strips_per_io;
661
662         uint32_t                raid_levels;
663 #define MFI_INFO_RAID_0         0x01
664 #define MFI_INFO_RAID_1         0x02
665 #define MFI_INFO_RAID_5         0x04
666 #define MFI_INFO_RAID_1E        0x08
667 #define MFI_INFO_RAID_6         0x10
668
669         uint32_t                adapter_ops;
670 #define MFI_INFO_AOPS_RBLD_RATE         0x0001
671 #define MFI_INFO_AOPS_CC_RATE           0x0002
672 #define MFI_INFO_AOPS_BGI_RATE          0x0004
673 #define MFI_INFO_AOPS_RECON_RATE        0x0008
674 #define MFI_INFO_AOPS_PATROL_RATE       0x0010
675 #define MFI_INFO_AOPS_ALARM_CONTROL     0x0020
676 #define MFI_INFO_AOPS_CLUSTER_SUPPORTED 0x0040
677 #define MFI_INFO_AOPS_BBU               0x0080
678 #define MFI_INFO_AOPS_SPANNING_ALLOWED  0x0100
679 #define MFI_INFO_AOPS_DEDICATED_SPARES  0x0200
680 #define MFI_INFO_AOPS_REVERTIBLE_SPARES 0x0400
681 #define MFI_INFO_AOPS_FOREIGN_IMPORT    0x0800
682 #define MFI_INFO_AOPS_SELF_DIAGNOSTIC   0x1000
683 #define MFI_INFO_AOPS_MIXED_ARRAY       0x2000
684 #define MFI_INFO_AOPS_GLOBAL_SPARES     0x4000
685
686         uint32_t                ld_ops;
687 #define MFI_INFO_LDOPS_READ_POLICY      0x01
688 #define MFI_INFO_LDOPS_WRITE_POLICY     0x02
689 #define MFI_INFO_LDOPS_IO_POLICY        0x04
690 #define MFI_INFO_LDOPS_ACCESS_POLICY    0x08
691 #define MFI_INFO_LDOPS_DISK_CACHE_POLICY 0x10
692
693         struct {
694                 uint8_t         min;
695                 uint8_t         max;
696                 uint8_t         reserved[2];
697         } __packed stripe_sz_ops;
698
699         uint32_t                pd_ops;
700 #define MFI_INFO_PDOPS_FORCE_ONLINE     0x01
701 #define MFI_INFO_PDOPS_FORCE_OFFLINE    0x02
702 #define MFI_INFO_PDOPS_FORCE_REBUILD    0x04
703
704         uint32_t                pd_mix_support;
705 #define MFI_INFO_PDMIX_SAS              0x01
706 #define MFI_INFO_PDMIX_SATA             0x02
707 #define MFI_INFO_PDMIX_ENCL             0x04
708 #define MFI_INFO_PDMIX_LD               0x08
709 #define MFI_INFO_PDMIX_SATA_CLUSTER     0x10
710
711         uint8_t                 ecc_bucket_count;
712         uint8_t                 reserved2[11];
713         struct mfi_ctrl_props   properties;
714         char                    package_version[0x60];
715         uint8_t                 pad[0x800 - 0x6a0];
716 } __packed;
717
718 /* keep track of an event. */
719 union mfi_evt {
720         struct {
721                 uint16_t        locale;
722                 uint8_t         reserved;
723                 int8_t          evt_class;
724         } members;
725         uint32_t                word;
726 } __packed;
727
728 /* event log state. */
729 struct mfi_evt_log_state {
730         uint32_t                newest_seq_num;
731         uint32_t                oldest_seq_num;
732         uint32_t                clear_seq_num;
733         uint32_t                shutdown_seq_num;
734         uint32_t                boot_seq_num;
735 } __packed;
736
737 struct mfi_progress {
738         uint16_t                progress;
739         uint16_t                elapsed_seconds;
740 } __packed;
741
742 struct mfi_evt_ld {
743         uint16_t                target_id;
744         uint8_t                 ld_index;
745         uint8_t                 reserved;
746 } __packed;
747
748 struct mfi_evt_pd {
749         uint16_t                device_id;
750         uint8_t                 enclosure_index;
751         uint8_t                 slot_number;
752 } __packed;
753
754 /* SAS (?) event detail, returned from MFI_DCMD_CTRL_EVENT_WAIT. */
755 struct mfi_evt_detail {
756         uint32_t                seq;
757         uint32_t                time;
758         uint32_t                code;
759         union mfi_evt           evt_class;
760         uint8_t                 arg_type;
761         uint8_t                 reserved1[15];
762
763         union {
764                 struct {
765                         struct mfi_evt_pd       pd;
766                         uint8_t                 cdb_len;
767                         uint8_t                 sense_len;
768                         uint8_t                 reserved[2];
769                         uint8_t                 cdb[16];
770                         uint8_t                 sense[64];
771                 } cdb_sense;
772
773                 struct mfi_evt_ld               ld;
774
775                 struct {
776                         struct mfi_evt_ld       ld;
777                         uint64_t                count;
778                 } ld_count;
779
780                 struct {
781                         uint64_t                lba;
782                         struct mfi_evt_ld       ld;
783                 } ld_lba;
784
785                 struct {
786                         struct mfi_evt_ld       ld;
787                         uint32_t                pre_owner;
788                         uint32_t                new_owner;
789                 } ld_owner;
790
791                 struct {
792                         uint64_t                ld_lba;
793                         uint64_t                pd_lba;
794                         struct mfi_evt_ld       ld;
795                         struct mfi_evt_pd       pd;
796                 } ld_lba_pd_lba;
797
798                 struct {
799                         struct mfi_evt_ld       ld;
800                         struct mfi_progress     prog;
801                 } ld_prog;
802
803                 struct {
804                         struct mfi_evt_ld       ld;
805                         uint32_t                prev_state;
806                         uint32_t                new_state;
807                 } ld_state;
808
809                 struct {
810                         uint64_t                strip;
811                         struct mfi_evt_ld       ld;
812                 } ld_strip;
813
814                 struct mfi_evt_pd               pd;
815
816                 struct {
817                         struct mfi_evt_pd       pd;
818                         uint32_t                err;
819                 } pd_err;
820
821                 struct {
822                         uint64_t                lba;
823                         struct mfi_evt_pd       pd;
824                 } pd_lba;
825
826                 struct {
827                         uint64_t                lba;
828                         struct mfi_evt_pd       pd;
829                         struct mfi_evt_ld       ld;
830                 } pd_lba_ld;
831
832                 struct {
833                         struct mfi_evt_pd       pd;
834                         struct mfi_progress     prog;
835                 } pd_prog;
836
837                 struct {
838                         struct mfi_evt_pd       ld;
839                         uint32_t                prev_state;
840                         uint32_t                new_state;
841                 } pd_state;
842
843                 struct {
844                         uint16_t                venderId;
845                         uint16_t                deviceId;
846                         uint16_t                subVenderId;
847                         uint16_t                subDeviceId;
848                 } pci;
849
850                 uint32_t                        rate;
851
852                 char                            str[96];
853
854                 struct {
855                         uint32_t                rtc;
856                         uint16_t                elapsedSeconds;
857                 } time;
858
859                 struct {
860                         uint32_t                ecar;
861                         uint32_t                elog;
862                         char                    str[64];
863                 } ecc;
864
865                 uint8_t         b[96];
866                 uint16_t        s[48];
867                 uint32_t        w[24];
868                 uint64_t        d[12];
869         } args;
870
871         char description[128];
872 } __packed;
873
874 struct mfi_evt_list {
875         uint32_t                count;
876         uint32_t                reserved;
877         struct mfi_evt_detail   event[1];
878 } __packed;
879
880 union mfi_pd_ref {
881         struct {
882                 uint16_t        device_id;
883                 uint16_t        seq_num;
884         } v;
885         uint32_t        ref;
886 } __packed;
887
888 union mfi_pd_ddf_type {
889         struct {
890                 union {
891                         struct {
892                                 uint16_t        forced_pd_guid  : 1;
893                                 uint16_t        in_vd           : 1;
894                                 uint16_t        is_global_spare : 1;
895                                 uint16_t        is_spare        : 1;
896                                 uint16_t        is_foreign      : 1;
897                                 uint16_t        reserved        : 7;
898                                 uint16_t        intf            : 4;
899                         } pd_type;
900                         uint16_t        type;
901                 } v;
902                 uint16_t                reserved;
903         } ddf;
904         struct {
905                 uint32_t                reserved;
906         } non_disk;
907         uint32_t                        type;
908 } __packed;
909
910 struct mfi_pd_progress {
911         uint32_t                        active;
912 #define MFI_PD_PROGRESS_REBUILD (1<<0)
913 #define MFI_PD_PROGRESS_PATROL  (1<<1)
914 #define MFI_PD_PROGRESS_CLEAR   (1<<2)
915         struct mfi_progress             rbld;
916         struct mfi_progress             patrol;
917         struct mfi_progress             clear;
918         struct mfi_progress             reserved[4];
919 } __packed;
920
921 struct mfi_pd_info {
922         union mfi_pd_ref                ref;
923         uint8_t                         inquiry_data[96];
924         uint8_t                         vpd_page83[64];
925         uint8_t                         not_supported;
926         uint8_t                         scsi_dev_type;
927         uint8_t                         connected_port_bitmap;
928         uint8_t                         device_speed;
929         uint32_t                        media_err_count;
930         uint32_t                        other_err_count;
931         uint32_t                        pred_fail_count;
932         uint32_t                        last_pred_fail_event_seq_num;
933         uint16_t                        fw_state;       /* MFI_PD_STATE_* */
934         uint8_t                         disabled_for_removal;
935         uint8_t                         link_speed;
936         union mfi_pd_ddf_type           state;
937         struct {
938                 uint8_t                 count;
939                 uint8_t                 is_path_broken;
940                 uint8_t                 reserved[6];
941                 uint64_t                sas_addr[4];
942         } path_info;
943         uint64_t                        raw_size;
944         uint64_t                        non_coerced_size;
945         uint64_t                        coerced_size;
946         uint16_t                        encl_device_id;
947         uint8_t                         encl_index;
948         uint8_t                         slot_number;
949         struct mfi_pd_progress          prog_info;
950         uint8_t                         bad_block_table_full;
951         uint8_t                         unusable_in_current_config;
952         uint8_t                         vpd_page83_ext[64];
953         uint8_t                         reserved[512-358];
954 } __packed;
955
956 struct mfi_pd_address {
957         uint16_t                device_id;
958         uint16_t                encl_device_id;
959         uint8_t                 encl_index;
960         uint8_t                 slot_number;
961         uint8_t                 scsi_dev_type;  /* 0 = disk */
962         uint8_t                 connect_port_bitmap;
963         uint64_t                sas_addr[2];
964 } __packed;
965
966 struct mfi_pd_list {
967         uint32_t                size;
968         uint32_t                count;
969         struct mfi_pd_address   addr[0];
970 } __packed;
971
972 enum mfi_pd_state {
973         MFI_PD_STATE_UNCONFIGURED_GOOD = 0x00,
974         MFI_PD_STATE_UNCONFIGURED_BAD = 0x01,
975         MFI_PD_STATE_HOT_SPARE = 0x02,
976         MFI_PD_STATE_OFFLINE = 0x10,
977         MFI_PD_STATE_FAILED = 0x11,
978         MFI_PD_STATE_REBUILD = 0x14,
979         MFI_PD_STATE_ONLINE = 0x18,
980         MFI_PD_STATE_COPYBACK = 0x20,
981         MFI_PD_STATE_SYSTEM = 0x40
982 };
983
984 union mfi_ld_ref {
985         struct {
986                 uint8_t         target_id;
987                 uint8_t         reserved;
988                 uint16_t        seq;
989         } v;
990         uint32_t                ref;
991 } __packed;
992
993 struct mfi_ld_list {
994         uint32_t                ld_count;
995         uint32_t                reserved1;
996         struct {
997                 union mfi_ld_ref        ld;
998                 uint8_t         state;
999                 uint8_t         reserved2[3];
1000                 uint64_t        size;
1001         } ld_list[MFI_MAX_LD];
1002 } __packed;
1003
1004 enum mfi_ld_access {
1005         MFI_LD_ACCESS_RW =      0,
1006         MFI_LD_ACCSSS_RO =      2,
1007         MFI_LD_ACCESS_BLOCKED = 3,
1008 };
1009 #define MFI_LD_ACCESS_MASK      3
1010
1011 enum mfi_ld_state {
1012         MFI_LD_STATE_OFFLINE =                  0,
1013         MFI_LD_STATE_PARTIALLY_DEGRADED =       1,
1014         MFI_LD_STATE_DEGRADED =                 2,
1015         MFI_LD_STATE_OPTIMAL =                  3
1016 };
1017
1018 struct mfi_ld_props {
1019         union mfi_ld_ref        ld;
1020         char                    name[16];
1021         uint8_t                 default_cache_policy;
1022         uint8_t                 access_policy;
1023         uint8_t                 disk_cache_policy;
1024         uint8_t                 current_cache_policy;
1025         uint8_t                 no_bgi;
1026         uint8_t                 reserved[7];
1027 } __packed;
1028
1029 struct mfi_ld_params {
1030         uint8_t                 primary_raid_level;
1031         uint8_t                 raid_level_qualifier;
1032         uint8_t                 secondary_raid_level;
1033         uint8_t                 stripe_size;
1034         uint8_t                 num_drives;
1035         uint8_t                 span_depth;
1036         uint8_t                 state;
1037         uint8_t                 init_state;
1038 #define MFI_LD_PARAMS_INIT_NO           0
1039 #define MFI_LD_PARAMS_INIT_QUICK        1
1040 #define MFI_LD_PARAMS_INIT_FULL         2
1041         uint8_t                 is_consistent;
1042         uint8_t                 reserved[23];
1043 } __packed;
1044
1045 struct mfi_ld_progress {
1046         uint32_t                active;
1047 #define MFI_LD_PROGRESS_CC      (1<<0)
1048 #define MFI_LD_PROGRESS_BGI     (1<<1)
1049 #define MFI_LD_PROGRESS_FGI     (1<<2)
1050 #define MFI_LD_PROGRESS_RECON   (1<<3)
1051         struct mfi_progress     cc;
1052         struct mfi_progress     bgi;
1053         struct mfi_progress     fgi;
1054         struct mfi_progress     recon;
1055         struct mfi_progress     reserved[4];
1056 } __packed;
1057
1058 struct mfi_span {
1059         uint64_t                start_block;
1060         uint64_t                num_blocks;
1061         uint16_t                array_ref;
1062         uint8_t                 reserved[6];
1063 } __packed;
1064
1065 #define MFI_MAX_SPAN_DEPTH      8
1066 struct mfi_ld_config {
1067         struct mfi_ld_props     properties;
1068         struct mfi_ld_params    params;
1069         struct mfi_span         span[MFI_MAX_SPAN_DEPTH];
1070 } __packed;
1071
1072 struct mfi_ld_info {
1073         struct mfi_ld_config    ld_config;
1074         uint64_t                size;
1075         struct mfi_ld_progress  progress;
1076         uint16_t                cluster_owner;
1077         uint8_t                 reconstruct_active;
1078         uint8_t                 reserved1[1];
1079         uint8_t                 vpd_page83[64];
1080         uint8_t                 reserved2[16];
1081 } __packed;
1082
1083 #define MAX_ARRAYS 16
1084 struct mfi_spare {
1085         union mfi_pd_ref        ref;
1086         uint8_t                 spare_type;
1087 #define MFI_SPARE_DEDICATED     (1 << 0)
1088 #define MFI_SPARE_REVERTIBLE    (1 << 1)
1089 #define MFI_SPARE_ENCL_AFFINITY (1 << 2)
1090         uint8_t                 reserved[2];
1091         uint8_t                 array_count;
1092         uint16_t                array_ref[MAX_ARRAYS];
1093 } __packed;
1094
1095 struct mfi_array {
1096         uint64_t                        size;
1097         uint8_t                         num_drives;
1098         uint8_t                         reserved;
1099         uint16_t                        array_ref;
1100         uint8_t                         pad[20];
1101         struct {
1102                 union mfi_pd_ref        ref;    /* 0xffff == missing drive */
1103                 uint16_t                fw_state;       /* MFI_PD_STATE_* */
1104                 struct {
1105                         uint8_t         pd;
1106                         uint8_t         slot;
1107                 } encl;
1108         } pd[0];
1109 } __packed;
1110
1111 struct mfi_config_data {
1112         uint32_t                size;
1113         uint16_t                array_count;
1114         uint16_t                array_size;
1115         uint16_t                log_drv_count;
1116         uint16_t                log_drv_size;
1117         uint16_t                spares_count;
1118         uint16_t                spares_size;
1119         uint8_t                 reserved[16];
1120         struct mfi_array        array[0];
1121         struct mfi_ld_config    ld[0];
1122         struct mfi_spare        spare[0];
1123 } __packed;
1124
1125 struct mfi_bbu_capacity_info {
1126         uint16_t                relative_charge;
1127         uint16_t                absolute_charge;
1128         uint16_t                remaining_capacity;
1129         uint16_t                full_charge_capacity;
1130         uint16_t                run_time_to_empty;
1131         uint16_t                average_time_to_empty;
1132         uint16_t                average_time_to_full;
1133         uint16_t                cycle_count;
1134         uint16_t                max_error;
1135         uint16_t                remaining_capacity_alarm;
1136         uint16_t                remaining_time_alarm;
1137         uint8_t                 reserved[26];
1138 } __packed;
1139
1140 struct mfi_bbu_design_info {
1141         uint32_t                mfg_date;
1142         uint16_t                design_capacity;
1143         uint16_t                design_voltage;
1144         uint16_t                spec_info;
1145         uint16_t                serial_number;
1146         uint16_t                pack_stat_config;
1147         uint8_t                 mfg_name[12];
1148         uint8_t                 device_name[8];
1149         uint8_t                 device_chemistry[8];
1150         uint8_t                 mfg_data[8];
1151         uint8_t                 reserved[17];
1152 } __packed;
1153
1154 struct mfi_ibbu_state {
1155         uint16_t                gas_guage_status;
1156         uint16_t                relative_charge;
1157         uint16_t                charger_system_state;
1158         uint16_t                charger_system_ctrl;
1159         uint16_t                charging_current;
1160         uint16_t                absolute_charge;
1161         uint16_t                max_error;
1162         uint8_t                 reserved[18];
1163 } __packed;
1164
1165 struct mfi_bbu_state {
1166         uint16_t                gas_guage_status;
1167         uint16_t                relative_charge;
1168         uint16_t                charger_status;
1169         uint16_t                remaining_capacity;
1170         uint16_t                full_charge_capacity;
1171         uint8_t                 is_SOH_good;
1172         uint8_t                 reserved[21];
1173 } __packed;
1174
1175 union mfi_bbu_status_detail {
1176         struct mfi_ibbu_state   ibbu;
1177         struct mfi_bbu_state    bbu;
1178 };
1179
1180 struct mfi_bbu_status {
1181         uint8_t                 battery_type;
1182 #define MFI_BBU_TYPE_NONE       0
1183 #define MFI_BBU_TYPE_IBBU       1
1184 #define MFI_BBU_TYPE_BBU        2
1185         uint8_t                 reserved;
1186         uint16_t                voltage;
1187         int16_t                 current;
1188         uint16_t                temperature;
1189         uint32_t                fw_status;
1190 #define MFI_BBU_STATE_PACK_MISSING      (1 << 0)
1191 #define MFI_BBU_STATE_VOLTAGE_LOW       (1 << 1)
1192 #define MFI_BBU_STATE_TEMPERATURE_HIGH  (1 << 2)
1193 #define MFI_BBU_STATE_CHARGE_ACTIVE     (1 << 0)
1194 #define MFI_BBU_STATE_DISCHARGE_ACTIVE  (1 << 0)
1195         uint8_t                 pad[20];
1196         union mfi_bbu_status_detail detail;
1197 } __packed;
1198
1199 enum mfi_pr_state {
1200         MFI_PR_STATE_STOPPED = 0,
1201         MFI_PR_STATE_READY = 1,
1202         MFI_PR_STATE_ACTIVE = 2,
1203         MFI_PR_STATE_ABORTED = 0xff
1204 };
1205
1206 struct mfi_pr_status {
1207         uint32_t                num_iteration;
1208         uint8_t                 state;
1209         uint8_t                 num_pd_done;
1210         uint8_t                 reserved[10];
1211 };
1212
1213 enum mfi_pr_opmode {
1214         MFI_PR_OPMODE_AUTO = 0,
1215         MFI_PR_OPMODE_MANUAL = 1,
1216         MFI_PR_OPMODE_DISABLED = 2
1217 };
1218
1219 struct mfi_pr_properties {
1220         uint8_t                 op_mode;
1221         uint8_t                 max_pd;
1222         uint8_t                 reserved;
1223         uint8_t                 exclude_ld_count;
1224         uint16_t                excluded_ld[MFI_MAX_LD];
1225         uint8_t                 cur_pd_map[MFI_MAX_PD / 8];
1226         uint8_t                 last_pd_map[MFI_MAX_PD / 8];
1227         uint32_t                next_exec;
1228         uint32_t                exec_freq;
1229         uint32_t                clear_freq;
1230 };
1231
1232 #define MFI_SCSI_MAX_TARGETS    128
1233 #define MFI_SCSI_MAX_LUNS       8
1234 #define MFI_SCSI_INITIATOR_ID   255
1235 #define MFI_SCSI_MAX_CMDS       8
1236 #define MFI_SCSI_MAX_CDB_LEN    16
1237
1238 #endif /* _MFIREG_H */