ec8326dd2bfb3a972529c7d7d0cfb33052d7d63e
[dragonfly.git] / sys / dev / raid / twa / tw_cl_share.h
1 /*
2  * Copyright (c) 2004-07 Applied Micro Circuits Corporation.
3  * Copyright (c) 2004-05 Vinod Kashyap
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/twa/tw_cl_share.h,v 1.7 2010/07/09 17:38:15 delphij Exp $
28  */
29
30 /*
31  * AMCC'S 3ware driver for 9000 series storage controllers.
32  *
33  * Author: Vinod Kashyap
34  * Modifications by: Adam Radford
35  * Modifications by: Manjunath Ranganathaiah
36  */
37
38
39
40 #ifndef TW_CL_SHARE_H
41
42 #define TW_CL_SHARE_H
43
44
45 /*
46  * Macros, structures and functions shared between OSL and CL,
47  * and defined by CL.
48  */
49
50 #define TW_CL_NULL                      ((TW_VOID *)0)
51 #define TW_CL_TRUE                      1
52 #define TW_CL_FALSE                     0
53
54 #define TW_CL_VENDOR_ID                 0x13C1  /* 3ware vendor id */
55 #define TW_CL_DEVICE_ID_9K              0x1002  /* 9000 PCI series device id */
56 #define TW_CL_DEVICE_ID_9K_X            0x1003  /* 9000 PCI-X series device id */
57 #define TW_CL_DEVICE_ID_9K_E            0x1004  /* 9000 PCIe series device id */
58 #define TW_CL_DEVICE_ID_9K_SA           0x1005  /* 9000 PCIe SAS series device id */
59
60 #define TW_CL_BAR_TYPE_IO               1       /* I/O base address */
61 #define TW_CL_BAR_TYPE_MEM              2       /* memory base address */
62 #define TW_CL_BAR_TYPE_SBUF             3       /* SBUF base address */
63
64 #ifdef TW_OSL_ENCLOSURE_SUPPORT
65 #define TW_CL_MAX_NUM_UNITS             65      /* max # of units we support
66                                                 -- enclosure target id is 64 */
67 #else /* TW_OSL_ENCLOSURE_SUPPORT */
68 #define TW_CL_MAX_NUM_UNITS             32      /* max # of units we support */
69 #endif /* TW_OSL_ENCLOSURE_SUPPORT */
70
71 #define TW_CL_MAX_NUM_LUNS              16      /* max # of LUN's we support */
72 #define TW_CL_MAX_IO_SIZE               0x20000 /* 128K */
73
74 /*
75  * Though we can support 256 simultaneous requests, we advertise as capable
76  * of supporting only 255, since we want to keep one CL internal request
77  * context packet always available for internal requests.
78  */
79 #define TW_CL_MAX_SIMULTANEOUS_REQUESTS 256     /* max simult reqs supported */
80
81 #define TW_CL_MAX_32BIT_SG_ELEMENTS     109     /* max 32-bit sg elements */
82 #define TW_CL_MAX_64BIT_SG_ELEMENTS     72      /* max 64-bit sg elements */
83
84
85 /* Possible values of ctlr->flags */
86 #define TW_CL_64BIT_ADDRESSES   (1<<0) /* 64 bit cmdpkt & SG addresses */
87 #define TW_CL_64BIT_SG_LENGTH   (1<<1) /* 64 bit SG length */
88 #define TW_CL_START_CTLR_ONLY   (1<<2) /* Start ctlr only */
89 #define TW_CL_STOP_CTLR_ONLY    (1<<3) /* Stop ctlr only */
90 #define TW_CL_DEFERRED_INTR_USED (1<<5) /* OS Layer uses deferred intr */
91
92 /* Possible error values from the Common Layer. */
93 #define TW_CL_ERR_REQ_SUCCESS                   0
94 #define TW_CL_ERR_REQ_GENERAL_FAILURE           (1<<0)
95 #define TW_CL_ERR_REQ_INVALID_TARGET            (1<<1)
96 #define TW_CL_ERR_REQ_INVALID_LUN               (1<<2)
97 #define TW_CL_ERR_REQ_SCSI_ERROR                (1<<3)
98 #define TW_CL_ERR_REQ_AUTO_SENSE_VALID          (1<<4)
99 #define TW_CL_ERR_REQ_BUS_RESET                 (1<<5)
100 #define TW_CL_ERR_REQ_UNABLE_TO_SUBMIT_COMMAND  (1<<6)
101
102
103 /* Possible values of req_pkt->flags */
104 #define TW_CL_REQ_RETRY_ON_BUSY         (1<<0)
105 #define TW_CL_REQ_CALLBACK_FOR_SGLIST   (1<<1)
106
107
108 #define TW_CL_MESSAGE_SOURCE_CONTROLLER_ERROR   3
109 #define TW_CL_MESSAGE_SOURCE_CONTROLLER_EVENT   4
110 #define TW_CL_MESSAGE_SOURCE_COMMON_LAYER_ERROR 21
111 #define TW_CL_MESSAGE_SOURCE_COMMON_LAYER_EVENT 22
112 #define TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER     5
113 #define TW_CL_MESSAGE_SOURCE_FREEBSD_OS         8
114 #define TW_CL_MESSAGE_SOURCE_WINDOWS_DRIVER     7
115 #define TW_CL_MESSAGE_SOURCE_WINDOWS_OS         10
116
117 #define TW_CL_SEVERITY_ERROR            0x1
118 #define TW_CL_SEVERITY_WARNING          0x2
119 #define TW_CL_SEVERITY_INFO             0x3
120 #define TW_CL_SEVERITY_DEBUG            0x4
121
122 #define TW_CL_SEVERITY_ERROR_STRING     "ERROR"
123 #define TW_CL_SEVERITY_WARNING_STRING   "WARNING"
124 #define TW_CL_SEVERITY_INFO_STRING      "INFO"
125 #define TW_CL_SEVERITY_DEBUG_STRING     "DEBUG"
126
127
128
129 /*
130  * Structure, a pointer to which is used as the controller handle in
131  * communications between the OS Layer and the Common Layer.
132  */
133 struct tw_cl_ctlr_handle {
134         TW_VOID *osl_ctlr_ctxt; /* OSL's ctlr context */
135         TW_VOID *cl_ctlr_ctxt;  /* CL's ctlr context */
136 };
137
138
139 /*
140  * Structure, a pointer to which is used as the request handle in
141  * communications between the OS Layer and the Common Layer.
142  */
143 struct tw_cl_req_handle {
144         TW_VOID *osl_req_ctxt;  /* OSL's request context */
145         TW_VOID *cl_req_ctxt;   /* CL's request context */
146         TW_UINT8 is_io;         /* Only freeze/release simq for IOs */
147 };
148
149
150 /* Structure used to describe SCSI requests to CL. */
151 struct tw_cl_scsi_req_packet {
152         TW_UINT32       unit;           /* unit # to send cmd to */
153         TW_UINT32       lun;            /* LUN to send cmd to */
154         TW_UINT8        *cdb;           /* ptr to SCSI cdb */
155         TW_UINT32       cdb_len;        /* # of valid cdb bytes */
156         TW_UINT32       sense_len;      /* # of bytes of valid sense info */
157         TW_UINT8        *sense_data;    /* ptr to sense data, if any */
158         TW_UINT32       scsi_status;    /* SCSI status returned by fw */
159         TW_UINT32       sgl_entries;    /* # of SG descriptors */
160         TW_UINT8        *sg_list;       /* ptr to SG list */
161 };
162
163
164 /* Structure used to describe pass through command packets to CL. */
165 struct tw_cl_passthru_req_packet {
166         TW_UINT8        *cmd_pkt;       /* ptr to passthru cmd pkt */
167         TW_UINT32       cmd_pkt_length; /* size of cmd pkt */
168         TW_UINT32       sgl_entries;    /* # of SG descriptors */
169         TW_UINT8        *sg_list;       /* ptr to SG list */
170 };
171
172
173 /* Request packet submitted to the Common Layer, by the OS Layer. */
174 struct tw_cl_req_packet {
175         TW_UINT32       cmd;            /* Common Layer cmd */
176         TW_UINT32       flags;          /* flags describing request */
177         TW_UINT32       status;         /* Common Layer returned status */
178         TW_VOID         (*tw_osl_callback)(struct tw_cl_req_handle *req_handle);
179                         /* OSL routine to be called by CL on req completion */
180         TW_VOID         (*tw_osl_sgl_callback)(
181                         struct tw_cl_req_handle *req_handle, TW_VOID *sg_list,
182                         TW_UINT32 *num_sgl_entries);
183                         /* OSL callback to get SG list. */
184
185         union {
186                 struct tw_cl_scsi_req_packet            scsi_req; /* SCSI req */
187                 struct tw_cl_passthru_req_packet        pt_req;/*Passthru req*/
188         } gen_req_pkt;
189 };
190
191
192 #pragma pack(1)
193 /*
194  * Packet that describes an AEN/error generated by the controller,
195  * Common Layer, or even the OS Layer.
196  */
197 struct tw_cl_event_packet {
198         TW_UINT32       sequence_id;
199         TW_UINT32       time_stamp_sec;
200         TW_UINT16       aen_code;
201         TW_UINT8        severity;
202         TW_UINT8        retrieved;
203         TW_UINT8        repeat_count;
204         TW_UINT8        parameter_len;
205         TW_UINT8        parameter_data[98];
206         TW_UINT32       event_src;
207         TW_UINT8        severity_str[20];
208 };
209 #pragma pack()
210
211
212 /* Structure to link 2 adjacent elements in a list. */
213 struct tw_cl_link {
214         struct tw_cl_link       *next;
215         struct tw_cl_link       *prev;
216 };
217
218
219 #pragma pack(1)
220 /* Scatter/Gather list entry with 32 bit addresses. */
221 struct tw_cl_sg_desc32 {
222         TW_UINT32       address;
223         TW_UINT32       length;
224 };
225
226
227 /* Scatter/Gather list entry with 64 bit addresses. */
228 struct tw_cl_sg_desc64 {
229         TW_UINT64       address;
230         TW_UINT32       length;
231 };
232
233 #pragma pack()
234
235
236 /* Byte swap functions.  Valid only if running on big endian platforms. */
237 #ifdef TW_OSL_BIG_ENDIAN
238
239 #define TW_CL_SWAP16_WITH_CAST(x)                                       \
240         ((x << 8) | (x >> 8))
241
242
243 #define TW_CL_SWAP32_WITH_CAST(x)                                       \
244         ((x << 24) | ((x << 8) & (0xFF0000)) |                          \
245         ((x >> 8) & (0xFF00)) | (x >> 24))
246
247
248 #define TW_CL_SWAP64_WITH_CAST(x)                                       \
249         ((((TW_UINT64)(TW_CL_SWAP32(((TW_UINT32 *)(&(x)))[1]))) << 32) |\
250         ((TW_UINT32)(TW_CL_SWAP32(((TW_UINT32 *)(&(x)))[0]))))
251
252
253 #else /* TW_OSL_BIG_ENDIAN */
254
255 #define TW_CL_SWAP16_WITH_CAST(x)       x
256 #define TW_CL_SWAP32_WITH_CAST(x)       x
257 #define TW_CL_SWAP64_WITH_CAST(x)       x
258
259 #endif /* TW_OSL_BIG_ENDIAN */
260
261 #define TW_CL_SWAP16(x)         TW_CL_SWAP16_WITH_CAST((TW_UINT16)(x))
262 #define TW_CL_SWAP32(x)         TW_CL_SWAP32_WITH_CAST((TW_UINT32)(x))
263 #define TW_CL_SWAP64(x)         TW_CL_SWAP64_WITH_CAST((TW_UINT64)(x))
264
265
266 /* Queue manipulation functions. */
267
268 /* Initialize a queue. */
269 #define TW_CL_Q_INIT(head)      do {            \
270         (head)->prev = (head)->next = head;     \
271 } while (0)
272
273
274 /* Insert an item at the head of the queue. */
275 #define TW_CL_Q_INSERT_HEAD(head, item) do {    \
276         (item)->next = (head)->next;            \
277         (item)->prev = head;                    \
278         (head)->next->prev = item;              \
279         (head)->next = item;                    \
280 } while (0)
281
282
283 /* Insert an item at the tail of the queue. */
284 #define TW_CL_Q_INSERT_TAIL(head, item) do {    \
285         (item)->next = head;                    \
286         (item)->prev = (head)->prev;            \
287         (head)->prev->next = item;              \
288         (head)->prev = item;                    \
289 } while (0)
290
291
292 /* Remove an item from the head of the queue. */
293 #define TW_CL_Q_REMOVE_ITEM(head, item) do {    \
294         (item)->prev->next = (item)->next;      \
295         (item)->next->prev = (item)->prev;      \
296 } while (0)
297
298
299 /* Retrieve the item at the head of the queue. */
300 #define TW_CL_Q_FIRST_ITEM(head)                \
301         (((head)->next != head) ? ((head)->next) : TW_CL_NULL)
302
303
304 /* Retrieve the item at the tail of the queue. */
305 #define TW_CL_Q_LAST_ITEM(head)                 \
306         (((head)->prev != head) ? ((head)->prev) : TW_CL_NULL)
307
308
309 /* Retrieve the item next to a given item in the queue. */
310 #define TW_CL_Q_NEXT_ITEM(head, item)           \
311         (((item)->next != head) ? ((item)->next) : TW_CL_NULL)
312
313
314 /* Retrieve the item previous to a given item in the queue. */
315 #define TW_CL_Q_PREV_ITEM(head, item)           \
316         (((item)->prev != head) ? ((item)->prev) : TW_CL_NULL)
317
318
319 /* Determine the offset of a field from the head of the structure it is in. */
320 #define TW_CL_STRUCT_OFFSET(struct_type, field) \
321         (TW_INT8 *)(&((struct_type *)0)->field)
322
323
324 /*
325  * Determine the address of the head of a structure, given the address of a
326  * field within it.
327  */
328 #define TW_CL_STRUCT_HEAD(addr, struct_type, field)     \
329         (struct_type *)((TW_INT8 *)addr -               \
330         TW_CL_STRUCT_OFFSET(struct_type, field))
331
332
333
334 #ifndef TW_BUILDING_API
335
336 #include "tw_osl_inline.h"
337
338
339
340 /*
341  * The following are extern declarations of OS Layer defined functions called
342  * by the Common Layer.  If any function has been defined as a macro in
343  * tw_osl_share.h, we will not make the extern declaration here.
344  */
345
346 #ifndef tw_osl_breakpoint
347 /* Allows setting breakpoints in the CL code for debugging purposes. */
348 extern TW_VOID  tw_osl_breakpoint(TW_VOID);
349 #endif
350
351
352 #ifndef tw_osl_ctlr_busy
353 /* Called when CL is too busy to accept new requests. */
354 extern TW_VOID  tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
355         struct tw_cl_req_handle *req_handle);
356 #endif
357
358
359 #ifndef tw_osl_cur_func
360 /* Text name of current function. */
361 extern TW_INT8  *tw_osl_cur_func(TW_VOID);
362 #endif
363
364
365 #ifdef TW_OSL_DEBUG
366 #ifndef tw_osl_dbg_printf
367 /* Print to syslog/event log/debug console, as applicable. */
368 extern TW_INT32 tw_osl_dbg_printf(struct tw_cl_ctlr_handle *ctlr_handle,
369         const TW_INT8 *fmt, ...);
370 #endif
371 #endif /* TW_OSL_DEBUG */
372
373
374 #ifndef tw_osl_delay
375 /* Cause a delay of usecs micro-seconds. */
376 extern TW_VOID  tw_osl_delay(TW_INT32 usecs);
377 #endif
378
379
380 #ifndef tw_osl_destroy_lock
381 /* Create/initialize a lock for CL's use. */
382 extern TW_VOID  tw_osl_destroy_lock(struct tw_cl_ctlr_handle *ctlr_handle,
383         TW_LOCK_HANDLE *lock);
384 #endif
385
386
387 #ifndef tw_osl_free_lock
388 /* Free a previously held lock. */
389 extern TW_VOID  tw_osl_free_lock(struct tw_cl_ctlr_handle *ctlr_handle,
390         TW_LOCK_HANDLE *lock);
391 #endif
392
393
394 #ifndef tw_osl_get_local_time
395 /* Get local time. */
396 extern TW_TIME  tw_osl_get_local_time(TW_VOID);
397 #endif
398
399
400 #ifndef tw_osl_get_lock
401 /* Acquire a lock. */
402 extern TW_VOID  tw_osl_get_lock(struct tw_cl_ctlr_handle *ctlr_handle,
403         TW_LOCK_HANDLE *lock);
404 #endif
405
406
407 #ifndef tw_osl_init_lock
408 /* Create/initialize a lock for CL's use. */
409 extern TW_VOID  tw_osl_init_lock(struct tw_cl_ctlr_handle *ctlr_handle,
410         TW_INT8 *lock_name, TW_LOCK_HANDLE *lock);
411 #endif
412
413
414 #ifndef tw_osl_memcpy
415 /* Copy 'size' bytes from 'src' to 'dest'. */
416 extern TW_VOID  tw_osl_memcpy(TW_VOID *src, TW_VOID *dest, TW_INT32 size);
417 #endif
418
419
420 #ifndef tw_osl_memzero
421 /* Zero 'size' bytes starting at 'addr'. */
422 extern TW_VOID  tw_osl_memzero(TW_VOID *addr, TW_INT32 size);
423 #endif
424
425
426 #ifndef tw_osl_notify_event
427 /* Notify OSL of a controller/CL (or even OSL) event. */
428 extern TW_VOID  tw_osl_notify_event(struct tw_cl_ctlr_handle *ctlr_handle,
429         struct tw_cl_event_packet *event);
430 #endif
431
432
433 #ifdef TW_OSL_PCI_CONFIG_ACCESSIBLE
434 #ifndef tw_osl_read_pci_config
435 /* Read 'size' bytes from 'offset' in the PCI config space. */
436 extern TW_UINT32 tw_osl_read_pci_config(
437         struct tw_cl_ctlr_handle *ctlr_handle, TW_INT32 offset, TW_INT32 size);
438 #endif
439 #endif /* TW_OSL_PCI_CONFIG_ACCESSIBLE */
440
441
442 #ifndef tw_osl_read_reg
443 /* Read 'size' bytes at 'offset' from base address of this controller. */
444 extern TW_UINT32 tw_osl_read_reg(struct tw_cl_ctlr_handle *ctlr_handle,
445         TW_INT32 offset, TW_INT32 size);
446 #endif
447
448
449 #ifndef tw_osl_scan_bus
450 /* Request OSL for a bus scan. */
451 extern TW_VOID  tw_osl_scan_bus(struct tw_cl_ctlr_handle *ctlr_handle);
452 #endif
453
454
455 #ifdef TW_OSL_CAN_SLEEP
456 #ifndef tw_osl_sleep
457 /* Sleep for 'timeout' ms or until woken up (by tw_osl_wakeup). */
458 extern TW_INT32 tw_osl_sleep(struct tw_cl_ctlr_handle *ctlr_handle,
459         TW_SLEEP_HANDLE *sleep_handle, TW_INT32 timeout);
460 #endif
461 #endif /* TW_OSL_CAN_SLEEP */
462
463
464 #ifndef tw_osl_sprintf
465 /* Standard sprintf. */
466 extern TW_INT32 tw_osl_sprintf(TW_INT8 *dest, const TW_INT8 *fmt, ...);
467 #endif
468
469
470 #ifndef tw_osl_strcpy
471 /* Copy string 'src' to 'dest'. */
472 extern TW_INT8  *tw_osl_strcpy(TW_INT8 *dest, TW_INT8 *src);
473 #endif
474
475
476 #ifndef tw_osl_strlen
477 /* Return length of string pointed at by 'str'. */
478 extern TW_INT32 tw_osl_strlen(TW_VOID *str);
479 #endif
480
481 #ifndef tw_osl_vsprintf
482 /* Standard vsprintf. */
483 extern TW_INT32 tw_osl_vsprintf(TW_INT8 *dest, const TW_INT8 *fmt, va_list ap);
484 #endif
485
486
487 #ifdef TW_OSL_CAN_SLEEP
488 #ifndef tw_osl_wakeup
489 /* Wake up a thread sleeping by a call to tw_osl_sleep. */
490 extern TW_VOID  tw_osl_wakeup(struct tw_cl_ctlr_handle *ctlr_handle,
491         TW_SLEEP_HANDLE *sleep_handle);
492 #endif
493 #endif /* TW_OSL_CAN_SLEEP */
494
495
496 #ifdef TW_OSL_PCI_CONFIG_ACCESSIBLE
497 #ifndef tw_osl_write_pci_config
498 /* Write 'value' of 'size' bytes at 'offset' in the PCI config space. */
499 extern TW_VOID  tw_osl_write_pci_config(struct tw_cl_ctlr_handle *ctlr_handle,
500         TW_INT32 offset, TW_INT32 value, TW_INT32 size);
501 #endif
502 #endif /* TW_OSL_PCI_CONFIG_ACCESSIBLE */
503
504
505 #ifndef tw_osl_write_reg
506 /*
507  * Write 'value' of 'size' (max 4) bytes at 'offset' from base address of
508  * this controller.
509  */
510 extern TW_VOID  tw_osl_write_reg(struct tw_cl_ctlr_handle *ctlr_handle,
511         TW_INT32 offset, TW_INT32 value, TW_INT32 size);
512 #endif
513
514
515
516 /* Functions in the Common Layer */
517
518 /* Creates and queues AEN's.  Also notifies OS Layer. */
519 extern TW_VOID tw_cl_create_event(struct tw_cl_ctlr_handle *ctlr_handle,
520         TW_UINT8 queue_event, TW_UINT8 event_src, TW_UINT16 event_code,
521         TW_UINT8 severity, TW_UINT8 *severity_str, TW_UINT8 *event_desc,
522         TW_UINT8 *event_specific_desc, ...);
523
524 /* Indicates whether a ctlr is supported by CL. */
525 extern TW_INT32 tw_cl_ctlr_supported(TW_INT32 vendor_id, TW_INT32 device_id);
526
527
528 /* Submit a firmware cmd packet. */
529 extern TW_INT32 tw_cl_fw_passthru(struct tw_cl_ctlr_handle *ctlr_handle,
530         struct tw_cl_req_packet *req_pkt, struct tw_cl_req_handle *req_handle);
531
532
533 /* Find out how much memory CL needs. */
534 extern TW_INT32 tw_cl_get_mem_requirements(
535         struct tw_cl_ctlr_handle *ctlr_handle, TW_UINT32 flags,
536         TW_INT32 device_id, TW_INT32 max_simult_reqs, TW_INT32 max_aens,
537         TW_UINT32 *alignment, TW_UINT32 *sg_size_factor,
538         TW_UINT32 *non_dma_mem_size, TW_UINT32 *dma_mem_size
539         );
540
541
542 /* Return PCI BAR info. */
543 extern TW_INT32 tw_cl_get_pci_bar_info(TW_INT32 device_id, TW_INT32 bar_type,
544         TW_INT32 *bar_num, TW_INT32 *bar0_offset, TW_INT32 *bar_size);
545
546
547 /* Initialize Common Layer for a given controller. */
548 extern TW_INT32 tw_cl_init_ctlr(struct tw_cl_ctlr_handle *ctlr_handle,
549         TW_UINT32 flags, TW_INT32 device_id, TW_INT32 max_simult_reqs,
550         TW_INT32 max_aens, TW_VOID *non_dma_mem, TW_VOID *dma_mem,
551         TW_UINT64 dma_mem_phys
552         );
553
554
555 /* CL's interrupt handler. */
556 extern TW_INT32 tw_cl_interrupt(struct tw_cl_ctlr_handle *ctlr_handle);
557
558
559 /* CL's ioctl handler. */
560 extern TW_INT32 tw_cl_ioctl(struct tw_cl_ctlr_handle *ctlr_handle,
561         u_long cmd, TW_VOID *buf);
562
563
564 #ifdef TW_OSL_DEBUG
565 /* Print CL's state/statistics for a controller. */
566 extern TW_VOID  tw_cl_print_ctlr_stats(struct tw_cl_ctlr_handle *ctlr_handle);
567
568 /* Prints CL internal details of a given request. */
569 extern TW_VOID  tw_cl_print_req_info(struct tw_cl_req_handle *req_handle);
570 #endif /* TW_OSL_DEBUG */
571
572
573 /* Soft reset controller. */
574 extern TW_INT32 tw_cl_reset_ctlr(struct tw_cl_ctlr_handle *ctlr_handle);
575
576
577 #ifdef TW_OSL_DEBUG
578 /* Reset CL's statistics for a controller. */
579 extern TW_VOID  tw_cl_reset_stats(struct tw_cl_ctlr_handle *ctlr_handle);
580 #endif /* TW_OSL_DEBUG */
581
582
583 /* Stop a controller. */
584 extern TW_INT32 tw_cl_shutdown_ctlr(struct tw_cl_ctlr_handle *ctlr_handle,
585         TW_UINT32 flags);
586
587
588 /* Submit a SCSI I/O request. */
589 extern TW_INT32 tw_cl_start_io(struct tw_cl_ctlr_handle *ctlr_handle,
590         struct tw_cl_req_packet *req_pkt, struct tw_cl_req_handle *req_handle);
591
592
593 #endif /* TW_BUILDING_API */
594
595 #endif /* TW_CL_SHARE_H */