?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
driver core: remove KOBJ_NAME_LEN define
[linux-2.6/mini2440.git] / drivers / message / fusion / mptbase.c
blob34402c47027e3951ac1d7de9387ec81a61227a2d
1 /*
2 * linux/drivers/message/fusion/mptbase.c
3 * This is the Fusion MPT base driver which supports multiple
4 * (SCSI + LAN) specialized protocol drivers.
5 * For use with LSI PCI chip/adapter(s)
6 * running LSI Fusion MPT (Message Passing Technology) firmware.
7 *
8 * Copyright (c) 1999-2008 LSI Corporation
9 * (mailto:DL-MPTFusionLinux@lsi.com)
10 *
11 */
12 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
13 /*
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; version 2 of the License.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 NO WARRANTY
24 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
25 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
26 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
27 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
28 solely responsible for determining the appropriateness of using and
29 distributing the Program and assumes all risks associated with its
30 exercise of rights under this Agreement, including but not limited to
31 the risks and costs of program errors, damage to or loss of data,
32 programs or equipment, and unavailability or interruption of operations.
33
34 DISCLAIMER OF LIABILITY
35 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
36 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
38 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
39 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
40 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
41 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
42
43 You should have received a copy of the GNU General Public License
44 along with this program; if not, write to the Free Software
45 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
46 */
47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
48
49 #include <linux/kernel.h>
50 #include <linux/module.h>
51 #include <linux/errno.h>
52 #include <linux/init.h>
53 #include <linux/slab.h>
54 #include <linux/types.h>
55 #include <linux/pci.h>
56 #include <linux/kdev_t.h>
57 #include <linux/blkdev.h>
58 #include <linux/delay.h>
59 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
60 #include <linux/dma-mapping.h>
61 #include <asm/io.h>
62 #ifdef CONFIG_MTRR
63 #include <asm/mtrr.h>
64 #endif
65
66 #include "mptbase.h"
67 #include "lsi/mpi_log_fc.h"
68
69 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
70 #define my_NAME "Fusion MPT base driver"
71 #define my_VERSION MPT_LINUX_VERSION_COMMON
72 #define MYNAM "mptbase"
73
74 MODULE_AUTHOR(MODULEAUTHOR);
75 MODULE_DESCRIPTION(my_NAME);
76 MODULE_LICENSE("GPL");
77 MODULE_VERSION(my_VERSION);
78
79 /*
80 * cmd line parameters
81 */
82 static int mpt_msi_enable = -1;
83 module_param(mpt_msi_enable, int, 0);
84 MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
85
86 static int mpt_channel_mapping;
87 module_param(mpt_channel_mapping, int, 0);
88 MODULE_PARM_DESC(mpt_channel_mapping, " Mapping id's to channels (default=0)");
89
90 static int mpt_debug_level;
91 static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
92 module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
93 &mpt_debug_level, 0600);
94 MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h - (default=0)");
95
96 #ifdef MFCNT
97 static int mfcounter = 0;
98 #define PRINT_MF_COUNT 20000
99 #endif
100
101 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
102 /*
103 * Public data...
104 */
105
106 static struct proc_dir_entry *mpt_proc_root_dir;
107
108 #define WHOINIT_UNKNOWN 0xAA
109
110 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
111 /*
112 * Private data...
113 */
114 /* Adapter link list */
115 LIST_HEAD(ioc_list);
116 /* Callback lookup table */
117 static MPT_CALLBACK MptCallbacks[MPT_MAX_PROTOCOL_DRIVERS];
118 /* Protocol driver class lookup table */
119 static int MptDriverClass[MPT_MAX_PROTOCOL_DRIVERS];
120 /* Event handler lookup table */
121 static MPT_EVHANDLER MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
122 /* Reset handler lookup table */
123 static MPT_RESETHANDLER MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
124 static struct mpt_pci_driver *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
125
126 static DECLARE_WAIT_QUEUE_HEAD(mpt_waitq);
127
128 /*
129 * Driver Callback Index's
130 */
131 static u8 mpt_base_index = MPT_MAX_PROTOCOL_DRIVERS;
132 static u8 last_drv_idx;
133
134 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
135 /*
136 * Forward protos...
137 */
138 static irqreturn_t mpt_interrupt(int irq, void *bus_id);
139 static int mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply);
140 static int mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes,
141 u32 *req, int replyBytes, u16 *u16reply, int maxwait,
142 int sleepFlag);
143 static int mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag);
144 static void mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev);
145 static void mpt_adapter_disable(MPT_ADAPTER *ioc);
146 static void mpt_adapter_dispose(MPT_ADAPTER *ioc);
147
148 static void MptDisplayIocCapabilities(MPT_ADAPTER *ioc);
149 static int MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag);
150 static int GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason);
151 static int GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
152 static int SendIocInit(MPT_ADAPTER *ioc, int sleepFlag);
153 static int SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag);
154 static int mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag);
155 static int mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag);
156 static int mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
157 static int KickStart(MPT_ADAPTER *ioc, int ignore, int sleepFlag);
158 static int SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag);
159 static int PrimeIocFifos(MPT_ADAPTER *ioc);
160 static int WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
161 static int WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
162 static int WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag);
163 static int GetLanConfigPages(MPT_ADAPTER *ioc);
164 static int GetIoUnitPage2(MPT_ADAPTER *ioc);
165 int mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
166 static int mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum);
167 static int mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum);
168 static void mpt_read_ioc_pg_1(MPT_ADAPTER *ioc);
169 static void mpt_read_ioc_pg_4(MPT_ADAPTER *ioc);
170 static void mpt_timer_expired(unsigned long data);
171 static void mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc);
172 static int SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch);
173 static int SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp);
174 static int mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag);
175 static int mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init);
176
177 #ifdef CONFIG_PROC_FS
178 static int procmpt_summary_read(char *buf, char **start, off_t offset,
179 int request, int *eof, void *data);
180 static int procmpt_version_read(char *buf, char **start, off_t offset,
181 int request, int *eof, void *data);
182 static int procmpt_iocinfo_read(char *buf, char **start, off_t offset,
183 int request, int *eof, void *data);
184 #endif
185 static void mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc);
186
187 //int mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag);
188 static int ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *evReply, int *evHandlers);
189 static void mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf);
190 static void mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info);
191 static void mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info);
192 static void mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info);
193 static int mpt_read_ioc_pg_3(MPT_ADAPTER *ioc);
194 static void mpt_inactive_raid_list_free(MPT_ADAPTER *ioc);
195
196 /* module entry point */
197 static int __init fusion_init (void);
198 static void __exit fusion_exit (void);
199
200 #define CHIPREG_READ32(addr) readl_relaxed(addr)
201 #define CHIPREG_READ32_dmasync(addr) readl(addr)
202 #define CHIPREG_WRITE32(addr,val) writel(val, addr)
203 #define CHIPREG_PIO_WRITE32(addr,val) outl(val, (unsigned long)addr)
204 #define CHIPREG_PIO_READ32(addr) inl((unsigned long)addr)
205
206 static void
207 pci_disable_io_access(struct pci_dev *pdev)
208 {
209 u16 command_reg;
210
211 pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
212 command_reg &= ~1;
213 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
214 }
215
216 static void
217 pci_enable_io_access(struct pci_dev *pdev)
218 {
219 u16 command_reg;
220
221 pci_read_config_word(pdev, PCI_COMMAND, &command_reg);
222 command_reg |= 1;
223 pci_write_config_word(pdev, PCI_COMMAND, command_reg);
224 }
225
226 static int mpt_set_debug_level(const char *val, struct kernel_param *kp)
227 {
228 int ret = param_set_int(val, kp);
229 MPT_ADAPTER *ioc;
230
231 if (ret)
232 return ret;
233
234 list_for_each_entry(ioc, &ioc_list, list)
235 ioc->debug_level = mpt_debug_level;
236 return 0;
237 }
238
239 /**
240 * mpt_get_cb_idx - obtain cb_idx for registered driver
241 * @dclass: class driver enum
242 *
243 * Returns cb_idx, or zero means it wasn't found
244 **/
245 static u8
246 mpt_get_cb_idx(MPT_DRIVER_CLASS dclass)
247 {
248 u8 cb_idx;
249
250 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--)
251 if (MptDriverClass[cb_idx] == dclass)
252 return cb_idx;
253 return 0;
254 }
255
256 /**
257 * mpt_fault_reset_work - work performed on workq after ioc fault
258 * @work: input argument, used to derive ioc
259 *
260 **/
261 static void
262 mpt_fault_reset_work(struct work_struct *work)
263 {
264 MPT_ADAPTER *ioc =
265 container_of(work, MPT_ADAPTER, fault_reset_work.work);
266 u32 ioc_raw_state;
267 int rc;
268 unsigned long flags;
269
270 if (ioc->diagPending || !ioc->active)
271 goto out;
272
273 ioc_raw_state = mpt_GetIocState(ioc, 0);
274 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
275 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state (%04xh)!!!\n",
276 ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
277 printk(MYIOC_s_WARN_FMT "Issuing HardReset from %s!!\n",
278 ioc->name, __FUNCTION__);
279 rc = mpt_HardResetHandler(ioc, CAN_SLEEP);
280 printk(MYIOC_s_WARN_FMT "%s: HardReset: %s\n", ioc->name,
281 __FUNCTION__, (rc == 0) ? "success" : "failed");
282 ioc_raw_state = mpt_GetIocState(ioc, 0);
283 if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT)
284 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state after "
285 "reset (%04xh)\n", ioc->name, ioc_raw_state &
286 MPI_DOORBELL_DATA_MASK);
287 }
288
289 out:
290 /*
291 * Take turns polling alternate controller
292 */
293 if (ioc->alt_ioc)
294 ioc = ioc->alt_ioc;
295
296 /* rearm the timer */
297 spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
298 if (ioc->reset_work_q)
299 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
300 msecs_to_jiffies(MPT_POLLING_INTERVAL));
301 spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
302 }
303
304
305 /*
306 * Process turbo (context) reply...
307 */
308 static void
309 mpt_turbo_reply(MPT_ADAPTER *ioc, u32 pa)
310 {
311 MPT_FRAME_HDR *mf = NULL;
312 MPT_FRAME_HDR *mr = NULL;
313 u16 req_idx = 0;
314 u8 cb_idx;
315
316 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got TURBO reply req_idx=%08x\n",
317 ioc->name, pa));
318
319 switch (pa >> MPI_CONTEXT_REPLY_TYPE_SHIFT) {
320 case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
321 req_idx = pa & 0x0000FFFF;
322 cb_idx = (pa & 0x00FF0000) >> 16;
323 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
324 break;
325 case MPI_CONTEXT_REPLY_TYPE_LAN:
326 cb_idx = mpt_get_cb_idx(MPTLAN_DRIVER);
327 /*
328 * Blind set of mf to NULL here was fatal
329 * after lan_reply says "freeme"
330 * Fix sort of combined with an optimization here;
331 * added explicit check for case where lan_reply
332 * was just returning 1 and doing nothing else.
333 * For this case skip the callback, but set up
334 * proper mf value first here:-)
335 */
336 if ((pa & 0x58000000) == 0x58000000) {
337 req_idx = pa & 0x0000FFFF;
338 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
339 mpt_free_msg_frame(ioc, mf);
340 mb();
341 return;
342 break;
343 }
344 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
345 break;
346 case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
347 cb_idx = mpt_get_cb_idx(MPTSTM_DRIVER);
348 mr = (MPT_FRAME_HDR *) CAST_U32_TO_PTR(pa);
349 break;
350 default:
351 cb_idx = 0;
352 BUG();
353 }
354
355 /* Check for (valid) IO callback! */
356 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
357 MptCallbacks[cb_idx] == NULL) {
358 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
359 __FUNCTION__, ioc->name, cb_idx);
360 goto out;
361 }
362
363 if (MptCallbacks[cb_idx](ioc, mf, mr))
364 mpt_free_msg_frame(ioc, mf);
365 out:
366 mb();
367 }
368
369 static void
370 mpt_reply(MPT_ADAPTER *ioc, u32 pa)
371 {
372 MPT_FRAME_HDR *mf;
373 MPT_FRAME_HDR *mr;
374 u16 req_idx;
375 u8 cb_idx;
376 int freeme;
377
378 u32 reply_dma_low;
379 u16 ioc_stat;
380
381 /* non-TURBO reply! Hmmm, something may be up...
382 * Newest turbo reply mechanism; get address
383 * via left shift 1 (get rid of MPI_ADDRESS_REPLY_A_BIT)!
384 */
385
386 /* Map DMA address of reply header to cpu address.
387 * pa is 32 bits - but the dma address may be 32 or 64 bits
388 * get offset based only only the low addresses
389 */
390
391 reply_dma_low = (pa <<= 1);
392 mr = (MPT_FRAME_HDR *)((u8 *)ioc->reply_frames +
393 (reply_dma_low - ioc->reply_frames_low_dma));
394
395 req_idx = le16_to_cpu(mr->u.frame.hwhdr.msgctxu.fld.req_idx);
396 cb_idx = mr->u.frame.hwhdr.msgctxu.fld.cb_idx;
397 mf = MPT_INDEX_2_MFPTR(ioc, req_idx);
398
399 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got non-TURBO reply=%p req_idx=%x cb_idx=%x Function=%x\n",
400 ioc->name, mr, req_idx, cb_idx, mr->u.hdr.Function));
401 DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mr);
402
403 /* Check/log IOC log info
404 */
405 ioc_stat = le16_to_cpu(mr->u.reply.IOCStatus);
406 if (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) {
407 u32 log_info = le32_to_cpu(mr->u.reply.IOCLogInfo);
408 if (ioc->bus_type == FC)
409 mpt_fc_log_info(ioc, log_info);
410 else if (ioc->bus_type == SPI)
411 mpt_spi_log_info(ioc, log_info);
412 else if (ioc->bus_type == SAS)
413 mpt_sas_log_info(ioc, log_info);
414 }
415
416 if (ioc_stat & MPI_IOCSTATUS_MASK)
417 mpt_iocstatus_info(ioc, (u32)ioc_stat, mf);
418
419 /* Check for (valid) IO callback! */
420 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS ||
421 MptCallbacks[cb_idx] == NULL) {
422 printk(MYIOC_s_WARN_FMT "%s: Invalid cb_idx (%d)!\n",
423 __FUNCTION__, ioc->name, cb_idx);
424 freeme = 0;
425 goto out;
426 }
427
428 freeme = MptCallbacks[cb_idx](ioc, mf, mr);
429
430 out:
431 /* Flush (non-TURBO) reply with a WRITE! */
432 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, pa);
433
434 if (freeme)
435 mpt_free_msg_frame(ioc, mf);
436 mb();
437 }
438
439 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
440 /**
441 * mpt_interrupt - MPT adapter (IOC) specific interrupt handler.
442 * @irq: irq number (not used)
443 * @bus_id: bus identifier cookie == pointer to MPT_ADAPTER structure
444 *
445 * This routine is registered via the request_irq() kernel API call,
446 * and handles all interrupts generated from a specific MPT adapter
447 * (also referred to as a IO Controller or IOC).
448 * This routine must clear the interrupt from the adapter and does
449 * so by reading the reply FIFO. Multiple replies may be processed
450 * per single call to this routine.
451 *
452 * This routine handles register-level access of the adapter but
453 * dispatches (calls) a protocol-specific callback routine to handle
454 * the protocol-specific details of the MPT request completion.
455 */
456 static irqreturn_t
457 mpt_interrupt(int irq, void *bus_id)
458 {
459 MPT_ADAPTER *ioc = bus_id;
460 u32 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
461
462 if (pa == 0xFFFFFFFF)
463 return IRQ_NONE;
464
465 /*
466 * Drain the reply FIFO!
467 */
468 do {
469 if (pa & MPI_ADDRESS_REPLY_A_BIT)
470 mpt_reply(ioc, pa);
471 else
472 mpt_turbo_reply(ioc, pa);
473 pa = CHIPREG_READ32_dmasync(&ioc->chip->ReplyFifo);
474 } while (pa != 0xFFFFFFFF);
475
476 return IRQ_HANDLED;
477 }
478
479 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
480 /**
481 * mpt_base_reply - MPT base driver's callback routine
482 * @ioc: Pointer to MPT_ADAPTER structure
483 * @mf: Pointer to original MPT request frame
484 * @reply: Pointer to MPT reply frame (NULL if TurboReply)
485 *
486 * MPT base driver's callback routine; all base driver
487 * "internal" request/reply processing is routed here.
488 * Currently used for EventNotification and EventAck handling.
489 *
490 * Returns 1 indicating original alloc'd request frame ptr
491 * should be freed, or 0 if it shouldn't.
492 */
493 static int
494 mpt_base_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
495 {
496 int freereq = 1;
497 u8 func;
498
499 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply() called\n", ioc->name));
500 #ifdef CONFIG_FUSION_LOGGING
501 if ((ioc->debug_level & MPT_DEBUG_MSG_FRAME) &&
502 !(reply->u.hdr.MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) {
503 dmfprintk(ioc, printk(MYIOC_s_INFO_FMT ": Original request frame (@%p) header\n",
504 ioc->name, mf));
505 DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)mf);
506 }
507 #endif
508
509 func = reply->u.hdr.Function;
510 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, Function=%02Xh\n",
511 ioc->name, func));
512
513 if (func == MPI_FUNCTION_EVENT_NOTIFICATION) {
514 EventNotificationReply_t *pEvReply = (EventNotificationReply_t *) reply;
515 int evHandlers = 0;
516 int results;
517
518 results = ProcessEventNotification(ioc, pEvReply, &evHandlers);
519 if (results != evHandlers) {
520 /* CHECKME! Any special handling needed here? */
521 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Called %d event handlers, sum results = %d\n",
522 ioc->name, evHandlers, results));
523 }
524
525 /*
526 * Hmmm... It seems that EventNotificationReply is an exception
527 * to the rule of one reply per request.
528 */
529 if (pEvReply->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) {
530 freereq = 0;
531 } else {
532 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "EVENT_NOTIFICATION reply %p returns Request frame\n",
533 ioc->name, pEvReply));
534 }
535
536 #ifdef CONFIG_PROC_FS
537 // LogEvent(ioc, pEvReply);
538 #endif
539
540 } else if (func == MPI_FUNCTION_EVENT_ACK) {
541 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_base_reply, EventAck reply received\n",
542 ioc->name));
543 } else if (func == MPI_FUNCTION_CONFIG) {
544 CONFIGPARMS *pCfg;
545 unsigned long flags;
546
547 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "config_complete (mf=%p,mr=%p)\n",
548 ioc->name, mf, reply));
549
550 pCfg = * ((CONFIGPARMS **)((u8 *) mf + ioc->req_sz - sizeof(void *)));
551
552 if (pCfg) {
553 /* disable timer and remove from linked list */
554 del_timer(&pCfg->timer);
555
556 spin_lock_irqsave(&ioc->FreeQlock, flags);
557 list_del(&pCfg->linkage);
558 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
559
560 /*
561 * If IOC Status is SUCCESS, save the header
562 * and set the status code to GOOD.
563 */
564 pCfg->status = MPT_CONFIG_ERROR;
565 if (reply) {
566 ConfigReply_t *pReply = (ConfigReply_t *)reply;
567 u16 status;
568
569 status = le16_to_cpu(pReply->IOCStatus) & MPI_IOCSTATUS_MASK;
570 dcprintk(ioc, printk(MYIOC_s_NOTE_FMT " IOCStatus=%04xh, IOCLogInfo=%08xh\n",
571 ioc->name, status, le32_to_cpu(pReply->IOCLogInfo)));
572
573 pCfg->status = status;
574 if (status == MPI_IOCSTATUS_SUCCESS) {
575 if ((pReply->Header.PageType &
576 MPI_CONFIG_PAGETYPE_MASK) ==
577 MPI_CONFIG_PAGETYPE_EXTENDED) {
578 pCfg->cfghdr.ehdr->ExtPageLength =
579 le16_to_cpu(pReply->ExtPageLength);
580 pCfg->cfghdr.ehdr->ExtPageType =
581 pReply->ExtPageType;
582 }
583 pCfg->cfghdr.hdr->PageVersion = pReply->Header.PageVersion;
584
585 /* If this is a regular header, save PageLength. */
586 /* LMP Do this better so not using a reserved field! */
587 pCfg->cfghdr.hdr->PageLength = pReply->Header.PageLength;
588 pCfg->cfghdr.hdr->PageNumber = pReply->Header.PageNumber;
589 pCfg->cfghdr.hdr->PageType = pReply->Header.PageType;
590 }
591 }
592
593 /*
594 * Wake up the original calling thread
595 */
596 pCfg->wait_done = 1;
597 wake_up(&mpt_waitq);
598 }
599 } else if (func == MPI_FUNCTION_SAS_IO_UNIT_CONTROL) {
600 /* we should be always getting a reply frame */
601 memcpy(ioc->persist_reply_frame, reply,
602 min(MPT_DEFAULT_FRAME_SIZE,
603 4*reply->u.reply.MsgLength));
604 del_timer(&ioc->persist_timer);
605 ioc->persist_wait_done = 1;
606 wake_up(&mpt_waitq);
607 } else {
608 printk(MYIOC_s_ERR_FMT "Unexpected msg function (=%02Xh) reply received!\n",
609 ioc->name, func);
610 }
611
612 /*
613 * Conditionally tell caller to free the original
614 * EventNotification/EventAck/unexpected request frame!
615 */
616 return freereq;
617 }
618
619 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
620 /**
621 * mpt_register - Register protocol-specific main callback handler.
622 * @cbfunc: callback function pointer
623 * @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
624 *
625 * This routine is called by a protocol-specific driver (SCSI host,
626 * LAN, SCSI target) to register its reply callback routine. Each
627 * protocol-specific driver must do this before it will be able to
628 * use any IOC resources, such as obtaining request frames.
629 *
630 * NOTES: The SCSI protocol driver currently calls this routine thrice
631 * in order to register separate callbacks; one for "normal" SCSI IO;
632 * one for MptScsiTaskMgmt requests; one for Scan/DV requests.
633 *
634 * Returns u8 valued "handle" in the range (and S.O.D. order)
635 * {N,...,7,6,5,...,1} if successful.
636 * A return value of MPT_MAX_PROTOCOL_DRIVERS (including zero!) should be
637 * considered an error by the caller.
638 */
639 u8
640 mpt_register(MPT_CALLBACK cbfunc, MPT_DRIVER_CLASS dclass)
641 {
642 u8 cb_idx;
643 last_drv_idx = MPT_MAX_PROTOCOL_DRIVERS;
644
645 /*
646 * Search for empty callback slot in this order: {N,...,7,6,5,...,1}
647 * (slot/handle 0 is reserved!)
648 */
649 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
650 if (MptCallbacks[cb_idx] == NULL) {
651 MptCallbacks[cb_idx] = cbfunc;
652 MptDriverClass[cb_idx] = dclass;
653 MptEvHandlers[cb_idx] = NULL;
654 last_drv_idx = cb_idx;
655 break;
656 }
657 }
658
659 return last_drv_idx;
660 }
661
662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
663 /**
664 * mpt_deregister - Deregister a protocol drivers resources.
665 * @cb_idx: previously registered callback handle
666 *
667 * Each protocol-specific driver should call this routine when its
668 * module is unloaded.
669 */
670 void
671 mpt_deregister(u8 cb_idx)
672 {
673 if (cb_idx && (cb_idx < MPT_MAX_PROTOCOL_DRIVERS)) {
674 MptCallbacks[cb_idx] = NULL;
675 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
676 MptEvHandlers[cb_idx] = NULL;
677
678 last_drv_idx++;
679 }
680 }
681
682 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
683 /**
684 * mpt_event_register - Register protocol-specific event callback handler.
685 * @cb_idx: previously registered (via mpt_register) callback handle
686 * @ev_cbfunc: callback function
687 *
688 * This routine can be called by one or more protocol-specific drivers
689 * if/when they choose to be notified of MPT events.
690 *
691 * Returns 0 for success.
692 */
693 int
694 mpt_event_register(u8 cb_idx, MPT_EVHANDLER ev_cbfunc)
695 {
696 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
697 return -1;
698
699 MptEvHandlers[cb_idx] = ev_cbfunc;
700 return 0;
701 }
702
703 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
704 /**
705 * mpt_event_deregister - Deregister protocol-specific event callback handler
706 * @cb_idx: previously registered callback handle
707 *
708 * Each protocol-specific driver should call this routine
709 * when it does not (or can no longer) handle events,
710 * or when its module is unloaded.
711 */
712 void
713 mpt_event_deregister(u8 cb_idx)
714 {
715 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
716 return;
717
718 MptEvHandlers[cb_idx] = NULL;
719 }
720
721 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
722 /**
723 * mpt_reset_register - Register protocol-specific IOC reset handler.
724 * @cb_idx: previously registered (via mpt_register) callback handle
725 * @reset_func: reset function
726 *
727 * This routine can be called by one or more protocol-specific drivers
728 * if/when they choose to be notified of IOC resets.
729 *
730 * Returns 0 for success.
731 */
732 int
733 mpt_reset_register(u8 cb_idx, MPT_RESETHANDLER reset_func)
734 {
735 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
736 return -1;
737
738 MptResetHandlers[cb_idx] = reset_func;
739 return 0;
740 }
741
742 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
743 /**
744 * mpt_reset_deregister - Deregister protocol-specific IOC reset handler.
745 * @cb_idx: previously registered callback handle
746 *
747 * Each protocol-specific driver should call this routine
748 * when it does not (or can no longer) handle IOC reset handling,
749 * or when its module is unloaded.
750 */
751 void
752 mpt_reset_deregister(u8 cb_idx)
753 {
754 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
755 return;
756
757 MptResetHandlers[cb_idx] = NULL;
758 }
759
760 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
761 /**
762 * mpt_device_driver_register - Register device driver hooks
763 * @dd_cbfunc: driver callbacks struct
764 * @cb_idx: MPT protocol driver index
765 */
766 int
767 mpt_device_driver_register(struct mpt_pci_driver * dd_cbfunc, u8 cb_idx)
768 {
769 MPT_ADAPTER *ioc;
770 const struct pci_device_id *id;
771
772 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
773 return -EINVAL;
774
775 MptDeviceDriverHandlers[cb_idx] = dd_cbfunc;
776
777 /* call per pci device probe entry point */
778 list_for_each_entry(ioc, &ioc_list, list) {
779 id = ioc->pcidev->driver ?
780 ioc->pcidev->driver->id_table : NULL;
781 if (dd_cbfunc->probe)
782 dd_cbfunc->probe(ioc->pcidev, id);
783 }
784
785 return 0;
786 }
787
788 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
789 /**
790 * mpt_device_driver_deregister - DeRegister device driver hooks
791 * @cb_idx: MPT protocol driver index
792 */
793 void
794 mpt_device_driver_deregister(u8 cb_idx)
795 {
796 struct mpt_pci_driver *dd_cbfunc;
797 MPT_ADAPTER *ioc;
798
799 if (!cb_idx || cb_idx >= MPT_MAX_PROTOCOL_DRIVERS)
800 return;
801
802 dd_cbfunc = MptDeviceDriverHandlers[cb_idx];
803
804 list_for_each_entry(ioc, &ioc_list, list) {
805 if (dd_cbfunc->remove)
806 dd_cbfunc->remove(ioc->pcidev);
807 }
808
809 MptDeviceDriverHandlers[cb_idx] = NULL;
810 }
811
812
813 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
814 /**
815 * mpt_get_msg_frame - Obtain an MPT request frame from the pool
816 * @cb_idx: Handle of registered MPT protocol driver
817 * @ioc: Pointer to MPT adapter structure
818 *
819 * Obtain an MPT request frame from the pool (of 1024) that are
820 * allocated per MPT adapter.
821 *
822 * Returns pointer to a MPT request frame or %NULL if none are available
823 * or IOC is not active.
824 */
825 MPT_FRAME_HDR*
826 mpt_get_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc)
827 {
828 MPT_FRAME_HDR *mf;
829 unsigned long flags;
830 u16 req_idx; /* Request index */
831
832 /* validate handle and ioc identifier */
833
834 #ifdef MFCNT
835 if (!ioc->active)
836 printk(MYIOC_s_WARN_FMT "IOC Not Active! mpt_get_msg_frame "
837 "returning NULL!\n", ioc->name);
838 #endif
839
840 /* If interrupts are not attached, do not return a request frame */
841 if (!ioc->active)
842 return NULL;
843
844 spin_lock_irqsave(&ioc->FreeQlock, flags);
845 if (!list_empty(&ioc->FreeQ)) {
846 int req_offset;
847
848 mf = list_entry(ioc->FreeQ.next, MPT_FRAME_HDR,
849 u.frame.linkage.list);
850 list_del(&mf->u.frame.linkage.list);
851 mf->u.frame.linkage.arg1 = 0;
852 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
853 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
854 /* u16! */
855 req_idx = req_offset / ioc->req_sz;
856 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
857 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
858 /* Default, will be changed if necessary in SG generation */
859 ioc->RequestNB[req_idx] = ioc->NB_for_64_byte_frame;
860 #ifdef MFCNT
861 ioc->mfcnt++;
862 #endif
863 }
864 else
865 mf = NULL;
866 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
867
868 #ifdef MFCNT
869 if (mf == NULL)
870 printk(MYIOC_s_WARN_FMT "IOC Active. No free Msg Frames! "
871 "Count 0x%x Max 0x%x\n", ioc->name, ioc->mfcnt,
872 ioc->req_depth);
873 mfcounter++;
874 if (mfcounter == PRINT_MF_COUNT)
875 printk(MYIOC_s_INFO_FMT "MF Count 0x%x Max 0x%x \n", ioc->name,
876 ioc->mfcnt, ioc->req_depth);
877 #endif
878
879 dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_get_msg_frame(%d,%d), got mf=%p\n",
880 ioc->name, cb_idx, ioc->id, mf));
881 return mf;
882 }
883
884 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
885 /**
886 * mpt_put_msg_frame - Send a protocol-specific MPT request frame to an IOC
887 * @cb_idx: Handle of registered MPT protocol driver
888 * @ioc: Pointer to MPT adapter structure
889 * @mf: Pointer to MPT request frame
890 *
891 * This routine posts an MPT request frame to the request post FIFO of a
892 * specific MPT adapter.
893 */
894 void
895 mpt_put_msg_frame(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
896 {
897 u32 mf_dma_addr;
898 int req_offset;
899 u16 req_idx; /* Request index */
900
901 /* ensure values are reset properly! */
902 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx; /* byte */
903 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
904 /* u16! */
905 req_idx = req_offset / ioc->req_sz;
906 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
907 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
908
909 DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
910
911 mf_dma_addr = (ioc->req_frames_low_dma + req_offset) | ioc->RequestNB[req_idx];
912 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d "
913 "RequestNB=%x\n", ioc->name, mf_dma_addr, req_idx,
914 ioc->RequestNB[req_idx]));
915 CHIPREG_WRITE32(&ioc->chip->RequestFifo, mf_dma_addr);
916 }
917
918 /**
919 * mpt_put_msg_frame_hi_pri - Send a hi-pri protocol-specific MPT request frame
920 * @cb_idx: Handle of registered MPT protocol driver
921 * @ioc: Pointer to MPT adapter structure
922 * @mf: Pointer to MPT request frame
923 *
924 * Send a protocol-specific MPT request frame to an IOC using
925 * hi-priority request queue.
926 *
927 * This routine posts an MPT request frame to the request post FIFO of a
928 * specific MPT adapter.
929 **/
930 void
931 mpt_put_msg_frame_hi_pri(u8 cb_idx, MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
932 {
933 u32 mf_dma_addr;
934 int req_offset;
935 u16 req_idx; /* Request index */
936
937 /* ensure values are reset properly! */
938 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
939 req_offset = (u8 *)mf - (u8 *)ioc->req_frames;
940 req_idx = req_offset / ioc->req_sz;
941 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(req_idx);
942 mf->u.frame.hwhdr.msgctxu.fld.rsvd = 0;
943
944 DBG_DUMP_PUT_MSG_FRAME(ioc, (u32 *)mf);
945
946 mf_dma_addr = (ioc->req_frames_low_dma + req_offset);
947 dsgprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mf_dma_addr=%x req_idx=%d\n",
948 ioc->name, mf_dma_addr, req_idx));
949 CHIPREG_WRITE32(&ioc->chip->RequestHiPriFifo, mf_dma_addr);
950 }
951
952 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
953 /**
954 * mpt_free_msg_frame - Place MPT request frame back on FreeQ.
955 * @handle: Handle of registered MPT protocol driver
956 * @ioc: Pointer to MPT adapter structure
957 * @mf: Pointer to MPT request frame
958 *
959 * This routine places a MPT request frame back on the MPT adapter's
960 * FreeQ.
961 */
962 void
963 mpt_free_msg_frame(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf)
964 {
965 unsigned long flags;
966
967 /* Put Request back on FreeQ! */
968 spin_lock_irqsave(&ioc->FreeQlock, flags);
969 mf->u.frame.linkage.arg1 = 0xdeadbeaf; /* signature to know if this mf is freed */
970 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
971 #ifdef MFCNT
972 ioc->mfcnt--;
973 #endif
974 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
975 }
976
977 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
978 /**
979 * mpt_add_sge - Place a simple SGE at address pAddr.
980 * @pAddr: virtual address for SGE
981 * @flagslength: SGE flags and data transfer length
982 * @dma_addr: Physical address
983 *
984 * This routine places a MPT request frame back on the MPT adapter's
985 * FreeQ.
986 */
987 void
988 mpt_add_sge(char *pAddr, u32 flagslength, dma_addr_t dma_addr)
989 {
990 if (sizeof(dma_addr_t) == sizeof(u64)) {
991 SGESimple64_t *pSge = (SGESimple64_t *) pAddr;
992 u32 tmp = dma_addr & 0xFFFFFFFF;
993
994 pSge->FlagsLength = cpu_to_le32(flagslength);
995 pSge->Address.Low = cpu_to_le32(tmp);
996 tmp = (u32) ((u64)dma_addr >> 32);
997 pSge->Address.High = cpu_to_le32(tmp);
998
999 } else {
1000 SGESimple32_t *pSge = (SGESimple32_t *) pAddr;
1001 pSge->FlagsLength = cpu_to_le32(flagslength);
1002 pSge->Address = cpu_to_le32(dma_addr);
1003 }
1004 }
1005
1006 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1007 /**
1008 * mpt_send_handshake_request - Send MPT request via doorbell handshake method.
1009 * @cb_idx: Handle of registered MPT protocol driver
1010 * @ioc: Pointer to MPT adapter structure
1011 * @reqBytes: Size of the request in bytes
1012 * @req: Pointer to MPT request frame
1013 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
1014 *
1015 * This routine is used exclusively to send MptScsiTaskMgmt
1016 * requests since they are required to be sent via doorbell handshake.
1017 *
1018 * NOTE: It is the callers responsibility to byte-swap fields in the
1019 * request which are greater than 1 byte in size.
1020 *
1021 * Returns 0 for success, non-zero for failure.
1022 */
1023 int
1024 mpt_send_handshake_request(u8 cb_idx, MPT_ADAPTER *ioc, int reqBytes, u32 *req, int sleepFlag)
1025 {
1026 int r = 0;
1027 u8 *req_as_bytes;
1028 int ii;
1029
1030 /* State is known to be good upon entering
1031 * this function so issue the bus reset
1032 * request.
1033 */
1034
1035 /*
1036 * Emulate what mpt_put_msg_frame() does /wrt to sanity
1037 * setting cb_idx/req_idx. But ONLY if this request
1038 * is in proper (pre-alloc'd) request buffer range...
1039 */
1040 ii = MFPTR_2_MPT_INDEX(ioc,(MPT_FRAME_HDR*)req);
1041 if (reqBytes >= 12 && ii >= 0 && ii < ioc->req_depth) {
1042 MPT_FRAME_HDR *mf = (MPT_FRAME_HDR*)req;
1043 mf->u.frame.hwhdr.msgctxu.fld.req_idx = cpu_to_le16(ii);
1044 mf->u.frame.hwhdr.msgctxu.fld.cb_idx = cb_idx;
1045 }
1046
1047 /* Make sure there are no doorbells */
1048 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1049
1050 CHIPREG_WRITE32(&ioc->chip->Doorbell,
1051 ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
1052 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
1053
1054 /* Wait for IOC doorbell int */
1055 if ((ii = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0) {
1056 return ii;
1057 }
1058
1059 /* Read doorbell and check for active bit */
1060 if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
1061 return -5;
1062
1063 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_send_handshake_request start, WaitCnt=%d\n",
1064 ioc->name, ii));
1065
1066 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1067
1068 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1069 return -2;
1070 }
1071
1072 /* Send request via doorbell handshake */
1073 req_as_bytes = (u8 *) req;
1074 for (ii = 0; ii < reqBytes/4; ii++) {
1075 u32 word;
1076
1077 word = ((req_as_bytes[(ii*4) + 0] << 0) |
1078 (req_as_bytes[(ii*4) + 1] << 8) |
1079 (req_as_bytes[(ii*4) + 2] << 16) |
1080 (req_as_bytes[(ii*4) + 3] << 24));
1081 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
1082 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1083 r = -3;
1084 break;
1085 }
1086 }
1087
1088 if (r >= 0 && WaitForDoorbellInt(ioc, 10, sleepFlag) >= 0)
1089 r = 0;
1090 else
1091 r = -4;
1092
1093 /* Make sure there are no doorbells */
1094 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1095
1096 return r;
1097 }
1098
1099 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1100 /**
1101 * mpt_host_page_access_control - control the IOC's Host Page Buffer access
1102 * @ioc: Pointer to MPT adapter structure
1103 * @access_control_value: define bits below
1104 * @sleepFlag: Specifies whether the process can sleep
1105 *
1106 * Provides mechanism for the host driver to control the IOC's
1107 * Host Page Buffer access.
1108 *
1109 * Access Control Value - bits[15:12]
1110 * 0h Reserved
1111 * 1h Enable Access { MPI_DB_HPBAC_ENABLE_ACCESS }
1112 * 2h Disable Access { MPI_DB_HPBAC_DISABLE_ACCESS }
1113 * 3h Free Buffer { MPI_DB_HPBAC_FREE_BUFFER }
1114 *
1115 * Returns 0 for success, non-zero for failure.
1116 */
1117
1118 static int
1119 mpt_host_page_access_control(MPT_ADAPTER *ioc, u8 access_control_value, int sleepFlag)
1120 {
1121 int r = 0;
1122
1123 /* return if in use */
1124 if (CHIPREG_READ32(&ioc->chip->Doorbell)
1125 & MPI_DOORBELL_ACTIVE)
1126 return -1;
1127
1128 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1129
1130 CHIPREG_WRITE32(&ioc->chip->Doorbell,
1131 ((MPI_FUNCTION_HOST_PAGEBUF_ACCESS_CONTROL
1132 <<MPI_DOORBELL_FUNCTION_SHIFT) |
1133 (access_control_value<<12)));
1134
1135 /* Wait for IOC to clear Doorbell Status bit */
1136 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0) {
1137 return -2;
1138 }else
1139 return 0;
1140 }
1141
1142 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1143 /**
1144 * mpt_host_page_alloc - allocate system memory for the fw
1145 * @ioc: Pointer to pointer to IOC adapter
1146 * @ioc_init: Pointer to ioc init config page
1147 *
1148 * If we already allocated memory in past, then resend the same pointer.
1149 * Returns 0 for success, non-zero for failure.
1150 */
1151 static int
1152 mpt_host_page_alloc(MPT_ADAPTER *ioc, pIOCInit_t ioc_init)
1153 {
1154 char *psge;
1155 int flags_length;
1156 u32 host_page_buffer_sz=0;
1157
1158 if(!ioc->HostPageBuffer) {
1159
1160 host_page_buffer_sz =
1161 le32_to_cpu(ioc->facts.HostPageBufferSGE.FlagsLength) & 0xFFFFFF;
1162
1163 if(!host_page_buffer_sz)
1164 return 0; /* fw doesn't need any host buffers */
1165
1166 /* spin till we get enough memory */
1167 while(host_page_buffer_sz > 0) {
1168
1169 if((ioc->HostPageBuffer = pci_alloc_consistent(
1170 ioc->pcidev,
1171 host_page_buffer_sz,
1172 &ioc->HostPageBuffer_dma)) != NULL) {
1173
1174 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1175 "host_page_buffer @ %p, dma @ %x, sz=%d bytes\n",
1176 ioc->name, ioc->HostPageBuffer,
1177 (u32)ioc->HostPageBuffer_dma,
1178 host_page_buffer_sz));
1179 ioc->alloc_total += host_page_buffer_sz;
1180 ioc->HostPageBuffer_sz = host_page_buffer_sz;
1181 break;
1182 }
1183
1184 host_page_buffer_sz -= (4*1024);
1185 }
1186 }
1187
1188 if(!ioc->HostPageBuffer) {
1189 printk(MYIOC_s_ERR_FMT
1190 "Failed to alloc memory for host_page_buffer!\n",
1191 ioc->name);
1192 return -999;
1193 }
1194
1195 psge = (char *)&ioc_init->HostPageBufferSGE;
1196 flags_length = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1197 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
1198 MPI_SGE_FLAGS_32_BIT_ADDRESSING |
1199 MPI_SGE_FLAGS_HOST_TO_IOC |
1200 MPI_SGE_FLAGS_END_OF_BUFFER;
1201 if (sizeof(dma_addr_t) == sizeof(u64)) {
1202 flags_length |= MPI_SGE_FLAGS_64_BIT_ADDRESSING;
1203 }
1204 flags_length = flags_length << MPI_SGE_FLAGS_SHIFT;
1205 flags_length |= ioc->HostPageBuffer_sz;
1206 mpt_add_sge(psge, flags_length, ioc->HostPageBuffer_dma);
1207 ioc->facts.HostPageBufferSGE = ioc_init->HostPageBufferSGE;
1208
1209 return 0;
1210 }
1211
1212 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1213 /**
1214 * mpt_verify_adapter - Given IOC identifier, set pointer to its adapter structure.
1215 * @iocid: IOC unique identifier (integer)
1216 * @iocpp: Pointer to pointer to IOC adapter
1217 *
1218 * Given a unique IOC identifier, set pointer to the associated MPT
1219 * adapter structure.
1220 *
1221 * Returns iocid and sets iocpp if iocid is found.
1222 * Returns -1 if iocid is not found.
1223 */
1224 int
1225 mpt_verify_adapter(int iocid, MPT_ADAPTER **iocpp)
1226 {
1227 MPT_ADAPTER *ioc;
1228
1229 list_for_each_entry(ioc,&ioc_list,list) {
1230 if (ioc->id == iocid) {
1231 *iocpp =ioc;
1232 return iocid;
1233 }
1234 }
1235
1236 *iocpp = NULL;
1237 return -1;
1238 }
1239
1240 /**
1241 * mpt_get_product_name - returns product string
1242 * @vendor: pci vendor id
1243 * @device: pci device id
1244 * @revision: pci revision id
1245 * @prod_name: string returned
1246 *
1247 * Returns product string displayed when driver loads,
1248 * in /proc/mpt/summary and /sysfs/class/scsi_host/host<X>/version_product
1249 *
1250 **/
1251 static void
1252 mpt_get_product_name(u16 vendor, u16 device, u8 revision, char *prod_name)
1253 {
1254 char *product_str = NULL;
1255
1256 if (vendor == PCI_VENDOR_ID_BROCADE) {
1257 switch (device)
1258 {
1259 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1260 switch (revision)
1261 {
1262 case 0x00:
1263 product_str = "BRE040 A0";
1264 break;
1265 case 0x01:
1266 product_str = "BRE040 A1";
1267 break;
1268 default:
1269 product_str = "BRE040";
1270 break;
1271 }
1272 break;
1273 }
1274 goto out;
1275 }
1276
1277 switch (device)
1278 {
1279 case MPI_MANUFACTPAGE_DEVICEID_FC909:
1280 product_str = "LSIFC909 B1";
1281 break;
1282 case MPI_MANUFACTPAGE_DEVICEID_FC919:
1283 product_str = "LSIFC919 B0";
1284 break;
1285 case MPI_MANUFACTPAGE_DEVICEID_FC929:
1286 product_str = "LSIFC929 B0";
1287 break;
1288 case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1289 if (revision < 0x80)
1290 product_str = "LSIFC919X A0";
1291 else
1292 product_str = "LSIFC919XL A1";
1293 break;
1294 case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1295 if (revision < 0x80)
1296 product_str = "LSIFC929X A0";
1297 else
1298 product_str = "LSIFC929XL A1";
1299 break;
1300 case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1301 product_str = "LSIFC939X A1";
1302 break;
1303 case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1304 product_str = "LSIFC949X A1";
1305 break;
1306 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1307 switch (revision)
1308 {
1309 case 0x00:
1310 product_str = "LSIFC949E A0";
1311 break;
1312 case 0x01:
1313 product_str = "LSIFC949E A1";
1314 break;
1315 default:
1316 product_str = "LSIFC949E";
1317 break;
1318 }
1319 break;
1320 case MPI_MANUFACTPAGE_DEVID_53C1030:
1321 switch (revision)
1322 {
1323 case 0x00:
1324 product_str = "LSI53C1030 A0";
1325 break;
1326 case 0x01:
1327 product_str = "LSI53C1030 B0";
1328 break;
1329 case 0x03:
1330 product_str = "LSI53C1030 B1";
1331 break;
1332 case 0x07:
1333 product_str = "LSI53C1030 B2";
1334 break;
1335 case 0x08:
1336 product_str = "LSI53C1030 C0";
1337 break;
1338 case 0x80:
1339 product_str = "LSI53C1030T A0";
1340 break;
1341 case 0x83:
1342 product_str = "LSI53C1030T A2";
1343 break;
1344 case 0x87:
1345 product_str = "LSI53C1030T A3";
1346 break;
1347 case 0xc1:
1348 product_str = "LSI53C1020A A1";
1349 break;
1350 default:
1351 product_str = "LSI53C1030";
1352 break;
1353 }
1354 break;
1355 case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1356 switch (revision)
1357 {
1358 case 0x03:
1359 product_str = "LSI53C1035 A2";
1360 break;
1361 case 0x04:
1362 product_str = "LSI53C1035 B0";
1363 break;
1364 default:
1365 product_str = "LSI53C1035";
1366 break;
1367 }
1368 break;
1369 case MPI_MANUFACTPAGE_DEVID_SAS1064:
1370 switch (revision)
1371 {
1372 case 0x00:
1373 product_str = "LSISAS1064 A1";
1374 break;
1375 case 0x01:
1376 product_str = "LSISAS1064 A2";
1377 break;
1378 case 0x02:
1379 product_str = "LSISAS1064 A3";
1380 break;
1381 case 0x03:
1382 product_str = "LSISAS1064 A4";
1383 break;
1384 default:
1385 product_str = "LSISAS1064";
1386 break;
1387 }
1388 break;
1389 case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1390 switch (revision)
1391 {
1392 case 0x00:
1393 product_str = "LSISAS1064E A0";
1394 break;
1395 case 0x01:
1396 product_str = "LSISAS1064E B0";
1397 break;
1398 case 0x02:
1399 product_str = "LSISAS1064E B1";
1400 break;
1401 case 0x04:
1402 product_str = "LSISAS1064E B2";
1403 break;
1404 case 0x08:
1405 product_str = "LSISAS1064E B3";
1406 break;
1407 default:
1408 product_str = "LSISAS1064E";
1409 break;
1410 }
1411 break;
1412 case MPI_MANUFACTPAGE_DEVID_SAS1068:
1413 switch (revision)
1414 {
1415 case 0x00:
1416 product_str = "LSISAS1068 A0";
1417 break;
1418 case 0x01:
1419 product_str = "LSISAS1068 B0";
1420 break;
1421 case 0x02:
1422 product_str = "LSISAS1068 B1";
1423 break;
1424 default:
1425 product_str = "LSISAS1068";
1426 break;
1427 }
1428 break;
1429 case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1430 switch (revision)
1431 {
1432 case 0x00:
1433 product_str = "LSISAS1068E A0";
1434 break;
1435 case 0x01:
1436 product_str = "LSISAS1068E B0";
1437 break;
1438 case 0x02:
1439 product_str = "LSISAS1068E B1";
1440 break;
1441 case 0x04:
1442 product_str = "LSISAS1068E B2";
1443 break;
1444 case 0x08:
1445 product_str = "LSISAS1068E B3";
1446 break;
1447 default:
1448 product_str = "LSISAS1068E";
1449 break;
1450 }
1451 break;
1452 case MPI_MANUFACTPAGE_DEVID_SAS1078:
1453 switch (revision)
1454 {
1455 case 0x00:
1456 product_str = "LSISAS1078 A0";
1457 break;
1458 case 0x01:
1459 product_str = "LSISAS1078 B0";
1460 break;
1461 case 0x02:
1462 product_str = "LSISAS1078 C0";
1463 break;
1464 case 0x03:
1465 product_str = "LSISAS1078 C1";
1466 break;
1467 case 0x04:
1468 product_str = "LSISAS1078 C2";
1469 break;
1470 default:
1471 product_str = "LSISAS1078";
1472 break;
1473 }
1474 break;
1475 }
1476
1477 out:
1478 if (product_str)
1479 sprintf(prod_name, "%s", product_str);
1480 }
1481
1482 /**
1483 * mpt_mapresources - map in memory mapped io
1484 * @ioc: Pointer to pointer to IOC adapter
1485 *
1486 **/
1487 static int
1488 mpt_mapresources(MPT_ADAPTER *ioc)
1489 {
1490 u8 __iomem *mem;
1491 int ii;
1492 unsigned long mem_phys;
1493 unsigned long port;
1494 u32 msize;
1495 u32 psize;
1496 u8 revision;
1497 int r = -ENODEV;
1498 struct pci_dev *pdev;
1499
1500 pdev = ioc->pcidev;
1501 ioc->bars = pci_select_bars(pdev, IORESOURCE_MEM);
1502 if (pci_enable_device_mem(pdev)) {
1503 printk(MYIOC_s_ERR_FMT "pci_enable_device_mem() "
1504 "failed\n", ioc->name);
1505 return r;
1506 }
1507 if (pci_request_selected_regions(pdev, ioc->bars, "mpt")) {
1508 printk(MYIOC_s_ERR_FMT "pci_request_selected_regions() with "
1509 "MEM failed\n", ioc->name);
1510 return r;
1511 }
1512
1513 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1514
1515 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK)
1516 && !pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK)) {
1517 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
1518 ": 64 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
1519 ioc->name));
1520 } else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK)
1521 && !pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
1522 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
1523 ": 32 BIT PCI BUS DMA ADDRESSING SUPPORTED\n",
1524 ioc->name));
1525 } else {
1526 printk(MYIOC_s_WARN_FMT "no suitable DMA mask for %s\n",
1527 ioc->name, pci_name(pdev));
1528 pci_release_selected_regions(pdev, ioc->bars);
1529 return r;
1530 }
1531
1532 mem_phys = msize = 0;
1533 port = psize = 0;
1534 for (ii = 0; ii < DEVICE_COUNT_RESOURCE; ii++) {
1535 if (pci_resource_flags(pdev, ii) & PCI_BASE_ADDRESS_SPACE_IO) {
1536 if (psize)
1537 continue;
1538 /* Get I/O space! */
1539 port = pci_resource_start(pdev, ii);
1540 psize = pci_resource_len(pdev, ii);
1541 } else {
1542 if (msize)
1543 continue;
1544 /* Get memmap */
1545 mem_phys = pci_resource_start(pdev, ii);
1546 msize = pci_resource_len(pdev, ii);
1547 }
1548 }
1549 ioc->mem_size = msize;
1550
1551 mem = NULL;
1552 /* Get logical ptr for PciMem0 space */
1553 /*mem = ioremap(mem_phys, msize);*/
1554 mem = ioremap(mem_phys, msize);
1555 if (mem == NULL) {
1556 printk(MYIOC_s_ERR_FMT ": ERROR - Unable to map adapter"
1557 " memory!\n", ioc->name);
1558 return -EINVAL;
1559 }
1560 ioc->memmap = mem;
1561 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "mem = %p, mem_phys = %lx\n",
1562 ioc->name, mem, mem_phys));
1563
1564 ioc->mem_phys = mem_phys;
1565 ioc->chip = (SYSIF_REGS __iomem *)mem;
1566
1567 /* Save Port IO values in case we need to do downloadboot */
1568 ioc->pio_mem_phys = port;
1569 ioc->pio_chip = (SYSIF_REGS __iomem *)port;
1570
1571 return 0;
1572 }
1573
1574 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1575 /**
1576 * mpt_attach - Install a PCI intelligent MPT adapter.
1577 * @pdev: Pointer to pci_dev structure
1578 * @id: PCI device ID information
1579 *
1580 * This routine performs all the steps necessary to bring the IOC of
1581 * a MPT adapter to a OPERATIONAL state. This includes registering
1582 * memory regions, registering the interrupt, and allocating request
1583 * and reply memory pools.
1584 *
1585 * This routine also pre-fetches the LAN MAC address of a Fibre Channel
1586 * MPT adapter.
1587 *
1588 * Returns 0 for success, non-zero for failure.
1589 *
1590 * TODO: Add support for polled controllers
1591 */
1592 int
1593 mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
1594 {
1595 MPT_ADAPTER *ioc;
1596 u8 cb_idx;
1597 int r = -ENODEV;
1598 u8 revision;
1599 u8 pcixcmd;
1600 static int mpt_ids = 0;
1601 #ifdef CONFIG_PROC_FS
1602 struct proc_dir_entry *dent, *ent;
1603 #endif
1604
1605 ioc = kzalloc(sizeof(MPT_ADAPTER), GFP_ATOMIC);
1606 if (ioc == NULL) {
1607 printk(KERN_ERR MYNAM ": ERROR - Insufficient memory to add adapter!\n");
1608 return -ENOMEM;
1609 }
1610
1611 ioc->id = mpt_ids++;
1612 sprintf(ioc->name, "ioc%d", ioc->id);
1613
1614 /*
1615 * set initial debug level
1616 * (refer to mptdebug.h)
1617 *
1618 */
1619 ioc->debug_level = mpt_debug_level;
1620 if (mpt_debug_level)
1621 printk(KERN_INFO "mpt_debug_level=%xh\n", mpt_debug_level);
1622
1623 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": mpt_adapter_install\n", ioc->name));
1624
1625 ioc->pcidev = pdev;
1626 if (mpt_mapresources(ioc)) {
1627 kfree(ioc);
1628 return r;
1629 }
1630
1631 ioc->alloc_total = sizeof(MPT_ADAPTER);
1632 ioc->req_sz = MPT_DEFAULT_FRAME_SIZE; /* avoid div by zero! */
1633 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
1634
1635 ioc->pcidev = pdev;
1636 ioc->diagPending = 0;
1637 spin_lock_init(&ioc->diagLock);
1638 spin_lock_init(&ioc->initializing_hba_lock);
1639
1640 /* Initialize the event logging.
1641 */
1642 ioc->eventTypes = 0; /* None */
1643 ioc->eventContext = 0;
1644 ioc->eventLogSize = 0;
1645 ioc->events = NULL;
1646
1647 #ifdef MFCNT
1648 ioc->mfcnt = 0;
1649 #endif
1650
1651 ioc->cached_fw = NULL;
1652
1653 /* Initilize SCSI Config Data structure
1654 */
1655 memset(&ioc->spi_data, 0, sizeof(SpiCfgData));
1656
1657 /* Initialize the running configQ head.
1658 */
1659 INIT_LIST_HEAD(&ioc->configQ);
1660
1661 /* Initialize the fc rport list head.
1662 */
1663 INIT_LIST_HEAD(&ioc->fc_rports);
1664
1665 /* Find lookup slot. */
1666 INIT_LIST_HEAD(&ioc->list);
1667
1668
1669 /* Initialize workqueue */
1670 INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
1671 spin_lock_init(&ioc->fault_reset_work_lock);
1672
1673 snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
1674 "mpt_poll_%d", ioc->id);
1675 ioc->reset_work_q =
1676 create_singlethread_workqueue(ioc->reset_work_q_name);
1677 if (!ioc->reset_work_q) {
1678 printk(MYIOC_s_ERR_FMT "Insufficient memory to add adapter!\n",
1679 ioc->name);
1680 pci_release_selected_regions(pdev, ioc->bars);
1681 kfree(ioc);
1682 return -ENOMEM;
1683 }
1684
1685 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "facts @ %p, pfacts[0] @ %p\n",
1686 ioc->name, &ioc->facts, &ioc->pfacts[0]));
1687
1688 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
1689 mpt_get_product_name(pdev->vendor, pdev->device, revision, ioc->prod_name);
1690
1691 switch (pdev->device)
1692 {
1693 case MPI_MANUFACTPAGE_DEVICEID_FC939X:
1694 case MPI_MANUFACTPAGE_DEVICEID_FC949X:
1695 ioc->errata_flag_1064 = 1;
1696 case MPI_MANUFACTPAGE_DEVICEID_FC909:
1697 case MPI_MANUFACTPAGE_DEVICEID_FC929:
1698 case MPI_MANUFACTPAGE_DEVICEID_FC919:
1699 case MPI_MANUFACTPAGE_DEVICEID_FC949E:
1700 ioc->bus_type = FC;
1701 break;
1702
1703 case MPI_MANUFACTPAGE_DEVICEID_FC929X:
1704 if (revision < XL_929) {
1705 /* 929X Chip Fix. Set Split transactions level
1706 * for PCIX. Set MOST bits to zero.
1707 */
1708 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1709 pcixcmd &= 0x8F;
1710 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1711 } else {
1712 /* 929XL Chip Fix. Set MMRBC to 0x08.
1713 */
1714 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1715 pcixcmd |= 0x08;
1716 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1717 }
1718 ioc->bus_type = FC;
1719 break;
1720
1721 case MPI_MANUFACTPAGE_DEVICEID_FC919X:
1722 /* 919X Chip Fix. Set Split transactions level
1723 * for PCIX. Set MOST bits to zero.
1724 */
1725 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1726 pcixcmd &= 0x8F;
1727 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1728 ioc->bus_type = FC;
1729 break;
1730
1731 case MPI_MANUFACTPAGE_DEVID_53C1030:
1732 /* 1030 Chip Fix. Disable Split transactions
1733 * for PCIX. Set MOST bits to zero if Rev < C0( = 8).
1734 */
1735 if (revision < C0_1030) {
1736 pci_read_config_byte(pdev, 0x6a, &pcixcmd);
1737 pcixcmd &= 0x8F;
1738 pci_write_config_byte(pdev, 0x6a, pcixcmd);
1739 }
1740
1741 case MPI_MANUFACTPAGE_DEVID_1030_53C1035:
1742 ioc->bus_type = SPI;
1743 break;
1744
1745 case MPI_MANUFACTPAGE_DEVID_SAS1064:
1746 case MPI_MANUFACTPAGE_DEVID_SAS1068:
1747 ioc->errata_flag_1064 = 1;
1748
1749 case MPI_MANUFACTPAGE_DEVID_SAS1064E:
1750 case MPI_MANUFACTPAGE_DEVID_SAS1068E:
1751 case MPI_MANUFACTPAGE_DEVID_SAS1078:
1752 ioc->bus_type = SAS;
1753 }
1754
1755 if (mpt_msi_enable == -1) {
1756 /* Enable on SAS, disable on FC and SPI */
1757 if (ioc->bus_type == SAS)
1758 ioc->msi_enable = 1;
1759 else
1760 ioc->msi_enable = 0;
1761 } else
1762 /* follow flag: 0 - disable; 1 - enable */
1763 ioc->msi_enable = mpt_msi_enable;
1764
1765 if (ioc->errata_flag_1064)
1766 pci_disable_io_access(pdev);
1767
1768 spin_lock_init(&ioc->FreeQlock);
1769
1770 /* Disable all! */
1771 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1772 ioc->active = 0;
1773 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1774
1775 /* Set IOC ptr in the pcidev's driver data. */
1776 pci_set_drvdata(ioc->pcidev, ioc);
1777
1778 /* Set lookup ptr. */
1779 list_add_tail(&ioc->list, &ioc_list);
1780
1781 /* Check for "bound ports" (929, 929X, 1030, 1035) to reduce redundant resets.
1782 */
1783 mpt_detect_bound_ports(ioc, pdev);
1784
1785 if ((r = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1786 CAN_SLEEP)) != 0){
1787 printk(MYIOC_s_ERR_FMT "didn't initialize properly! (%d)\n",
1788 ioc->name, r);
1789
1790 list_del(&ioc->list);
1791 if (ioc->alt_ioc)
1792 ioc->alt_ioc->alt_ioc = NULL;
1793 iounmap(ioc->memmap);
1794 if (r != -5)
1795 pci_release_selected_regions(pdev, ioc->bars);
1796
1797 destroy_workqueue(ioc->reset_work_q);
1798 ioc->reset_work_q = NULL;
1799
1800 kfree(ioc);
1801 pci_set_drvdata(pdev, NULL);
1802 return r;
1803 }
1804
1805 /* call per device driver probe entry point */
1806 for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
1807 if(MptDeviceDriverHandlers[cb_idx] &&
1808 MptDeviceDriverHandlers[cb_idx]->probe) {
1809 MptDeviceDriverHandlers[cb_idx]->probe(pdev,id);
1810 }
1811 }
1812
1813 #ifdef CONFIG_PROC_FS
1814 /*
1815 * Create "/proc/mpt/iocN" subdirectory entry for each MPT adapter.
1816 */
1817 dent = proc_mkdir(ioc->name, mpt_proc_root_dir);
1818 if (dent) {
1819 ent = create_proc_entry("info", S_IFREG|S_IRUGO, dent);
1820 if (ent) {
1821 ent->read_proc = procmpt_iocinfo_read;
1822 ent->data = ioc;
1823 }
1824 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, dent);
1825 if (ent) {
1826 ent->read_proc = procmpt_summary_read;
1827 ent->data = ioc;
1828 }
1829 }
1830 #endif
1831
1832 if (!ioc->alt_ioc)
1833 queue_delayed_work(ioc->reset_work_q, &ioc->fault_reset_work,
1834 msecs_to_jiffies(MPT_POLLING_INTERVAL));
1835
1836 return 0;
1837 }
1838
1839 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1840 /**
1841 * mpt_detach - Remove a PCI intelligent MPT adapter.
1842 * @pdev: Pointer to pci_dev structure
1843 */
1844
1845 void
1846 mpt_detach(struct pci_dev *pdev)
1847 {
1848 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1849 char pname[32];
1850 u8 cb_idx;
1851 unsigned long flags;
1852 struct workqueue_struct *wq;
1853
1854 /*
1855 * Stop polling ioc for fault condition
1856 */
1857 spin_lock_irqsave(&ioc->fault_reset_work_lock, flags);
1858 wq = ioc->reset_work_q;
1859 ioc->reset_work_q = NULL;
1860 spin_unlock_irqrestore(&ioc->fault_reset_work_lock, flags);
1861 cancel_delayed_work(&ioc->fault_reset_work);
1862 destroy_workqueue(wq);
1863
1864
1865 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/summary", ioc->name);
1866 remove_proc_entry(pname, NULL);
1867 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s/info", ioc->name);
1868 remove_proc_entry(pname, NULL);
1869 sprintf(pname, MPT_PROCFS_MPTBASEDIR "/%s", ioc->name);
1870 remove_proc_entry(pname, NULL);
1871
1872 /* call per device driver remove entry point */
1873 for(cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
1874 if(MptDeviceDriverHandlers[cb_idx] &&
1875 MptDeviceDriverHandlers[cb_idx]->remove) {
1876 MptDeviceDriverHandlers[cb_idx]->remove(pdev);
1877 }
1878 }
1879
1880 /* Disable interrupts! */
1881 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1882
1883 ioc->active = 0;
1884 synchronize_irq(pdev->irq);
1885
1886 /* Clear any lingering interrupt */
1887 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1888
1889 CHIPREG_READ32(&ioc->chip->IntStatus);
1890
1891 mpt_adapter_dispose(ioc);
1892
1893 pci_set_drvdata(pdev, NULL);
1894 }
1895
1896 /**************************************************************************
1897 * Power Management
1898 */
1899 #ifdef CONFIG_PM
1900 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1901 /**
1902 * mpt_suspend - Fusion MPT base driver suspend routine.
1903 * @pdev: Pointer to pci_dev structure
1904 * @state: new state to enter
1905 */
1906 int
1907 mpt_suspend(struct pci_dev *pdev, pm_message_t state)
1908 {
1909 u32 device_state;
1910 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1911
1912 device_state = pci_choose_state(pdev, state);
1913 printk(MYIOC_s_INFO_FMT "pci-suspend: pdev=0x%p, slot=%s, Entering "
1914 "operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
1915 device_state);
1916
1917 /* put ioc into READY_STATE */
1918 if(SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, CAN_SLEEP)) {
1919 printk(MYIOC_s_ERR_FMT
1920 "pci-suspend: IOC msg unit reset failed!\n", ioc->name);
1921 }
1922
1923 /* disable interrupts */
1924 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
1925 ioc->active = 0;
1926
1927 /* Clear any lingering interrupt */
1928 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
1929
1930 free_irq(ioc->pci_irq, ioc);
1931 if (ioc->msi_enable)
1932 pci_disable_msi(ioc->pcidev);
1933 ioc->pci_irq = -1;
1934 pci_save_state(pdev);
1935 pci_disable_device(pdev);
1936 pci_release_selected_regions(pdev, ioc->bars);
1937 pci_set_power_state(pdev, device_state);
1938 return 0;
1939 }
1940
1941 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1942 /**
1943 * mpt_resume - Fusion MPT base driver resume routine.
1944 * @pdev: Pointer to pci_dev structure
1945 */
1946 int
1947 mpt_resume(struct pci_dev *pdev)
1948 {
1949 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1950 u32 device_state = pdev->current_state;
1951 int recovery_state;
1952 int err;
1953
1954 printk(MYIOC_s_INFO_FMT "pci-resume: pdev=0x%p, slot=%s, Previous "
1955 "operating state [D%d]\n", ioc->name, pdev, pci_name(pdev),
1956 device_state);
1957
1958 pci_set_power_state(pdev, PCI_D0);
1959 pci_enable_wake(pdev, PCI_D0, 0);
1960 pci_restore_state(pdev);
1961 ioc->pcidev = pdev;
1962 err = mpt_mapresources(ioc);
1963 if (err)
1964 return err;
1965
1966 printk(MYIOC_s_INFO_FMT "pci-resume: ioc-state=0x%x,doorbell=0x%x\n",
1967 ioc->name, (mpt_GetIocState(ioc, 1) >> MPI_IOC_STATE_SHIFT),
1968 CHIPREG_READ32(&ioc->chip->Doorbell));
1969
1970 /*
1971 * Errata workaround for SAS pci express:
1972 * Upon returning to the D0 state, the contents of the doorbell will be
1973 * stale data, and this will incorrectly signal to the host driver that
1974 * the firmware is ready to process mpt commands. The workaround is
1975 * to issue a diagnostic reset.
1976 */
1977 if (ioc->bus_type == SAS && (pdev->device ==
1978 MPI_MANUFACTPAGE_DEVID_SAS1068E || pdev->device ==
1979 MPI_MANUFACTPAGE_DEVID_SAS1064E)) {
1980 if (KickStart(ioc, 1, CAN_SLEEP) < 0) {
1981 printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover\n",
1982 ioc->name);
1983 goto out;
1984 }
1985 }
1986
1987 /* bring ioc to operational state */
1988 printk(MYIOC_s_INFO_FMT "Sending mpt_do_ioc_recovery\n", ioc->name);
1989 recovery_state = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_BRINGUP,
1990 CAN_SLEEP);
1991 if (recovery_state != 0)
1992 printk(MYIOC_s_WARN_FMT "pci-resume: Cannot recover, "
1993 "error:[%x]\n", ioc->name, recovery_state);
1994 else
1995 printk(MYIOC_s_INFO_FMT
1996 "pci-resume: success\n", ioc->name);
1997 out:
1998 return 0;
1999
2000 }
2001 #endif
2002
2003 static int
2004 mpt_signal_reset(u8 index, MPT_ADAPTER *ioc, int reset_phase)
2005 {
2006 if ((MptDriverClass[index] == MPTSPI_DRIVER &&
2007 ioc->bus_type != SPI) ||
2008 (MptDriverClass[index] == MPTFC_DRIVER &&
2009 ioc->bus_type != FC) ||
2010 (MptDriverClass[index] == MPTSAS_DRIVER &&
2011 ioc->bus_type != SAS))
2012 /* make sure we only call the relevant reset handler
2013 * for the bus */
2014 return 0;
2015 return (MptResetHandlers[index])(ioc, reset_phase);
2016 }
2017
2018 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2019 /**
2020 * mpt_do_ioc_recovery - Initialize or recover MPT adapter.
2021 * @ioc: Pointer to MPT adapter structure
2022 * @reason: Event word / reason
2023 * @sleepFlag: Use schedule if CAN_SLEEP else use udelay.
2024 *
2025 * This routine performs all the steps necessary to bring the IOC
2026 * to a OPERATIONAL state.
2027 *
2028 * This routine also pre-fetches the LAN MAC address of a Fibre Channel
2029 * MPT adapter.
2030 *
2031 * Returns:
2032 * 0 for success
2033 * -1 if failed to get board READY
2034 * -2 if READY but IOCFacts Failed
2035 * -3 if READY but PrimeIOCFifos Failed
2036 * -4 if READY but IOCInit Failed
2037 * -5 if failed to enable_device and/or request_selected_regions
2038 * -6 if failed to upload firmware
2039 */
2040 static int
2041 mpt_do_ioc_recovery(MPT_ADAPTER *ioc, u32 reason, int sleepFlag)
2042 {
2043 int hard_reset_done = 0;
2044 int alt_ioc_ready = 0;
2045 int hard;
2046 int rc=0;
2047 int ii;
2048 u8 cb_idx;
2049 int handlers;
2050 int ret = 0;
2051 int reset_alt_ioc_active = 0;
2052 int irq_allocated = 0;
2053 u8 *a;
2054
2055 printk(MYIOC_s_INFO_FMT "Initiating %s\n", ioc->name,
2056 reason == MPT_HOSTEVENT_IOC_BRINGUP ? "bringup" : "recovery");
2057
2058 /* Disable reply interrupts (also blocks FreeQ) */
2059 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2060 ioc->active = 0;
2061
2062 if (ioc->alt_ioc) {
2063 if (ioc->alt_ioc->active)
2064 reset_alt_ioc_active = 1;
2065
2066 /* Disable alt-IOC's reply interrupts (and FreeQ) for a bit ... */
2067 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, 0xFFFFFFFF);
2068 ioc->alt_ioc->active = 0;
2069 }
2070
2071 hard = 1;
2072 if (reason == MPT_HOSTEVENT_IOC_BRINGUP)
2073 hard = 0;
2074
2075 if ((hard_reset_done = MakeIocReady(ioc, hard, sleepFlag)) < 0) {
2076 if (hard_reset_done == -4) {
2077 printk(MYIOC_s_WARN_FMT "Owned by PEER..skipping!\n",
2078 ioc->name);
2079
2080 if (reset_alt_ioc_active && ioc->alt_ioc) {
2081 /* (re)Enable alt-IOC! (reply interrupt, FreeQ) */
2082 dprintk(ioc, printk(MYIOC_s_INFO_FMT
2083 "alt_ioc reply irq re-enabled\n", ioc->alt_ioc->name));
2084 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2085 ioc->alt_ioc->active = 1;
2086 }
2087
2088 } else {
2089 printk(MYIOC_s_WARN_FMT "NOT READY!\n", ioc->name);
2090 }
2091 return -1;
2092 }
2093
2094 /* hard_reset_done = 0 if a soft reset was performed
2095 * and 1 if a hard reset was performed.
2096 */
2097 if (hard_reset_done && reset_alt_ioc_active && ioc->alt_ioc) {
2098 if ((rc = MakeIocReady(ioc->alt_ioc, 0, sleepFlag)) == 0)
2099 alt_ioc_ready = 1;
2100 else
2101 printk(MYIOC_s_WARN_FMT "alt_ioc not ready!\n", ioc->alt_ioc->name);
2102 }
2103
2104 for (ii=0; ii<5; ii++) {
2105 /* Get IOC facts! Allow 5 retries */
2106 if ((rc = GetIocFacts(ioc, sleepFlag, reason)) == 0)
2107 break;
2108 }
2109
2110
2111 if (ii == 5) {
2112 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2113 "Retry IocFacts failed rc=%x\n", ioc->name, rc));
2114 ret = -2;
2115 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2116 MptDisplayIocCapabilities(ioc);
2117 }
2118
2119 if (alt_ioc_ready) {
2120 if ((rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason)) != 0) {
2121 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2122 "Initial Alt IocFacts failed rc=%x\n", ioc->name, rc));
2123 /* Retry - alt IOC was initialized once
2124 */
2125 rc = GetIocFacts(ioc->alt_ioc, sleepFlag, reason);
2126 }
2127 if (rc) {
2128 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2129 "Retry Alt IocFacts failed rc=%x\n", ioc->name, rc));
2130 alt_ioc_ready = 0;
2131 reset_alt_ioc_active = 0;
2132 } else if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2133 MptDisplayIocCapabilities(ioc->alt_ioc);
2134 }
2135 }
2136
2137 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP) &&
2138 (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)) {
2139 pci_release_selected_regions(ioc->pcidev, ioc->bars);
2140 ioc->bars = pci_select_bars(ioc->pcidev, IORESOURCE_MEM |
2141 IORESOURCE_IO);
2142 if (pci_enable_device(ioc->pcidev))
2143 return -5;
2144 if (pci_request_selected_regions(ioc->pcidev, ioc->bars,
2145 "mpt"))
2146 return -5;
2147 }
2148
2149 /*
2150 * Device is reset now. It must have de-asserted the interrupt line
2151 * (if it was asserted) and it should be safe to register for the
2152 * interrupt now.
2153 */
2154 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2155 ioc->pci_irq = -1;
2156 if (ioc->pcidev->irq) {
2157 if (ioc->msi_enable && !pci_enable_msi(ioc->pcidev))
2158 printk(MYIOC_s_INFO_FMT "PCI-MSI enabled\n",
2159 ioc->name);
2160 else
2161 ioc->msi_enable = 0;
2162 rc = request_irq(ioc->pcidev->irq, mpt_interrupt,
2163 IRQF_SHARED, ioc->name, ioc);
2164 if (rc < 0) {
2165 printk(MYIOC_s_ERR_FMT "Unable to allocate "
2166 "interrupt %d!\n", ioc->name, ioc->pcidev->irq);
2167 if (ioc->msi_enable)
2168 pci_disable_msi(ioc->pcidev);
2169 return -EBUSY;
2170 }
2171 irq_allocated = 1;
2172 ioc->pci_irq = ioc->pcidev->irq;
2173 pci_set_master(ioc->pcidev); /* ?? */
2174 dprintk(ioc, printk(MYIOC_s_INFO_FMT "installed at interrupt "
2175 "%d\n", ioc->name, ioc->pcidev->irq));
2176 }
2177 }
2178
2179 /* Prime reply & request queues!
2180 * (mucho alloc's) Must be done prior to
2181 * init as upper addresses are needed for init.
2182 * If fails, continue with alt-ioc processing
2183 */
2184 if ((ret == 0) && ((rc = PrimeIocFifos(ioc)) != 0))
2185 ret = -3;
2186
2187 /* May need to check/upload firmware & data here!
2188 * If fails, continue with alt-ioc processing
2189 */
2190 if ((ret == 0) && ((rc = SendIocInit(ioc, sleepFlag)) != 0))
2191 ret = -4;
2192 // NEW!
2193 if (alt_ioc_ready && ((rc = PrimeIocFifos(ioc->alt_ioc)) != 0)) {
2194 printk(MYIOC_s_WARN_FMT ": alt_ioc (%d) FIFO mgmt alloc!\n",
2195 ioc->alt_ioc->name, rc);
2196 alt_ioc_ready = 0;
2197 reset_alt_ioc_active = 0;
2198 }
2199
2200 if (alt_ioc_ready) {
2201 if ((rc = SendIocInit(ioc->alt_ioc, sleepFlag)) != 0) {
2202 alt_ioc_ready = 0;
2203 reset_alt_ioc_active = 0;
2204 printk(MYIOC_s_WARN_FMT "alt_ioc (%d) init failure!\n",
2205 ioc->alt_ioc->name, rc);
2206 }
2207 }
2208
2209 if (reason == MPT_HOSTEVENT_IOC_BRINGUP){
2210 if (ioc->upload_fw) {
2211 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2212 "firmware upload required!\n", ioc->name));
2213
2214 /* Controller is not operational, cannot do upload
2215 */
2216 if (ret == 0) {
2217 rc = mpt_do_upload(ioc, sleepFlag);
2218 if (rc == 0) {
2219 if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
2220 /*
2221 * Maintain only one pointer to FW memory
2222 * so there will not be two attempt to
2223 * downloadboot onboard dual function
2224 * chips (mpt_adapter_disable,
2225 * mpt_diag_reset)
2226 */
2227 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2228 "mpt_upload: alt_%s has cached_fw=%p \n",
2229 ioc->name, ioc->alt_ioc->name, ioc->alt_ioc->cached_fw));
2230 ioc->cached_fw = NULL;
2231 }
2232 } else {
2233 printk(MYIOC_s_WARN_FMT
2234 "firmware upload failure!\n", ioc->name);
2235 ret = -6;
2236 }
2237 }
2238 }
2239 }
2240
2241 if (ret == 0) {
2242 /* Enable! (reply interrupt) */
2243 CHIPREG_WRITE32(&ioc->chip->IntMask, MPI_HIM_DIM);
2244 ioc->active = 1;
2245 }
2246
2247 if (reset_alt_ioc_active && ioc->alt_ioc) {
2248 /* (re)Enable alt-IOC! (reply interrupt) */
2249 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "alt_ioc reply irq re-enabled\n",
2250 ioc->alt_ioc->name));
2251 CHIPREG_WRITE32(&ioc->alt_ioc->chip->IntMask, MPI_HIM_DIM);
2252 ioc->alt_ioc->active = 1;
2253 }
2254
2255 /* Enable MPT base driver management of EventNotification
2256 * and EventAck handling.
2257 */
2258 if ((ret == 0) && (!ioc->facts.EventState))
2259 (void) SendEventNotification(ioc, 1); /* 1=Enable EventNotification */
2260
2261 if (ioc->alt_ioc && alt_ioc_ready && !ioc->alt_ioc->facts.EventState)
2262 (void) SendEventNotification(ioc->alt_ioc, 1); /* 1=Enable EventNotification */
2263
2264 /* Add additional "reason" check before call to GetLanConfigPages
2265 * (combined with GetIoUnitPage2 call). This prevents a somewhat
2266 * recursive scenario; GetLanConfigPages times out, timer expired
2267 * routine calls HardResetHandler, which calls into here again,
2268 * and we try GetLanConfigPages again...
2269 */
2270 if ((ret == 0) && (reason == MPT_HOSTEVENT_IOC_BRINGUP)) {
2271
2272 /*
2273 * Initalize link list for inactive raid volumes.
2274 */
2275 mutex_init(&ioc->raid_data.inactive_list_mutex);
2276 INIT_LIST_HEAD(&ioc->raid_data.inactive_list);
2277
2278 if (ioc->bus_type == SAS) {
2279
2280 /* clear persistency table */
2281 if(ioc->facts.IOCExceptions &
2282 MPI_IOCFACTS_EXCEPT_PERSISTENT_TABLE_FULL) {
2283 ret = mptbase_sas_persist_operation(ioc,
2284 MPI_SAS_OP_CLEAR_NOT_PRESENT);
2285 if(ret != 0)
2286 goto out;
2287 }
2288
2289 /* Find IM volumes
2290 */
2291 mpt_findImVolumes(ioc);
2292
2293 } else if (ioc->bus_type == FC) {
2294 if ((ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) &&
2295 (ioc->lan_cnfg_page0.Header.PageLength == 0)) {
2296 /*
2297 * Pre-fetch the ports LAN MAC address!
2298 * (LANPage1_t stuff)
2299 */
2300 (void) GetLanConfigPages(ioc);
2301 a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
2302 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2303 "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
2304 ioc->name, a[5], a[4], a[3], a[2], a[1], a[0]));
2305
2306 }
2307 } else {
2308 /* Get NVRAM and adapter maximums from SPP 0 and 2
2309 */
2310 mpt_GetScsiPortSettings(ioc, 0);
2311
2312 /* Get version and length of SDP 1
2313 */
2314 mpt_readScsiDevicePageHeaders(ioc, 0);
2315
2316 /* Find IM volumes
2317 */
2318 if (ioc->facts.MsgVersion >= MPI_VERSION_01_02)
2319 mpt_findImVolumes(ioc);
2320
2321 /* Check, and possibly reset, the coalescing value
2322 */
2323 mpt_read_ioc_pg_1(ioc);
2324
2325 mpt_read_ioc_pg_4(ioc);
2326 }
2327
2328 GetIoUnitPage2(ioc);
2329 mpt_get_manufacturing_pg_0(ioc);
2330 }
2331
2332 /*
2333 * Call each currently registered protocol IOC reset handler
2334 * with post-reset indication.
2335 * NOTE: If we're doing _IOC_BRINGUP, there can be no
2336 * MptResetHandlers[] registered yet.
2337 */
2338 if (hard_reset_done) {
2339 rc = handlers = 0;
2340 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
2341 if ((ret == 0) && MptResetHandlers[cb_idx]) {
2342 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2343 "Calling IOC post_reset handler #%d\n",
2344 ioc->name, cb_idx));
2345 rc += mpt_signal_reset(cb_idx, ioc, MPT_IOC_POST_RESET);
2346 handlers++;
2347 }
2348
2349 if (alt_ioc_ready && MptResetHandlers[cb_idx]) {
2350 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2351 "Calling IOC post_reset handler #%d\n",
2352 ioc->alt_ioc->name, cb_idx));
2353 rc += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_POST_RESET);
2354 handlers++;
2355 }
2356 }
2357 /* FIXME? Examine results here? */
2358 }
2359
2360 out:
2361 if ((ret != 0) && irq_allocated) {
2362 free_irq(ioc->pci_irq, ioc);
2363 if (ioc->msi_enable)
2364 pci_disable_msi(ioc->pcidev);
2365 }
2366 return ret;
2367 }
2368
2369 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2370 /**
2371 * mpt_detect_bound_ports - Search for matching PCI bus/dev_function
2372 * @ioc: Pointer to MPT adapter structure
2373 * @pdev: Pointer to (struct pci_dev) structure
2374 *
2375 * Search for PCI bus/dev_function which matches
2376 * PCI bus/dev_function (+/-1) for newly discovered 929,
2377 * 929X, 1030 or 1035.
2378 *
2379 * If match on PCI dev_function +/-1 is found, bind the two MPT adapters
2380 * using alt_ioc pointer fields in their %MPT_ADAPTER structures.
2381 */
2382 static void
2383 mpt_detect_bound_ports(MPT_ADAPTER *ioc, struct pci_dev *pdev)
2384 {
2385 struct pci_dev *peer=NULL;
2386 unsigned int slot = PCI_SLOT(pdev->devfn);
2387 unsigned int func = PCI_FUNC(pdev->devfn);
2388 MPT_ADAPTER *ioc_srch;
2389
2390 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PCI device %s devfn=%x/%x,"
2391 " searching for devfn match on %x or %x\n",
2392 ioc->name, pci_name(pdev), pdev->bus->number,
2393 pdev->devfn, func-1, func+1));
2394
2395 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func-1));
2396 if (!peer) {
2397 peer = pci_get_slot(pdev->bus, PCI_DEVFN(slot,func+1));
2398 if (!peer)
2399 return;
2400 }
2401
2402 list_for_each_entry(ioc_srch, &ioc_list, list) {
2403 struct pci_dev *_pcidev = ioc_srch->pcidev;
2404 if (_pcidev == peer) {
2405 /* Paranoia checks */
2406 if (ioc->alt_ioc != NULL) {
2407 printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
2408 ioc->name, ioc->alt_ioc->name);
2409 break;
2410 } else if (ioc_srch->alt_ioc != NULL) {
2411 printk(MYIOC_s_WARN_FMT "Oops, already bound to %s!\n",
2412 ioc_srch->name, ioc_srch->alt_ioc->name);
2413 break;
2414 }
2415 dprintk(ioc, printk(MYIOC_s_INFO_FMT "FOUND! binding to %s\n",
2416 ioc->name, ioc_srch->name));
2417 ioc_srch->alt_ioc = ioc;
2418 ioc->alt_ioc = ioc_srch;
2419 }
2420 }
2421 pci_dev_put(peer);
2422 }
2423
2424 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2425 /**
2426 * mpt_adapter_disable - Disable misbehaving MPT adapter.
2427 * @ioc: Pointer to MPT adapter structure
2428 */
2429 static void
2430 mpt_adapter_disable(MPT_ADAPTER *ioc)
2431 {
2432 int sz;
2433 int ret;
2434
2435 if (ioc->cached_fw != NULL) {
2436 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: Pushing FW onto "
2437 "adapter\n", __FUNCTION__, ioc->name));
2438 if ((ret = mpt_downloadboot(ioc, (MpiFwHeader_t *)
2439 ioc->cached_fw, CAN_SLEEP)) < 0) {
2440 printk(MYIOC_s_WARN_FMT
2441 ": firmware downloadboot failure (%d)!\n",
2442 ioc->name, ret);
2443 }
2444 }
2445
2446 /* Disable adapter interrupts! */
2447 CHIPREG_WRITE32(&ioc->chip->IntMask, 0xFFFFFFFF);
2448 ioc->active = 0;
2449 /* Clear any lingering interrupt */
2450 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
2451
2452 if (ioc->alloc != NULL) {
2453 sz = ioc->alloc_sz;
2454 dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "free @ %p, sz=%d bytes\n",
2455 ioc->name, ioc->alloc, ioc->alloc_sz));
2456 pci_free_consistent(ioc->pcidev, sz,
2457 ioc->alloc, ioc->alloc_dma);
2458 ioc->reply_frames = NULL;
2459 ioc->req_frames = NULL;
2460 ioc->alloc = NULL;
2461 ioc->alloc_total -= sz;
2462 }
2463
2464 if (ioc->sense_buf_pool != NULL) {
2465 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
2466 pci_free_consistent(ioc->pcidev, sz,
2467 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
2468 ioc->sense_buf_pool = NULL;
2469 ioc->alloc_total -= sz;
2470 }
2471
2472 if (ioc->events != NULL){
2473 sz = MPTCTL_EVENT_LOG_SIZE * sizeof(MPT_IOCTL_EVENTS);
2474 kfree(ioc->events);
2475 ioc->events = NULL;
2476 ioc->alloc_total -= sz;
2477 }
2478
2479 mpt_free_fw_memory(ioc);
2480
2481 kfree(ioc->spi_data.nvram);
2482 mpt_inactive_raid_list_free(ioc);
2483 kfree(ioc->raid_data.pIocPg2);
2484 kfree(ioc->raid_data.pIocPg3);
2485 ioc->spi_data.nvram = NULL;
2486 ioc->raid_data.pIocPg3 = NULL;
2487
2488 if (ioc->spi_data.pIocPg4 != NULL) {
2489 sz = ioc->spi_data.IocPg4Sz;
2490 pci_free_consistent(ioc->pcidev, sz,
2491 ioc->spi_data.pIocPg4,
2492 ioc->spi_data.IocPg4_dma);
2493 ioc->spi_data.pIocPg4 = NULL;
2494 ioc->alloc_total -= sz;
2495 }
2496
2497 if (ioc->ReqToChain != NULL) {
2498 kfree(ioc->ReqToChain);
2499 kfree(ioc->RequestNB);
2500 ioc->ReqToChain = NULL;
2501 }
2502
2503 kfree(ioc->ChainToChain);
2504 ioc->ChainToChain = NULL;
2505
2506 if (ioc->HostPageBuffer != NULL) {
2507 if((ret = mpt_host_page_access_control(ioc,
2508 MPI_DB_HPBAC_FREE_BUFFER, NO_SLEEP)) != 0) {
2509 printk(MYIOC_s_ERR_FMT
2510 "host page buffers free failed (%d)!\n",
2511 ioc->name, ret);
2512 }
2513 dexitprintk(ioc, printk(MYIOC_s_INFO_FMT "HostPageBuffer free @ %p, sz=%d bytes\n",
2514 ioc->name, ioc->HostPageBuffer, ioc->HostPageBuffer_sz));
2515 pci_free_consistent(ioc->pcidev, ioc->HostPageBuffer_sz,
2516 ioc->HostPageBuffer, ioc->HostPageBuffer_dma);
2517 ioc->HostPageBuffer = NULL;
2518 ioc->HostPageBuffer_sz = 0;
2519 ioc->alloc_total -= ioc->HostPageBuffer_sz;
2520 }
2521 }
2522
2523 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2524 /**
2525 * mpt_adapter_dispose - Free all resources associated with an MPT adapter
2526 * @ioc: Pointer to MPT adapter structure
2527 *
2528 * This routine unregisters h/w resources and frees all alloc'd memory
2529 * associated with a MPT adapter structure.
2530 */
2531 static void
2532 mpt_adapter_dispose(MPT_ADAPTER *ioc)
2533 {
2534 int sz_first, sz_last;
2535
2536 if (ioc == NULL)
2537 return;
2538
2539 sz_first = ioc->alloc_total;
2540
2541 mpt_adapter_disable(ioc);
2542
2543 if (ioc->pci_irq != -1) {
2544 free_irq(ioc->pci_irq, ioc);
2545 if (ioc->msi_enable)
2546 pci_disable_msi(ioc->pcidev);
2547 ioc->pci_irq = -1;
2548 }
2549
2550 if (ioc->memmap != NULL) {
2551 iounmap(ioc->memmap);
2552 ioc->memmap = NULL;
2553 }
2554
2555 pci_disable_device(ioc->pcidev);
2556 pci_release_selected_regions(ioc->pcidev, ioc->bars);
2557
2558 #if defined(CONFIG_MTRR) && 0
2559 if (ioc->mtrr_reg > 0) {
2560 mtrr_del(ioc->mtrr_reg, 0, 0);
2561 dprintk(ioc, printk(MYIOC_s_INFO_FMT "MTRR region de-registered\n", ioc->name));
2562 }
2563 #endif
2564
2565 /* Zap the adapter lookup ptr! */
2566 list_del(&ioc->list);
2567
2568 sz_last = ioc->alloc_total;
2569 dprintk(ioc, printk(MYIOC_s_INFO_FMT "free'd %d of %d bytes\n",
2570 ioc->name, sz_first-sz_last+(int)sizeof(*ioc), sz_first));
2571
2572 if (ioc->alt_ioc)
2573 ioc->alt_ioc->alt_ioc = NULL;
2574
2575 kfree(ioc);
2576 }
2577
2578 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2579 /**
2580 * MptDisplayIocCapabilities - Disply IOC's capabilities.
2581 * @ioc: Pointer to MPT adapter structure
2582 */
2583 static void
2584 MptDisplayIocCapabilities(MPT_ADAPTER *ioc)
2585 {
2586 int i = 0;
2587
2588 printk(KERN_INFO "%s: ", ioc->name);
2589 if (ioc->prod_name)
2590 printk("%s: ", ioc->prod_name);
2591 printk("Capabilities={");
2592
2593 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
2594 printk("Initiator");
2595 i++;
2596 }
2597
2598 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2599 printk("%sTarget", i ? "," : "");
2600 i++;
2601 }
2602
2603 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
2604 printk("%sLAN", i ? "," : "");
2605 i++;
2606 }
2607
2608 #if 0
2609 /*
2610 * This would probably evoke more questions than it's worth
2611 */
2612 if (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
2613 printk("%sLogBusAddr", i ? "," : "");
2614 i++;
2615 }
2616 #endif
2617
2618 printk("}\n");
2619 }
2620
2621 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2622 /**
2623 * MakeIocReady - Get IOC to a READY state, using KickStart if needed.
2624 * @ioc: Pointer to MPT_ADAPTER structure
2625 * @force: Force hard KickStart of IOC
2626 * @sleepFlag: Specifies whether the process can sleep
2627 *
2628 * Returns:
2629 * 1 - DIAG reset and READY
2630 * 0 - READY initially OR soft reset and READY
2631 * -1 - Any failure on KickStart
2632 * -2 - Msg Unit Reset Failed
2633 * -3 - IO Unit Reset Failed
2634 * -4 - IOC owned by a PEER
2635 */
2636 static int
2637 MakeIocReady(MPT_ADAPTER *ioc, int force, int sleepFlag)
2638 {
2639 u32 ioc_state;
2640 int statefault = 0;
2641 int cntdn;
2642 int hard_reset_done = 0;
2643 int r;
2644 int ii;
2645 int whoinit;
2646
2647 /* Get current [raw] IOC state */
2648 ioc_state = mpt_GetIocState(ioc, 0);
2649 dhsprintk(ioc, printk(MYIOC_s_INFO_FMT "MakeIocReady [raw] state=%08x\n", ioc->name, ioc_state));
2650
2651 /*
2652 * Check to see if IOC got left/stuck in doorbell handshake
2653 * grip of death. If so, hard reset the IOC.
2654 */
2655 if (ioc_state & MPI_DOORBELL_ACTIVE) {
2656 statefault = 1;
2657 printk(MYIOC_s_WARN_FMT "Unexpected doorbell active!\n",
2658 ioc->name);
2659 }
2660
2661 /* Is it already READY? */
2662 if (!statefault && (ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_READY)
2663 return 0;
2664
2665 /*
2666 * Check to see if IOC is in FAULT state.
2667 */
2668 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
2669 statefault = 2;
2670 printk(MYIOC_s_WARN_FMT "IOC is in FAULT state!!!\n",
2671 ioc->name);
2672 printk(MYIOC_s_WARN_FMT " FAULT code = %04xh\n",
2673 ioc->name, ioc_state & MPI_DOORBELL_DATA_MASK);
2674 }
2675
2676 /*
2677 * Hmmm... Did it get left operational?
2678 */
2679 if ((ioc_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_OPERATIONAL) {
2680 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOC operational unexpected\n",
2681 ioc->name));
2682
2683 /* Check WhoInit.
2684 * If PCI Peer, exit.
2685 * Else, if no fault conditions are present, issue a MessageUnitReset
2686 * Else, fall through to KickStart case
2687 */
2688 whoinit = (ioc_state & MPI_DOORBELL_WHO_INIT_MASK) >> MPI_DOORBELL_WHO_INIT_SHIFT;
2689 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT
2690 "whoinit 0x%x statefault %d force %d\n",
2691 ioc->name, whoinit, statefault, force));
2692 if (whoinit == MPI_WHOINIT_PCI_PEER)
2693 return -4;
2694 else {
2695 if ((statefault == 0 ) && (force == 0)) {
2696 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) == 0)
2697 return 0;
2698 }
2699 statefault = 3;
2700 }
2701 }
2702
2703 hard_reset_done = KickStart(ioc, statefault||force, sleepFlag);
2704 if (hard_reset_done < 0)
2705 return -1;
2706
2707 /*
2708 * Loop here waiting for IOC to come READY.
2709 */
2710 ii = 0;
2711 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 5; /* 5 seconds */
2712
2713 while ((ioc_state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
2714 if (ioc_state == MPI_IOC_STATE_OPERATIONAL) {
2715 /*
2716 * BIOS or previous driver load left IOC in OP state.
2717 * Reset messaging FIFOs.
2718 */
2719 if ((r = SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag)) != 0) {
2720 printk(MYIOC_s_ERR_FMT "IOC msg unit reset failed!\n", ioc->name);
2721 return -2;
2722 }
2723 } else if (ioc_state == MPI_IOC_STATE_RESET) {
2724 /*
2725 * Something is wrong. Try to get IOC back
2726 * to a known state.
2727 */
2728 if ((r = SendIocReset(ioc, MPI_FUNCTION_IO_UNIT_RESET, sleepFlag)) != 0) {
2729 printk(MYIOC_s_ERR_FMT "IO unit reset failed!\n", ioc->name);
2730 return -3;
2731 }
2732 }
2733
2734 ii++; cntdn--;
2735 if (!cntdn) {
2736 printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
2737 ioc->name, (int)((ii+5)/HZ));
2738 return -ETIME;
2739 }
2740
2741 if (sleepFlag == CAN_SLEEP) {
2742 msleep(1);
2743 } else {
2744 mdelay (1); /* 1 msec delay */
2745 }
2746
2747 }
2748
2749 if (statefault < 3) {
2750 printk(MYIOC_s_INFO_FMT "Recovered from %s\n",
2751 ioc->name,
2752 statefault==1 ? "stuck handshake" : "IOC FAULT");
2753 }
2754
2755 return hard_reset_done;
2756 }
2757
2758 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2759 /**
2760 * mpt_GetIocState - Get the current state of a MPT adapter.
2761 * @ioc: Pointer to MPT_ADAPTER structure
2762 * @cooked: Request raw or cooked IOC state
2763 *
2764 * Returns all IOC Doorbell register bits if cooked==0, else just the
2765 * Doorbell bits in MPI_IOC_STATE_MASK.
2766 */
2767 u32
2768 mpt_GetIocState(MPT_ADAPTER *ioc, int cooked)
2769 {
2770 u32 s, sc;
2771
2772 /* Get! */
2773 s = CHIPREG_READ32(&ioc->chip->Doorbell);
2774 sc = s & MPI_IOC_STATE_MASK;
2775
2776 /* Save! */
2777 ioc->last_state = sc;
2778
2779 return cooked ? sc : s;
2780 }
2781
2782 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2783 /**
2784 * GetIocFacts - Send IOCFacts request to MPT adapter.
2785 * @ioc: Pointer to MPT_ADAPTER structure
2786 * @sleepFlag: Specifies whether the process can sleep
2787 * @reason: If recovery, only update facts.
2788 *
2789 * Returns 0 for success, non-zero for failure.
2790 */
2791 static int
2792 GetIocFacts(MPT_ADAPTER *ioc, int sleepFlag, int reason)
2793 {
2794 IOCFacts_t get_facts;
2795 IOCFactsReply_t *facts;
2796 int r;
2797 int req_sz;
2798 int reply_sz;
2799 int sz;
2800 u32 status, vv;
2801 u8 shiftFactor=1;
2802
2803 /* IOC *must* NOT be in RESET state! */
2804 if (ioc->last_state == MPI_IOC_STATE_RESET) {
2805 printk(MYIOC_s_ERR_FMT "Can't get IOCFacts NOT READY! (%08x)\n",
2806 ioc->name, ioc->last_state );
2807 return -44;
2808 }
2809
2810 facts = &ioc->facts;
2811
2812 /* Destination (reply area)... */
2813 reply_sz = sizeof(*facts);
2814 memset(facts, 0, reply_sz);
2815
2816 /* Request area (get_facts on the stack right now!) */
2817 req_sz = sizeof(get_facts);
2818 memset(&get_facts, 0, req_sz);
2819
2820 get_facts.Function = MPI_FUNCTION_IOC_FACTS;
2821 /* Assert: All other get_facts fields are zero! */
2822
2823 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2824 "Sending get IocFacts request req_sz=%d reply_sz=%d\n",
2825 ioc->name, req_sz, reply_sz));
2826
2827 /* No non-zero fields in the get_facts request are greater than
2828 * 1 byte in size, so we can just fire it off as is.
2829 */
2830 r = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_facts,
2831 reply_sz, (u16*)facts, 5 /*seconds*/, sleepFlag);
2832 if (r != 0)
2833 return r;
2834
2835 /*
2836 * Now byte swap (GRRR) the necessary fields before any further
2837 * inspection of reply contents.
2838 *
2839 * But need to do some sanity checks on MsgLength (byte) field
2840 * to make sure we don't zero IOC's req_sz!
2841 */
2842 /* Did we get a valid reply? */
2843 if (facts->MsgLength > offsetof(IOCFactsReply_t, RequestFrameSize)/sizeof(u32)) {
2844 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2845 /*
2846 * If not been here, done that, save off first WhoInit value
2847 */
2848 if (ioc->FirstWhoInit == WHOINIT_UNKNOWN)
2849 ioc->FirstWhoInit = facts->WhoInit;
2850 }
2851
2852 facts->MsgVersion = le16_to_cpu(facts->MsgVersion);
2853 facts->MsgContext = le32_to_cpu(facts->MsgContext);
2854 facts->IOCExceptions = le16_to_cpu(facts->IOCExceptions);
2855 facts->IOCStatus = le16_to_cpu(facts->IOCStatus);
2856 facts->IOCLogInfo = le32_to_cpu(facts->IOCLogInfo);
2857 status = le16_to_cpu(facts->IOCStatus) & MPI_IOCSTATUS_MASK;
2858 /* CHECKME! IOCStatus, IOCLogInfo */
2859
2860 facts->ReplyQueueDepth = le16_to_cpu(facts->ReplyQueueDepth);
2861 facts->RequestFrameSize = le16_to_cpu(facts->RequestFrameSize);
2862
2863 /*
2864 * FC f/w version changed between 1.1 and 1.2
2865 * Old: u16{Major(4),Minor(4),SubMinor(8)}
2866 * New: u32{Major(8),Minor(8),Unit(8),Dev(8)}
2867 */
2868 if (facts->MsgVersion < 0x0102) {
2869 /*
2870 * Handle old FC f/w style, convert to new...
2871 */
2872 u16 oldv = le16_to_cpu(facts->Reserved_0101_FWVersion);
2873 facts->FWVersion.Word =
2874 ((oldv<<12) & 0xFF000000) |
2875 ((oldv<<8) & 0x000FFF00);
2876 } else
2877 facts->FWVersion.Word = le32_to_cpu(facts->FWVersion.Word);
2878
2879 facts->ProductID = le16_to_cpu(facts->ProductID);
2880 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
2881 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
2882 ioc->ir_firmware = 1;
2883 facts->CurrentHostMfaHighAddr =
2884 le32_to_cpu(facts->CurrentHostMfaHighAddr);
2885 facts->GlobalCredits = le16_to_cpu(facts->GlobalCredits);
2886 facts->CurrentSenseBufferHighAddr =
2887 le32_to_cpu(facts->CurrentSenseBufferHighAddr);
2888 facts->CurReplyFrameSize =
2889 le16_to_cpu(facts->CurReplyFrameSize);
2890 facts->IOCCapabilities = le32_to_cpu(facts->IOCCapabilities);
2891
2892 /*
2893 * Handle NEW (!) IOCFactsReply fields in MPI-1.01.xx
2894 * Older MPI-1.00.xx struct had 13 dwords, and enlarged
2895 * to 14 in MPI-1.01.0x.
2896 */
2897 if (facts->MsgLength >= (offsetof(IOCFactsReply_t,FWImageSize) + 7)/4 &&
2898 facts->MsgVersion > 0x0100) {
2899 facts->FWImageSize = le32_to_cpu(facts->FWImageSize);
2900 }
2901
2902 sz = facts->FWImageSize;
2903 if ( sz & 0x01 )
2904 sz += 1;
2905 if ( sz & 0x02 )
2906 sz += 2;
2907 facts->FWImageSize = sz;
2908
2909 if (!facts->RequestFrameSize) {
2910 /* Something is wrong! */
2911 printk(MYIOC_s_ERR_FMT "IOC reported invalid 0 request size!\n",
2912 ioc->name);
2913 return -55;
2914 }
2915
2916 r = sz = facts->BlockSize;
2917 vv = ((63 / (sz * 4)) + 1) & 0x03;
2918 ioc->NB_for_64_byte_frame = vv;
2919 while ( sz )
2920 {
2921 shiftFactor++;
2922 sz = sz >> 1;
2923 }
2924 ioc->NBShiftFactor = shiftFactor;
2925 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT
2926 "NB_for_64_byte_frame=%x NBShiftFactor=%x BlockSize=%x\n",
2927 ioc->name, vv, shiftFactor, r));
2928
2929 if (reason == MPT_HOSTEVENT_IOC_BRINGUP) {
2930 /*
2931 * Set values for this IOC's request & reply frame sizes,
2932 * and request & reply queue depths...
2933 */
2934 ioc->req_sz = min(MPT_DEFAULT_FRAME_SIZE, facts->RequestFrameSize * 4);
2935 ioc->req_depth = min_t(int, MPT_MAX_REQ_DEPTH, facts->GlobalCredits);
2936 ioc->reply_sz = MPT_REPLY_FRAME_SIZE;
2937 ioc->reply_depth = min_t(int, MPT_DEFAULT_REPLY_DEPTH, facts->ReplyQueueDepth);
2938
2939 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "reply_sz=%3d, reply_depth=%4d\n",
2940 ioc->name, ioc->reply_sz, ioc->reply_depth));
2941 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "req_sz =%3d, req_depth =%4d\n",
2942 ioc->name, ioc->req_sz, ioc->req_depth));
2943
2944 /* Get port facts! */
2945 if ( (r = GetPortFacts(ioc, 0, sleepFlag)) != 0 )
2946 return r;
2947 }
2948 } else {
2949 printk(MYIOC_s_ERR_FMT
2950 "Invalid IOC facts reply, msgLength=%d offsetof=%zd!\n",
2951 ioc->name, facts->MsgLength, (offsetof(IOCFactsReply_t,
2952 RequestFrameSize)/sizeof(u32)));
2953 return -66;
2954 }
2955
2956 return 0;
2957 }
2958
2959 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
2960 /**
2961 * GetPortFacts - Send PortFacts request to MPT adapter.
2962 * @ioc: Pointer to MPT_ADAPTER structure
2963 * @portnum: Port number
2964 * @sleepFlag: Specifies whether the process can sleep
2965 *
2966 * Returns 0 for success, non-zero for failure.
2967 */
2968 static int
2969 GetPortFacts(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
2970 {
2971 PortFacts_t get_pfacts;
2972 PortFactsReply_t *pfacts;
2973 int ii;
2974 int req_sz;
2975 int reply_sz;
2976 int max_id;
2977
2978 /* IOC *must* NOT be in RESET state! */
2979 if (ioc->last_state == MPI_IOC_STATE_RESET) {
2980 printk(MYIOC_s_ERR_FMT "Can't get PortFacts NOT READY! (%08x)\n",
2981 ioc->name, ioc->last_state );
2982 return -4;
2983 }
2984
2985 pfacts = &ioc->pfacts[portnum];
2986
2987 /* Destination (reply area)... */
2988 reply_sz = sizeof(*pfacts);
2989 memset(pfacts, 0, reply_sz);
2990
2991 /* Request area (get_pfacts on the stack right now!) */
2992 req_sz = sizeof(get_pfacts);
2993 memset(&get_pfacts, 0, req_sz);
2994
2995 get_pfacts.Function = MPI_FUNCTION_PORT_FACTS;
2996 get_pfacts.PortNumber = portnum;
2997 /* Assert: All other get_pfacts fields are zero! */
2998
2999 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending get PortFacts(%d) request\n",
3000 ioc->name, portnum));
3001
3002 /* No non-zero fields in the get_pfacts request are greater than
3003 * 1 byte in size, so we can just fire it off as is.
3004 */
3005 ii = mpt_handshake_req_reply_wait(ioc, req_sz, (u32*)&get_pfacts,
3006 reply_sz, (u16*)pfacts, 5 /*seconds*/, sleepFlag);
3007 if (ii != 0)
3008 return ii;
3009
3010 /* Did we get a valid reply? */
3011
3012 /* Now byte swap the necessary fields in the response. */
3013 pfacts->MsgContext = le32_to_cpu(pfacts->MsgContext);
3014 pfacts->IOCStatus = le16_to_cpu(pfacts->IOCStatus);
3015 pfacts->IOCLogInfo = le32_to_cpu(pfacts->IOCLogInfo);
3016 pfacts->MaxDevices = le16_to_cpu(pfacts->MaxDevices);
3017 pfacts->PortSCSIID = le16_to_cpu(pfacts->PortSCSIID);
3018 pfacts->ProtocolFlags = le16_to_cpu(pfacts->ProtocolFlags);
3019 pfacts->MaxPostedCmdBuffers = le16_to_cpu(pfacts->MaxPostedCmdBuffers);
3020 pfacts->MaxPersistentIDs = le16_to_cpu(pfacts->MaxPersistentIDs);
3021 pfacts->MaxLanBuckets = le16_to_cpu(pfacts->MaxLanBuckets);
3022
3023 max_id = (ioc->bus_type == SAS) ? pfacts->PortSCSIID :
3024 pfacts->MaxDevices;
3025 ioc->devices_per_bus = (max_id > 255) ? 256 : max_id;
3026 ioc->number_of_buses = (ioc->devices_per_bus < 256) ? 1 : max_id/256;
3027
3028 /*
3029 * Place all the devices on channels
3030 *
3031 * (for debuging)
3032 */
3033 if (mpt_channel_mapping) {
3034 ioc->devices_per_bus = 1;
3035 ioc->number_of_buses = (max_id > 255) ? 255 : max_id;
3036 }
3037
3038 return 0;
3039 }
3040
3041 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3042 /**
3043 * SendIocInit - Send IOCInit request to MPT adapter.
3044 * @ioc: Pointer to MPT_ADAPTER structure
3045 * @sleepFlag: Specifies whether the process can sleep
3046 *
3047 * Send IOCInit followed by PortEnable to bring IOC to OPERATIONAL state.
3048 *
3049 * Returns 0 for success, non-zero for failure.
3050 */
3051 static int
3052 SendIocInit(MPT_ADAPTER *ioc, int sleepFlag)
3053 {
3054 IOCInit_t ioc_init;
3055 MPIDefaultReply_t init_reply;
3056 u32 state;
3057 int r;
3058 int count;
3059 int cntdn;
3060
3061 memset(&ioc_init, 0, sizeof(ioc_init));
3062 memset(&init_reply, 0, sizeof(init_reply));
3063
3064 ioc_init.WhoInit = MPI_WHOINIT_HOST_DRIVER;
3065 ioc_init.Function = MPI_FUNCTION_IOC_INIT;
3066
3067 /* If we are in a recovery mode and we uploaded the FW image,
3068 * then this pointer is not NULL. Skip the upload a second time.
3069 * Set this flag if cached_fw set for either IOC.
3070 */
3071 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
3072 ioc->upload_fw = 1;
3073 else
3074 ioc->upload_fw = 0;
3075 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "upload_fw %d facts.Flags=%x\n",
3076 ioc->name, ioc->upload_fw, ioc->facts.Flags));
3077
3078 ioc_init.MaxDevices = (U8)ioc->devices_per_bus;
3079 ioc_init.MaxBuses = (U8)ioc->number_of_buses;
3080 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "facts.MsgVersion=%x\n",
3081 ioc->name, ioc->facts.MsgVersion));
3082 if (ioc->facts.MsgVersion >= MPI_VERSION_01_05) {
3083 // set MsgVersion and HeaderVersion host driver was built with
3084 ioc_init.MsgVersion = cpu_to_le16(MPI_VERSION);
3085 ioc_init.HeaderVersion = cpu_to_le16(MPI_HEADER_VERSION);
3086
3087 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_HOST_PAGE_BUFFER_PERSISTENT) {
3088 ioc_init.HostPageBufferSGE = ioc->facts.HostPageBufferSGE;
3089 } else if(mpt_host_page_alloc(ioc, &ioc_init))
3090 return -99;
3091 }
3092 ioc_init.ReplyFrameSize = cpu_to_le16(ioc->reply_sz); /* in BYTES */
3093
3094 if (sizeof(dma_addr_t) == sizeof(u64)) {
3095 /* Save the upper 32-bits of the request
3096 * (reply) and sense buffers.
3097 */
3098 ioc_init.HostMfaHighAddr = cpu_to_le32((u32)((u64)ioc->alloc_dma >> 32));
3099 ioc_init.SenseBufferHighAddr = cpu_to_le32((u32)((u64)ioc->sense_buf_pool_dma >> 32));
3100 } else {
3101 /* Force 32-bit addressing */
3102 ioc_init.HostMfaHighAddr = cpu_to_le32(0);
3103 ioc_init.SenseBufferHighAddr = cpu_to_le32(0);
3104 }
3105
3106 ioc->facts.CurrentHostMfaHighAddr = ioc_init.HostMfaHighAddr;
3107 ioc->facts.CurrentSenseBufferHighAddr = ioc_init.SenseBufferHighAddr;
3108 ioc->facts.MaxDevices = ioc_init.MaxDevices;
3109 ioc->facts.MaxBuses = ioc_init.MaxBuses;
3110
3111 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOCInit (req @ %p)\n",
3112 ioc->name, &ioc_init));
3113
3114 r = mpt_handshake_req_reply_wait(ioc, sizeof(IOCInit_t), (u32*)&ioc_init,
3115 sizeof(MPIDefaultReply_t), (u16*)&init_reply, 10 /*seconds*/, sleepFlag);
3116 if (r != 0) {
3117 printk(MYIOC_s_ERR_FMT "Sending IOCInit failed(%d)!\n",ioc->name, r);
3118 return r;
3119 }
3120
3121 /* No need to byte swap the multibyte fields in the reply
3122 * since we don't even look at its contents.
3123 */
3124
3125 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending PortEnable (req @ %p)\n",
3126 ioc->name, &ioc_init));
3127
3128 if ((r = SendPortEnable(ioc, 0, sleepFlag)) != 0) {
3129 printk(MYIOC_s_ERR_FMT "Sending PortEnable failed(%d)!\n",ioc->name, r);
3130 return r;
3131 }
3132
3133 /* YIKES! SUPER IMPORTANT!!!
3134 * Poll IocState until _OPERATIONAL while IOC is doing
3135 * LoopInit and TargetDiscovery!
3136 */
3137 count = 0;
3138 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 60; /* 60 seconds */
3139 state = mpt_GetIocState(ioc, 1);
3140 while (state != MPI_IOC_STATE_OPERATIONAL && --cntdn) {
3141 if (sleepFlag == CAN_SLEEP) {
3142 msleep(1);
3143 } else {
3144 mdelay(1);
3145 }
3146
3147 if (!cntdn) {
3148 printk(MYIOC_s_ERR_FMT "Wait IOC_OP state timeout(%d)!\n",
3149 ioc->name, (int)((count+5)/HZ));
3150 return -9;
3151 }
3152
3153 state = mpt_GetIocState(ioc, 1);
3154 count++;
3155 }
3156 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wait IOC_OPERATIONAL state (cnt=%d)\n",
3157 ioc->name, count));
3158
3159 ioc->aen_event_read_flag=0;
3160 return r;
3161 }
3162
3163 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3164 /**
3165 * SendPortEnable - Send PortEnable request to MPT adapter port.
3166 * @ioc: Pointer to MPT_ADAPTER structure
3167 * @portnum: Port number to enable
3168 * @sleepFlag: Specifies whether the process can sleep
3169 *
3170 * Send PortEnable to bring IOC to OPERATIONAL state.
3171 *
3172 * Returns 0 for success, non-zero for failure.
3173 */
3174 static int
3175 SendPortEnable(MPT_ADAPTER *ioc, int portnum, int sleepFlag)
3176 {
3177 PortEnable_t port_enable;
3178 MPIDefaultReply_t reply_buf;
3179 int rc;
3180 int req_sz;
3181 int reply_sz;
3182
3183 /* Destination... */
3184 reply_sz = sizeof(MPIDefaultReply_t);
3185 memset(&reply_buf, 0, reply_sz);
3186
3187 req_sz = sizeof(PortEnable_t);
3188 memset(&port_enable, 0, req_sz);
3189
3190 port_enable.Function = MPI_FUNCTION_PORT_ENABLE;
3191 port_enable.PortNumber = portnum;
3192 /* port_enable.ChainOffset = 0; */
3193 /* port_enable.MsgFlags = 0; */
3194 /* port_enable.MsgContext = 0; */
3195
3196 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Port(%d)Enable (req @ %p)\n",
3197 ioc->name, portnum, &port_enable));
3198
3199 /* RAID FW may take a long time to enable
3200 */
3201 if (ioc->ir_firmware || ioc->bus_type == SAS) {
3202 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
3203 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
3204 300 /*seconds*/, sleepFlag);
3205 } else {
3206 rc = mpt_handshake_req_reply_wait(ioc, req_sz,
3207 (u32*)&port_enable, reply_sz, (u16*)&reply_buf,
3208 30 /*seconds*/, sleepFlag);
3209 }
3210 return rc;
3211 }
3212
3213 /**
3214 * mpt_alloc_fw_memory - allocate firmware memory
3215 * @ioc: Pointer to MPT_ADAPTER structure
3216 * @size: total FW bytes
3217 *
3218 * If memory has already been allocated, the same (cached) value
3219 * is returned.
3220 *
3221 * Return 0 if successfull, or non-zero for failure
3222 **/
3223 int
3224 mpt_alloc_fw_memory(MPT_ADAPTER *ioc, int size)
3225 {
3226 int rc;
3227
3228 if (ioc->cached_fw) {
3229 rc = 0; /* use already allocated memory */
3230 goto out;
3231 }
3232 else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw) {
3233 ioc->cached_fw = ioc->alt_ioc->cached_fw; /* use alt_ioc's memory */
3234 ioc->cached_fw_dma = ioc->alt_ioc->cached_fw_dma;
3235 rc = 0;
3236 goto out;
3237 }
3238 ioc->cached_fw = pci_alloc_consistent(ioc->pcidev, size, &ioc->cached_fw_dma);
3239 if (!ioc->cached_fw) {
3240 printk(MYIOC_s_ERR_FMT "Unable to allocate memory for the cached firmware image!\n",
3241 ioc->name);
3242 rc = -1;
3243 } else {
3244 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "FW Image @ %p[%p], sz=%d[%x] bytes\n",
3245 ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, size, size));
3246 ioc->alloc_total += size;
3247 rc = 0;
3248 }
3249 out:
3250 return rc;
3251 }
3252
3253 /**
3254 * mpt_free_fw_memory - free firmware memory
3255 * @ioc: Pointer to MPT_ADAPTER structure
3256 *
3257 * If alt_img is NULL, delete from ioc structure.
3258 * Else, delete a secondary image in same format.
3259 **/
3260 void
3261 mpt_free_fw_memory(MPT_ADAPTER *ioc)
3262 {
3263 int sz;
3264
3265 if (!ioc->cached_fw)
3266 return;
3267
3268 sz = ioc->facts.FWImageSize;
3269 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "free_fw_memory: FW Image @ %p[%p], sz=%d[%x] bytes\n",
3270 ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3271 pci_free_consistent(ioc->pcidev, sz, ioc->cached_fw, ioc->cached_fw_dma);
3272 ioc->alloc_total -= sz;
3273 ioc->cached_fw = NULL;
3274 }
3275
3276 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3277 /**
3278 * mpt_do_upload - Construct and Send FWUpload request to MPT adapter port.
3279 * @ioc: Pointer to MPT_ADAPTER structure
3280 * @sleepFlag: Specifies whether the process can sleep
3281 *
3282 * Returns 0 for success, >0 for handshake failure
3283 * <0 for fw upload failure.
3284 *
3285 * Remark: If bound IOC and a successful FWUpload was performed
3286 * on the bound IOC, the second image is discarded
3287 * and memory is free'd. Both channels must upload to prevent
3288 * IOC from running in degraded mode.
3289 */
3290 static int
3291 mpt_do_upload(MPT_ADAPTER *ioc, int sleepFlag)
3292 {
3293 u8 reply[sizeof(FWUploadReply_t)];
3294 FWUpload_t *prequest;
3295 FWUploadReply_t *preply;
3296 FWUploadTCSGE_t *ptcsge;
3297 int sgeoffset;
3298 u32 flagsLength;
3299 int ii, sz, reply_sz;
3300 int cmdStatus;
3301
3302 /* If the image size is 0, we are done.
3303 */
3304 if ((sz = ioc->facts.FWImageSize) == 0)
3305 return 0;
3306
3307 if (mpt_alloc_fw_memory(ioc, ioc->facts.FWImageSize) != 0)
3308 return -ENOMEM;
3309
3310 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Image @ %p[%p], sz=%d[%x] bytes\n",
3311 ioc->name, ioc->cached_fw, (void *)(ulong)ioc->cached_fw_dma, sz, sz));
3312
3313 prequest = (sleepFlag == NO_SLEEP) ? kzalloc(ioc->req_sz, GFP_ATOMIC) :
3314 kzalloc(ioc->req_sz, GFP_KERNEL);
3315 if (!prequest) {
3316 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "fw upload failed "
3317 "while allocating memory \n", ioc->name));
3318 mpt_free_fw_memory(ioc);
3319 return -ENOMEM;
3320 }
3321
3322 preply = (FWUploadReply_t *)&reply;
3323
3324 reply_sz = sizeof(reply);
3325 memset(preply, 0, reply_sz);
3326
3327 prequest->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
3328 prequest->Function = MPI_FUNCTION_FW_UPLOAD;
3329
3330 ptcsge = (FWUploadTCSGE_t *) &prequest->SGL;
3331 ptcsge->DetailsLength = 12;
3332 ptcsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
3333 ptcsge->ImageSize = cpu_to_le32(sz);
3334 ptcsge++;
3335
3336 sgeoffset = sizeof(FWUpload_t) - sizeof(SGE_MPI_UNION) + sizeof(FWUploadTCSGE_t);
3337
3338 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ | sz;
3339 mpt_add_sge((char *)ptcsge, flagsLength, ioc->cached_fw_dma);
3340
3341 sgeoffset += sizeof(u32) + sizeof(dma_addr_t);
3342 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": Sending FW Upload (req @ %p) sgeoffset=%d \n",
3343 ioc->name, prequest, sgeoffset));
3344 DBG_DUMP_FW_REQUEST_FRAME(ioc, (u32 *)prequest);
3345
3346 ii = mpt_handshake_req_reply_wait(ioc, sgeoffset, (u32*)prequest,
3347 reply_sz, (u16*)preply, 65 /*seconds*/, sleepFlag);
3348
3349 dinitprintk(ioc, printk(MYIOC_s_INFO_FMT ": FW Upload completed rc=%x \n", ioc->name, ii));
3350
3351 cmdStatus = -EFAULT;
3352 if (ii == 0) {
3353 /* Handshake transfer was complete and successful.
3354 * Check the Reply Frame.
3355 */
3356 int status, transfer_sz;
3357 status = le16_to_cpu(preply->IOCStatus);
3358 if (status == MPI_IOCSTATUS_SUCCESS) {
3359 transfer_sz = le32_to_cpu(preply->ActualImageSize);
3360 if (transfer_sz == sz)
3361 cmdStatus = 0;
3362 }
3363 }
3364 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": do_upload cmdStatus=%d \n",
3365 ioc->name, cmdStatus));
3366
3367
3368 if (cmdStatus) {
3369
3370 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT ": fw upload failed, freeing image \n",
3371 ioc->name));
3372 mpt_free_fw_memory(ioc);
3373 }
3374 kfree(prequest);
3375
3376 return cmdStatus;
3377 }
3378
3379 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3380 /**
3381 * mpt_downloadboot - DownloadBoot code
3382 * @ioc: Pointer to MPT_ADAPTER structure
3383 * @pFwHeader: Pointer to firmware header info
3384 * @sleepFlag: Specifies whether the process can sleep
3385 *
3386 * FwDownloadBoot requires Programmed IO access.
3387 *
3388 * Returns 0 for success
3389 * -1 FW Image size is 0
3390 * -2 No valid cached_fw Pointer
3391 * <0 for fw upload failure.
3392 */
3393 static int
3394 mpt_downloadboot(MPT_ADAPTER *ioc, MpiFwHeader_t *pFwHeader, int sleepFlag)
3395 {
3396 MpiExtImageHeader_t *pExtImage;
3397 u32 fwSize;
3398 u32 diag0val;
3399 int count;
3400 u32 *ptrFw;
3401 u32 diagRwData;
3402 u32 nextImage;
3403 u32 load_addr;
3404 u32 ioc_state=0;
3405
3406 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot: fw size 0x%x (%d), FW Ptr %p\n",
3407 ioc->name, pFwHeader->ImageSize, pFwHeader->ImageSize, pFwHeader));
3408
3409 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3410 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3411 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3412 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3413 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3414 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3415
3416 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM));
3417
3418 /* wait 1 msec */
3419 if (sleepFlag == CAN_SLEEP) {
3420 msleep(1);
3421 } else {
3422 mdelay (1);
3423 }
3424
3425 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3426 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3427
3428 for (count = 0; count < 30; count ++) {
3429 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3430 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3431 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RESET_ADAPTER cleared, count=%d\n",
3432 ioc->name, count));
3433 break;
3434 }
3435 /* wait .1 sec */
3436 if (sleepFlag == CAN_SLEEP) {
3437 msleep (100);
3438 } else {
3439 mdelay (100);
3440 }
3441 }
3442
3443 if ( count == 30 ) {
3444 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot failed! "
3445 "Unable to get MPI_DIAG_DRWE mode, diag0val=%x\n",
3446 ioc->name, diag0val));
3447 return -3;
3448 }
3449
3450 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3451 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3452 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3453 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3454 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3455 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3456
3457 /* Set the DiagRwEn and Disable ARM bits */
3458 CHIPREG_WRITE32(&ioc->chip->Diagnostic, (MPI_DIAG_RW_ENABLE | MPI_DIAG_DISABLE_ARM));
3459
3460 fwSize = (pFwHeader->ImageSize + 3)/4;
3461 ptrFw = (u32 *) pFwHeader;
3462
3463 /* Write the LoadStartAddress to the DiagRw Address Register
3464 * using Programmed IO
3465 */
3466 if (ioc->errata_flag_1064)
3467 pci_enable_io_access(ioc->pcidev);
3468
3469 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->LoadStartAddress);
3470 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "LoadStart addr written 0x%x \n",
3471 ioc->name, pFwHeader->LoadStartAddress));
3472
3473 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write FW Image: 0x%x bytes @ %p\n",
3474 ioc->name, fwSize*4, ptrFw));
3475 while (fwSize--) {
3476 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3477 }
3478
3479 nextImage = pFwHeader->NextImageHeaderOffset;
3480 while (nextImage) {
3481 pExtImage = (MpiExtImageHeader_t *) ((char *)pFwHeader + nextImage);
3482
3483 load_addr = pExtImage->LoadStartAddress;
3484
3485 fwSize = (pExtImage->ImageSize + 3) >> 2;
3486 ptrFw = (u32 *)pExtImage;
3487
3488 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write Ext Image: 0x%x (%d) bytes @ %p load_addr=%x\n",
3489 ioc->name, fwSize*4, fwSize*4, ptrFw, load_addr));
3490 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, load_addr);
3491
3492 while (fwSize--) {
3493 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, *ptrFw++);
3494 }
3495 nextImage = pExtImage->NextImageHeaderOffset;
3496 }
3497
3498 /* Write the IopResetVectorRegAddr */
3499 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Addr=%x! \n", ioc->name, pFwHeader->IopResetRegAddr));
3500 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, pFwHeader->IopResetRegAddr);
3501
3502 /* Write the IopResetVectorValue */
3503 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Write IopResetVector Value=%x! \n", ioc->name, pFwHeader->IopResetVectorValue));
3504 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, pFwHeader->IopResetVectorValue);
3505
3506 /* Clear the internal flash bad bit - autoincrementing register,
3507 * so must do two writes.
3508 */
3509 if (ioc->bus_type == SPI) {
3510 /*
3511 * 1030 and 1035 H/W errata, workaround to access
3512 * the ClearFlashBadSignatureBit
3513 */
3514 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3515 diagRwData = CHIPREG_PIO_READ32(&ioc->pio_chip->DiagRwData);
3516 diagRwData |= 0x40000000;
3517 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwAddress, 0x3F000000);
3518 CHIPREG_PIO_WRITE32(&ioc->pio_chip->DiagRwData, diagRwData);
3519
3520 } else /* if((ioc->bus_type == SAS) || (ioc->bus_type == FC)) */ {
3521 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3522 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val |
3523 MPI_DIAG_CLEAR_FLASH_BAD_SIG);
3524
3525 /* wait 1 msec */
3526 if (sleepFlag == CAN_SLEEP) {
3527 msleep (1);
3528 } else {
3529 mdelay (1);
3530 }
3531 }
3532
3533 if (ioc->errata_flag_1064)
3534 pci_disable_io_access(ioc->pcidev);
3535
3536 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3537 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot diag0val=%x, "
3538 "turning off PREVENT_IOC_BOOT, DISABLE_ARM, RW_ENABLE\n",
3539 ioc->name, diag0val));
3540 diag0val &= ~(MPI_DIAG_PREVENT_IOC_BOOT | MPI_DIAG_DISABLE_ARM | MPI_DIAG_RW_ENABLE);
3541 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "downloadboot now diag0val=%x\n",
3542 ioc->name, diag0val));
3543 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3544
3545 /* Write 0xFF to reset the sequencer */
3546 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3547
3548 if (ioc->bus_type == SAS) {
3549 ioc_state = mpt_GetIocState(ioc, 0);
3550 if ( (GetIocFacts(ioc, sleepFlag,
3551 MPT_HOSTEVENT_IOC_BRINGUP)) != 0 ) {
3552 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT "GetIocFacts failed: IocState=%x\n",
3553 ioc->name, ioc_state));
3554 return -EFAULT;
3555 }
3556 }
3557
3558 for (count=0; count<HZ*20; count++) {
3559 if ((ioc_state = mpt_GetIocState(ioc, 0)) & MPI_IOC_STATE_READY) {
3560 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3561 "downloadboot successful! (count=%d) IocState=%x\n",
3562 ioc->name, count, ioc_state));
3563 if (ioc->bus_type == SAS) {
3564 return 0;
3565 }
3566 if ((SendIocInit(ioc, sleepFlag)) != 0) {
3567 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3568 "downloadboot: SendIocInit failed\n",
3569 ioc->name));
3570 return -EFAULT;
3571 }
3572 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3573 "downloadboot: SendIocInit successful\n",
3574 ioc->name));
3575 return 0;
3576 }
3577 if (sleepFlag == CAN_SLEEP) {
3578 msleep (10);
3579 } else {
3580 mdelay (10);
3581 }
3582 }
3583 ddlprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3584 "downloadboot failed! IocState=%x\n",ioc->name, ioc_state));
3585 return -EFAULT;
3586 }
3587
3588 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3589 /**
3590 * KickStart - Perform hard reset of MPT adapter.
3591 * @ioc: Pointer to MPT_ADAPTER structure
3592 * @force: Force hard reset
3593 * @sleepFlag: Specifies whether the process can sleep
3594 *
3595 * This routine places MPT adapter in diagnostic mode via the
3596 * WriteSequence register, and then performs a hard reset of adapter
3597 * via the Diagnostic register.
3598 *
3599 * Inputs: sleepflag - CAN_SLEEP (non-interrupt thread)
3600 * or NO_SLEEP (interrupt thread, use mdelay)
3601 * force - 1 if doorbell active, board fault state
3602 * board operational, IOC_RECOVERY or
3603 * IOC_BRINGUP and there is an alt_ioc.
3604 * 0 else
3605 *
3606 * Returns:
3607 * 1 - hard reset, READY
3608 * 0 - no reset due to History bit, READY
3609 * -1 - no reset due to History bit but not READY
3610 * OR reset but failed to come READY
3611 * -2 - no reset, could not enter DIAG mode
3612 * -3 - reset but bad FW bit
3613 */
3614 static int
3615 KickStart(MPT_ADAPTER *ioc, int force, int sleepFlag)
3616 {
3617 int hard_reset_done = 0;
3618 u32 ioc_state=0;
3619 int cnt,cntdn;
3620
3621 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStarting!\n", ioc->name));
3622 if (ioc->bus_type == SPI) {
3623 /* Always issue a Msg Unit Reset first. This will clear some
3624 * SCSI bus hang conditions.
3625 */
3626 SendIocReset(ioc, MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET, sleepFlag);
3627
3628 if (sleepFlag == CAN_SLEEP) {
3629 msleep (1000);
3630 } else {
3631 mdelay (1000);
3632 }
3633 }
3634
3635 hard_reset_done = mpt_diag_reset(ioc, force, sleepFlag);
3636 if (hard_reset_done < 0)
3637 return hard_reset_done;
3638
3639 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset successful!\n",
3640 ioc->name));
3641
3642 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 2; /* 2 seconds */
3643 for (cnt=0; cnt<cntdn; cnt++) {
3644 ioc_state = mpt_GetIocState(ioc, 1);
3645 if ((ioc_state == MPI_IOC_STATE_READY) || (ioc_state == MPI_IOC_STATE_OPERATIONAL)) {
3646 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "KickStart successful! (cnt=%d)\n",
3647 ioc->name, cnt));
3648 return hard_reset_done;
3649 }
3650 if (sleepFlag == CAN_SLEEP) {
3651 msleep (10);
3652 } else {
3653 mdelay (10);
3654 }
3655 }
3656
3657 dinitprintk(ioc, printk(MYIOC_s_ERR_FMT "Failed to come READY after reset! IocState=%x\n",
3658 ioc->name, mpt_GetIocState(ioc, 0)));
3659 return -1;
3660 }
3661
3662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3663 /**
3664 * mpt_diag_reset - Perform hard reset of the adapter.
3665 * @ioc: Pointer to MPT_ADAPTER structure
3666 * @ignore: Set if to honor and clear to ignore
3667 * the reset history bit
3668 * @sleepFlag: CAN_SLEEP if called in a non-interrupt thread,
3669 * else set to NO_SLEEP (use mdelay instead)
3670 *
3671 * This routine places the adapter in diagnostic mode via the
3672 * WriteSequence register and then performs a hard reset of adapter
3673 * via the Diagnostic register. Adapter should be in ready state
3674 * upon successful completion.
3675 *
3676 * Returns: 1 hard reset successful
3677 * 0 no reset performed because reset history bit set
3678 * -2 enabling diagnostic mode failed
3679 * -3 diagnostic reset failed
3680 */
3681 static int
3682 mpt_diag_reset(MPT_ADAPTER *ioc, int ignore, int sleepFlag)
3683 {
3684 u32 diag0val;
3685 u32 doorbell;
3686 int hard_reset_done = 0;
3687 int count = 0;
3688 u32 diag1val = 0;
3689 MpiFwHeader_t *cached_fw; /* Pointer to FW */
3690
3691 /* Clear any existing interrupts */
3692 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
3693
3694 if (ioc->pcidev->device == MPI_MANUFACTPAGE_DEVID_SAS1078) {
3695 drsprintk(ioc, printk(MYIOC_s_WARN_FMT "%s: Doorbell=%p; 1078 reset "
3696 "address=%p\n", ioc->name, __FUNCTION__,
3697 &ioc->chip->Doorbell, &ioc->chip->Reset_1078));
3698 CHIPREG_WRITE32(&ioc->chip->Reset_1078, 0x07);
3699 if (sleepFlag == CAN_SLEEP)
3700 msleep(1);
3701 else
3702 mdelay(1);
3703
3704 for (count = 0; count < 60; count ++) {
3705 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3706 doorbell &= MPI_IOC_STATE_MASK;
3707
3708 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3709 "looking for READY STATE: doorbell=%x"
3710 " count=%d\n",
3711 ioc->name, doorbell, count));
3712 if (doorbell == MPI_IOC_STATE_READY) {
3713 return 1;
3714 }
3715
3716 /* wait 1 sec */
3717 if (sleepFlag == CAN_SLEEP)
3718 msleep(1000);
3719 else
3720 mdelay(1000);
3721 }
3722 return -1;
3723 }
3724
3725 /* Use "Diagnostic reset" method! (only thing available!) */
3726 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3727
3728 if (ioc->debug_level & MPT_DEBUG) {
3729 if (ioc->alt_ioc)
3730 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3731 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG1: diag0=%08x, diag1=%08x\n",
3732 ioc->name, diag0val, diag1val));
3733 }
3734
3735 /* Do the reset if we are told to ignore the reset history
3736 * or if the reset history is 0
3737 */
3738 if (ignore || !(diag0val & MPI_DIAG_RESET_HISTORY)) {
3739 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3740 /* Write magic sequence to WriteSequence register
3741 * Loop until in diagnostic mode
3742 */
3743 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3744 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3745 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3746 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3747 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3748 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3749
3750 /* wait 100 msec */
3751 if (sleepFlag == CAN_SLEEP) {
3752 msleep (100);
3753 } else {
3754 mdelay (100);
3755 }
3756
3757 count++;
3758 if (count > 20) {
3759 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3760 ioc->name, diag0val);
3761 return -2;
3762
3763 }
3764
3765 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3766
3767 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Wrote magic DiagWriteEn sequence (%x)\n",
3768 ioc->name, diag0val));
3769 }
3770
3771 if (ioc->debug_level & MPT_DEBUG) {
3772 if (ioc->alt_ioc)
3773 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3774 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG2: diag0=%08x, diag1=%08x\n",
3775 ioc->name, diag0val, diag1val));
3776 }
3777 /*
3778 * Disable the ARM (Bug fix)
3779 *
3780 */
3781 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_DISABLE_ARM);
3782 mdelay(1);
3783
3784 /*
3785 * Now hit the reset bit in the Diagnostic register
3786 * (THE BIG HAMMER!) (Clears DRWE bit).
3787 */
3788 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val | MPI_DIAG_RESET_ADAPTER);
3789 hard_reset_done = 1;
3790 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Diagnostic reset performed\n",
3791 ioc->name));
3792
3793 /*
3794 * Call each currently registered protocol IOC reset handler
3795 * with pre-reset indication.
3796 * NOTE: If we're doing _IOC_BRINGUP, there can be no
3797 * MptResetHandlers[] registered yet.
3798 */
3799 {
3800 u8 cb_idx;
3801 int r = 0;
3802
3803 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
3804 if (MptResetHandlers[cb_idx]) {
3805 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3806 "Calling IOC pre_reset handler #%d\n",
3807 ioc->name, cb_idx));
3808 r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_PRE_RESET);
3809 if (ioc->alt_ioc) {
3810 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
3811 "Calling alt-%s pre_reset handler #%d\n",
3812 ioc->name, ioc->alt_ioc->name, cb_idx));
3813 r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_PRE_RESET);
3814 }
3815 }
3816 }
3817 /* FIXME? Examine results here? */
3818 }
3819
3820 if (ioc->cached_fw)
3821 cached_fw = (MpiFwHeader_t *)ioc->cached_fw;
3822 else if (ioc->alt_ioc && ioc->alt_ioc->cached_fw)
3823 cached_fw = (MpiFwHeader_t *)ioc->alt_ioc->cached_fw;
3824 else
3825 cached_fw = NULL;
3826 if (cached_fw) {
3827 /* If the DownloadBoot operation fails, the
3828 * IOC will be left unusable. This is a fatal error
3829 * case. _diag_reset will return < 0
3830 */
3831 for (count = 0; count < 30; count ++) {
3832 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3833 if (!(diag0val & MPI_DIAG_RESET_ADAPTER)) {
3834 break;
3835 }
3836
3837 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "cached_fw: diag0val=%x count=%d\n",
3838 ioc->name, diag0val, count));
3839 /* wait 1 sec */
3840 if (sleepFlag == CAN_SLEEP) {
3841 msleep (1000);
3842 } else {
3843 mdelay (1000);
3844 }
3845 }
3846 if ((count = mpt_downloadboot(ioc, cached_fw, sleepFlag)) < 0) {
3847 printk(MYIOC_s_WARN_FMT
3848 "firmware downloadboot failure (%d)!\n", ioc->name, count);
3849 }
3850
3851 } else {
3852 /* Wait for FW to reload and for board
3853 * to go to the READY state.
3854 * Maximum wait is 60 seconds.
3855 * If fail, no error will check again
3856 * with calling program.
3857 */
3858 for (count = 0; count < 60; count ++) {
3859 doorbell = CHIPREG_READ32(&ioc->chip->Doorbell);
3860 doorbell &= MPI_IOC_STATE_MASK;
3861
3862 if (doorbell == MPI_IOC_STATE_READY) {
3863 break;
3864 }
3865
3866 /* wait 1 sec */
3867 if (sleepFlag == CAN_SLEEP) {
3868 msleep (1000);
3869 } else {
3870 mdelay (1000);
3871 }
3872 }
3873 }
3874 }
3875
3876 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3877 if (ioc->debug_level & MPT_DEBUG) {
3878 if (ioc->alt_ioc)
3879 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3880 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG3: diag0=%08x, diag1=%08x\n",
3881 ioc->name, diag0val, diag1val));
3882 }
3883
3884 /* Clear RESET_HISTORY bit! Place board in the
3885 * diagnostic mode to update the diag register.
3886 */
3887 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3888 count = 0;
3889 while ((diag0val & MPI_DIAG_DRWE) == 0) {
3890 /* Write magic sequence to WriteSequence register
3891 * Loop until in diagnostic mode
3892 */
3893 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFF);
3894 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_1ST_KEY_VALUE);
3895 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_2ND_KEY_VALUE);
3896 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_3RD_KEY_VALUE);
3897 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_4TH_KEY_VALUE);
3898 CHIPREG_WRITE32(&ioc->chip->WriteSequence, MPI_WRSEQ_5TH_KEY_VALUE);
3899
3900 /* wait 100 msec */
3901 if (sleepFlag == CAN_SLEEP) {
3902 msleep (100);
3903 } else {
3904 mdelay (100);
3905 }
3906
3907 count++;
3908 if (count > 20) {
3909 printk(MYIOC_s_ERR_FMT "Enable Diagnostic mode FAILED! (%02xh)\n",
3910 ioc->name, diag0val);
3911 break;
3912 }
3913 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3914 }
3915 diag0val &= ~MPI_DIAG_RESET_HISTORY;
3916 CHIPREG_WRITE32(&ioc->chip->Diagnostic, diag0val);
3917 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3918 if (diag0val & MPI_DIAG_RESET_HISTORY) {
3919 printk(MYIOC_s_WARN_FMT "ResetHistory bit failed to clear!\n",
3920 ioc->name);
3921 }
3922
3923 /* Disable Diagnostic Mode
3924 */
3925 CHIPREG_WRITE32(&ioc->chip->WriteSequence, 0xFFFFFFFF);
3926
3927 /* Check FW reload status flags.
3928 */
3929 diag0val = CHIPREG_READ32(&ioc->chip->Diagnostic);
3930 if (diag0val & (MPI_DIAG_FLASH_BAD_SIG | MPI_DIAG_RESET_ADAPTER | MPI_DIAG_DISABLE_ARM)) {
3931 printk(MYIOC_s_ERR_FMT "Diagnostic reset FAILED! (%02xh)\n",
3932 ioc->name, diag0val);
3933 return -3;
3934 }
3935
3936 if (ioc->debug_level & MPT_DEBUG) {
3937 if (ioc->alt_ioc)
3938 diag1val = CHIPREG_READ32(&ioc->alt_ioc->chip->Diagnostic);
3939 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DbG4: diag0=%08x, diag1=%08x\n",
3940 ioc->name, diag0val, diag1val));
3941 }
3942
3943 /*
3944 * Reset flag that says we've enabled event notification
3945 */
3946 ioc->facts.EventState = 0;
3947
3948 if (ioc->alt_ioc)
3949 ioc->alt_ioc->facts.EventState = 0;
3950
3951 return hard_reset_done;
3952 }
3953
3954 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
3955 /**
3956 * SendIocReset - Send IOCReset request to MPT adapter.
3957 * @ioc: Pointer to MPT_ADAPTER structure
3958 * @reset_type: reset type, expected values are
3959 * %MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET or %MPI_FUNCTION_IO_UNIT_RESET
3960 * @sleepFlag: Specifies whether the process can sleep
3961 *
3962 * Send IOCReset request to the MPT adapter.
3963 *
3964 * Returns 0 for success, non-zero for failure.
3965 */
3966 static int
3967 SendIocReset(MPT_ADAPTER *ioc, u8 reset_type, int sleepFlag)
3968 {
3969 int r;
3970 u32 state;
3971 int cntdn, count;
3972
3973 drsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending IOC reset(0x%02x)!\n",
3974 ioc->name, reset_type));
3975 CHIPREG_WRITE32(&ioc->chip->Doorbell, reset_type<<MPI_DOORBELL_FUNCTION_SHIFT);
3976 if ((r = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
3977 return r;
3978
3979 /* FW ACK'd request, wait for READY state
3980 */
3981 count = 0;
3982 cntdn = ((sleepFlag == CAN_SLEEP) ? HZ : 1000) * 15; /* 15 seconds */
3983
3984 while ((state = mpt_GetIocState(ioc, 1)) != MPI_IOC_STATE_READY) {
3985 cntdn--;
3986 count++;
3987 if (!cntdn) {
3988 if (sleepFlag != CAN_SLEEP)
3989 count *= 10;
3990
3991 printk(MYIOC_s_ERR_FMT "Wait IOC_READY state timeout(%d)!\n",
3992 ioc->name, (int)((count+5)/HZ));
3993 return -ETIME;
3994 }
3995
3996 if (sleepFlag == CAN_SLEEP) {
3997 msleep(1);
3998 } else {
3999 mdelay (1); /* 1 msec delay */
4000 }
4001 }
4002
4003 /* TODO!
4004 * Cleanup all event stuff for this IOC; re-issue EventNotification
4005 * request if needed.
4006 */
4007 if (ioc->facts.Function)
4008 ioc->facts.EventState = 0;
4009
4010 return 0;
4011 }
4012
4013 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4014 /**
4015 * initChainBuffers - Allocate memory for and initialize chain buffers
4016 * @ioc: Pointer to MPT_ADAPTER structure
4017 *
4018 * Allocates memory for and initializes chain buffers,
4019 * chain buffer control arrays and spinlock.
4020 */
4021 static int
4022 initChainBuffers(MPT_ADAPTER *ioc)
4023 {
4024 u8 *mem;
4025 int sz, ii, num_chain;
4026 int scale, num_sge, numSGE;
4027
4028 /* ReqToChain size must equal the req_depth
4029 * index = req_idx
4030 */
4031 if (ioc->ReqToChain == NULL) {
4032 sz = ioc->req_depth * sizeof(int);
4033 mem = kmalloc(sz, GFP_ATOMIC);
4034 if (mem == NULL)
4035 return -1;
4036
4037 ioc->ReqToChain = (int *) mem;
4038 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReqToChain alloc @ %p, sz=%d bytes\n",
4039 ioc->name, mem, sz));
4040 mem = kmalloc(sz, GFP_ATOMIC);
4041 if (mem == NULL)
4042 return -1;
4043
4044 ioc->RequestNB = (int *) mem;
4045 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestNB alloc @ %p, sz=%d bytes\n",
4046 ioc->name, mem, sz));
4047 }
4048 for (ii = 0; ii < ioc->req_depth; ii++) {
4049 ioc->ReqToChain[ii] = MPT_HOST_NO_CHAIN;
4050 }
4051
4052 /* ChainToChain size must equal the total number
4053 * of chain buffers to be allocated.
4054 * index = chain_idx
4055 *
4056 * Calculate the number of chain buffers needed(plus 1) per I/O
4057 * then multiply the maximum number of simultaneous cmds
4058 *
4059 * num_sge = num sge in request frame + last chain buffer
4060 * scale = num sge per chain buffer if no chain element
4061 */
4062 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
4063 if (sizeof(dma_addr_t) == sizeof(u64))
4064 num_sge = scale + (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
4065 else
4066 num_sge = 1+ scale + (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
4067
4068 if (sizeof(dma_addr_t) == sizeof(u64)) {
4069 numSGE = (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
4070 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + sizeof(u32));
4071 } else {
4072 numSGE = 1 + (scale - 1) * (ioc->facts.MaxChainDepth-1) + scale +
4073 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + sizeof(u32));
4074 }
4075 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "num_sge=%d numSGE=%d\n",
4076 ioc->name, num_sge, numSGE));
4077
4078 if ( numSGE > MPT_SCSI_SG_DEPTH )
4079 numSGE = MPT_SCSI_SG_DEPTH;
4080
4081 num_chain = 1;
4082 while (numSGE - num_sge > 0) {
4083 num_chain++;
4084 num_sge += (scale - 1);
4085 }
4086 num_chain++;
4087
4088 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Now numSGE=%d num_sge=%d num_chain=%d\n",
4089 ioc->name, numSGE, num_sge, num_chain));
4090
4091 if (ioc->bus_type == SPI)
4092 num_chain *= MPT_SCSI_CAN_QUEUE;
4093 else
4094 num_chain *= MPT_FC_CAN_QUEUE;
4095
4096 ioc->num_chain = num_chain;
4097
4098 sz = num_chain * sizeof(int);
4099 if (ioc->ChainToChain == NULL) {
4100 mem = kmalloc(sz, GFP_ATOMIC);
4101 if (mem == NULL)
4102 return -1;
4103
4104 ioc->ChainToChain = (int *) mem;
4105 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainToChain alloc @ %p, sz=%d bytes\n",
4106 ioc->name, mem, sz));
4107 } else {
4108 mem = (u8 *) ioc->ChainToChain;
4109 }
4110 memset(mem, 0xFF, sz);
4111 return num_chain;
4112 }
4113
4114 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4115 /**
4116 * PrimeIocFifos - Initialize IOC request and reply FIFOs.
4117 * @ioc: Pointer to MPT_ADAPTER structure
4118 *
4119 * This routine allocates memory for the MPT reply and request frame
4120 * pools (if necessary), and primes the IOC reply FIFO with
4121 * reply frames.
4122 *
4123 * Returns 0 for success, non-zero for failure.
4124 */
4125 static int
4126 PrimeIocFifos(MPT_ADAPTER *ioc)
4127 {
4128 MPT_FRAME_HDR *mf;
4129 unsigned long flags;
4130 dma_addr_t alloc_dma;
4131 u8 *mem;
4132 int i, reply_sz, sz, total_size, num_chain;
4133
4134 /* Prime reply FIFO... */
4135
4136 if (ioc->reply_frames == NULL) {
4137 if ( (num_chain = initChainBuffers(ioc)) < 0)
4138 return -1;
4139
4140 total_size = reply_sz = (ioc->reply_sz * ioc->reply_depth);
4141 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d bytes, ReplyDepth=%d\n",
4142 ioc->name, ioc->reply_sz, ioc->reply_depth));
4143 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffer sz=%d[%x] bytes\n",
4144 ioc->name, reply_sz, reply_sz));
4145
4146 sz = (ioc->req_sz * ioc->req_depth);
4147 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d bytes, RequestDepth=%d\n",
4148 ioc->name, ioc->req_sz, ioc->req_depth));
4149 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffer sz=%d[%x] bytes\n",
4150 ioc->name, sz, sz));
4151 total_size += sz;
4152
4153 sz = num_chain * ioc->req_sz; /* chain buffer pool size */
4154 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d bytes, ChainDepth=%d\n",
4155 ioc->name, ioc->req_sz, num_chain));
4156 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffer sz=%d[%x] bytes num_chain=%d\n",
4157 ioc->name, sz, sz, num_chain));
4158
4159 total_size += sz;
4160 mem = pci_alloc_consistent(ioc->pcidev, total_size, &alloc_dma);
4161 if (mem == NULL) {
4162 printk(MYIOC_s_ERR_FMT "Unable to allocate Reply, Request, Chain Buffers!\n",
4163 ioc->name);
4164 goto out_fail;
4165 }
4166
4167 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Total alloc @ %p[%p], sz=%d[%x] bytes\n",
4168 ioc->name, mem, (void *)(ulong)alloc_dma, total_size, total_size));
4169
4170 memset(mem, 0, total_size);
4171 ioc->alloc_total += total_size;
4172 ioc->alloc = mem;
4173 ioc->alloc_dma = alloc_dma;
4174 ioc->alloc_sz = total_size;
4175 ioc->reply_frames = (MPT_FRAME_HDR *) mem;
4176 ioc->reply_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
4177
4178 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
4179 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
4180
4181 alloc_dma += reply_sz;
4182 mem += reply_sz;
4183
4184 /* Request FIFO - WE manage this! */
4185
4186 ioc->req_frames = (MPT_FRAME_HDR *) mem;
4187 ioc->req_frames_dma = alloc_dma;
4188
4189 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RequestBuffers @ %p[%p]\n",
4190 ioc->name, mem, (void *)(ulong)alloc_dma));
4191
4192 ioc->req_frames_low_dma = (u32) (alloc_dma & 0xFFFFFFFF);
4193
4194 #if defined(CONFIG_MTRR) && 0
4195 /*
4196 * Enable Write Combining MTRR for IOC's memory region.
4197 * (at least as much as we can; "size and base must be
4198 * multiples of 4 kiB"
4199 */
4200 ioc->mtrr_reg = mtrr_add(ioc->req_frames_dma,
4201 sz,
4202 MTRR_TYPE_WRCOMB, 1);
4203 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MTRR region registered (base:size=%08x:%x)\n",
4204 ioc->name, ioc->req_frames_dma, sz));
4205 #endif
4206
4207 for (i = 0; i < ioc->req_depth; i++) {
4208 alloc_dma += ioc->req_sz;
4209 mem += ioc->req_sz;
4210 }
4211
4212 ioc->ChainBuffer = mem;
4213 ioc->ChainBufferDMA = alloc_dma;
4214
4215 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ChainBuffers @ %p(%p)\n",
4216 ioc->name, ioc->ChainBuffer, (void *)(ulong)ioc->ChainBufferDMA));
4217
4218 /* Initialize the free chain Q.
4219 */
4220
4221 INIT_LIST_HEAD(&ioc->FreeChainQ);
4222
4223 /* Post the chain buffers to the FreeChainQ.
4224 */
4225 mem = (u8 *)ioc->ChainBuffer;
4226 for (i=0; i < num_chain; i++) {
4227 mf = (MPT_FRAME_HDR *) mem;
4228 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeChainQ);
4229 mem += ioc->req_sz;
4230 }
4231
4232 /* Initialize Request frames linked list
4233 */
4234 alloc_dma = ioc->req_frames_dma;
4235 mem = (u8 *) ioc->req_frames;
4236
4237 spin_lock_irqsave(&ioc->FreeQlock, flags);
4238 INIT_LIST_HEAD(&ioc->FreeQ);
4239 for (i = 0; i < ioc->req_depth; i++) {
4240 mf = (MPT_FRAME_HDR *) mem;
4241
4242 /* Queue REQUESTs *internally*! */
4243 list_add_tail(&mf->u.frame.linkage.list, &ioc->FreeQ);
4244
4245 mem += ioc->req_sz;
4246 }
4247 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
4248
4249 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
4250 ioc->sense_buf_pool =
4251 pci_alloc_consistent(ioc->pcidev, sz, &ioc->sense_buf_pool_dma);
4252 if (ioc->sense_buf_pool == NULL) {
4253 printk(MYIOC_s_ERR_FMT "Unable to allocate Sense Buffers!\n",
4254 ioc->name);
4255 goto out_fail;
4256 }
4257
4258 ioc->sense_buf_low_dma = (u32) (ioc->sense_buf_pool_dma & 0xFFFFFFFF);
4259 ioc->alloc_total += sz;
4260 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SenseBuffers @ %p[%p]\n",
4261 ioc->name, ioc->sense_buf_pool, (void *)(ulong)ioc->sense_buf_pool_dma));
4262
4263 }
4264
4265 /* Post Reply frames to FIFO
4266 */
4267 alloc_dma = ioc->alloc_dma;
4268 dinitprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ReplyBuffers @ %p[%p]\n",
4269 ioc->name, ioc->reply_frames, (void *)(ulong)alloc_dma));
4270
4271 for (i = 0; i < ioc->reply_depth; i++) {
4272 /* Write each address to the IOC! */
4273 CHIPREG_WRITE32(&ioc->chip->ReplyFifo, alloc_dma);
4274 alloc_dma += ioc->reply_sz;
4275 }
4276
4277 return 0;
4278
4279 out_fail:
4280 if (ioc->alloc != NULL) {
4281 sz = ioc->alloc_sz;
4282 pci_free_consistent(ioc->pcidev,
4283 sz,
4284 ioc->alloc, ioc->alloc_dma);
4285 ioc->reply_frames = NULL;
4286 ioc->req_frames = NULL;
4287 ioc->alloc_total -= sz;
4288 }
4289 if (ioc->sense_buf_pool != NULL) {
4290 sz = (ioc->req_depth * MPT_SENSE_BUFFER_ALLOC);
4291 pci_free_consistent(ioc->pcidev,
4292 sz,
4293 ioc->sense_buf_pool, ioc->sense_buf_pool_dma);
4294 ioc->sense_buf_pool = NULL;
4295 }
4296 return -1;
4297 }
4298
4299 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4300 /**
4301 * mpt_handshake_req_reply_wait - Send MPT request to and receive reply
4302 * from IOC via doorbell handshake method.
4303 * @ioc: Pointer to MPT_ADAPTER structure
4304 * @reqBytes: Size of the request in bytes
4305 * @req: Pointer to MPT request frame
4306 * @replyBytes: Expected size of the reply in bytes
4307 * @u16reply: Pointer to area where reply should be written
4308 * @maxwait: Max wait time for a reply (in seconds)
4309 * @sleepFlag: Specifies whether the process can sleep
4310 *
4311 * NOTES: It is the callers responsibility to byte-swap fields in the
4312 * request which are greater than 1 byte in size. It is also the
4313 * callers responsibility to byte-swap response fields which are
4314 * greater than 1 byte in size.
4315 *
4316 * Returns 0 for success, non-zero for failure.
4317 */
4318 static int
4319 mpt_handshake_req_reply_wait(MPT_ADAPTER *ioc, int reqBytes, u32 *req,
4320 int replyBytes, u16 *u16reply, int maxwait, int sleepFlag)
4321 {
4322 MPIDefaultReply_t *mptReply;
4323 int failcnt = 0;
4324 int t;
4325
4326 /*
4327 * Get ready to cache a handshake reply
4328 */
4329 ioc->hs_reply_idx = 0;
4330 mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4331 mptReply->MsgLength = 0;
4332
4333 /*
4334 * Make sure there are no doorbells (WRITE 0 to IntStatus reg),
4335 * then tell IOC that we want to handshake a request of N words.
4336 * (WRITE u32val to Doorbell reg).
4337 */
4338 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4339 CHIPREG_WRITE32(&ioc->chip->Doorbell,
4340 ((MPI_FUNCTION_HANDSHAKE<<MPI_DOORBELL_FUNCTION_SHIFT) |
4341 ((reqBytes/4)<<MPI_DOORBELL_ADD_DWORDS_SHIFT)));
4342
4343 /*
4344 * Wait for IOC's doorbell handshake int
4345 */
4346 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4347 failcnt++;
4348
4349 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request start reqBytes=%d, WaitCnt=%d%s\n",
4350 ioc->name, reqBytes, t, failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4351
4352 /* Read doorbell and check for active bit */
4353 if (!(CHIPREG_READ32(&ioc->chip->Doorbell) & MPI_DOORBELL_ACTIVE))
4354 return -1;
4355
4356 /*
4357 * Clear doorbell int (WRITE 0 to IntStatus reg),
4358 * then wait for IOC to ACKnowledge that it's ready for
4359 * our handshake request.
4360 */
4361 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4362 if (!failcnt && (t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4363 failcnt++;
4364
4365 if (!failcnt) {
4366 int ii;
4367 u8 *req_as_bytes = (u8 *) req;
4368
4369 /*
4370 * Stuff request words via doorbell handshake,
4371 * with ACK from IOC for each.
4372 */
4373 for (ii = 0; !failcnt && ii < reqBytes/4; ii++) {
4374 u32 word = ((req_as_bytes[(ii*4) + 0] << 0) |
4375 (req_as_bytes[(ii*4) + 1] << 8) |
4376 (req_as_bytes[(ii*4) + 2] << 16) |
4377 (req_as_bytes[(ii*4) + 3] << 24));
4378
4379 CHIPREG_WRITE32(&ioc->chip->Doorbell, word);
4380 if ((t = WaitForDoorbellAck(ioc, 5, sleepFlag)) < 0)
4381 failcnt++;
4382 }
4383
4384 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handshake request frame (@%p) header\n", ioc->name, req));
4385 DBG_DUMP_REQUEST_FRAME_HDR(ioc, (u32 *)req);
4386
4387 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake request post done, WaitCnt=%d%s\n",
4388 ioc->name, t, failcnt ? " - MISSING DOORBELL ACK!" : ""));
4389
4390 /*
4391 * Wait for completion of doorbell handshake reply from the IOC
4392 */
4393 if (!failcnt && (t = WaitForDoorbellReply(ioc, maxwait, sleepFlag)) < 0)
4394 failcnt++;
4395
4396 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HandShake reply count=%d%s\n",
4397 ioc->name, t, failcnt ? " - MISSING DOORBELL REPLY!" : ""));
4398
4399 /*
4400 * Copy out the cached reply...
4401 */
4402 for (ii=0; ii < min(replyBytes/2,mptReply->MsgLength*2); ii++)
4403 u16reply[ii] = ioc->hs_reply[ii];
4404 } else {
4405 return -99;
4406 }
4407
4408 return -failcnt;
4409 }
4410
4411 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4412 /**
4413 * WaitForDoorbellAck - Wait for IOC doorbell handshake acknowledge
4414 * @ioc: Pointer to MPT_ADAPTER structure
4415 * @howlong: How long to wait (in seconds)
4416 * @sleepFlag: Specifies whether the process can sleep
4417 *
4418 * This routine waits (up to ~2 seconds max) for IOC doorbell
4419 * handshake ACKnowledge, indicated by the IOP_DOORBELL_STATUS
4420 * bit in its IntStatus register being clear.
4421 *
4422 * Returns a negative value on failure, else wait loop count.
4423 */
4424 static int
4425 WaitForDoorbellAck(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4426 {
4427 int cntdn;
4428 int count = 0;
4429 u32 intstat=0;
4430
4431 cntdn = 1000 * howlong;
4432
4433 if (sleepFlag == CAN_SLEEP) {
4434 while (--cntdn) {
4435 msleep (1);
4436 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4437 if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
4438 break;
4439 count++;
4440 }
4441 } else {
4442 while (--cntdn) {
4443 udelay (1000);
4444 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4445 if (! (intstat & MPI_HIS_IOP_DOORBELL_STATUS))
4446 break;
4447 count++;
4448 }
4449 }
4450
4451 if (cntdn) {
4452 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell ACK (count=%d)\n",
4453 ioc->name, count));
4454 return count;
4455 }
4456
4457 printk(MYIOC_s_ERR_FMT "Doorbell ACK timeout (count=%d), IntStatus=%x!\n",
4458 ioc->name, count, intstat);
4459 return -1;
4460 }
4461
4462 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4463 /**
4464 * WaitForDoorbellInt - Wait for IOC to set its doorbell interrupt bit
4465 * @ioc: Pointer to MPT_ADAPTER structure
4466 * @howlong: How long to wait (in seconds)
4467 * @sleepFlag: Specifies whether the process can sleep
4468 *
4469 * This routine waits (up to ~2 seconds max) for IOC doorbell interrupt
4470 * (MPI_HIS_DOORBELL_INTERRUPT) to be set in the IntStatus register.
4471 *
4472 * Returns a negative value on failure, else wait loop count.
4473 */
4474 static int
4475 WaitForDoorbellInt(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4476 {
4477 int cntdn;
4478 int count = 0;
4479 u32 intstat=0;
4480
4481 cntdn = 1000 * howlong;
4482 if (sleepFlag == CAN_SLEEP) {
4483 while (--cntdn) {
4484 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4485 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4486 break;
4487 msleep(1);
4488 count++;
4489 }
4490 } else {
4491 while (--cntdn) {
4492 intstat = CHIPREG_READ32(&ioc->chip->IntStatus);
4493 if (intstat & MPI_HIS_DOORBELL_INTERRUPT)
4494 break;
4495 udelay (1000);
4496 count++;
4497 }
4498 }
4499
4500 if (cntdn) {
4501 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell INT (cnt=%d) howlong=%d\n",
4502 ioc->name, count, howlong));
4503 return count;
4504 }
4505
4506 printk(MYIOC_s_ERR_FMT "Doorbell INT timeout (count=%d), IntStatus=%x!\n",
4507 ioc->name, count, intstat);
4508 return -1;
4509 }
4510
4511 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4512 /**
4513 * WaitForDoorbellReply - Wait for and capture an IOC handshake reply.
4514 * @ioc: Pointer to MPT_ADAPTER structure
4515 * @howlong: How long to wait (in seconds)
4516 * @sleepFlag: Specifies whether the process can sleep
4517 *
4518 * This routine polls the IOC for a handshake reply, 16 bits at a time.
4519 * Reply is cached to IOC private area large enough to hold a maximum
4520 * of 128 bytes of reply data.
4521 *
4522 * Returns a negative value on failure, else size of reply in WORDS.
4523 */
4524 static int
4525 WaitForDoorbellReply(MPT_ADAPTER *ioc, int howlong, int sleepFlag)
4526 {
4527 int u16cnt = 0;
4528 int failcnt = 0;
4529 int t;
4530 u16 *hs_reply = ioc->hs_reply;
4531 volatile MPIDefaultReply_t *mptReply = (MPIDefaultReply_t *) ioc->hs_reply;
4532 u16 hword;
4533
4534 hs_reply[0] = hs_reply[1] = hs_reply[7] = 0;
4535
4536 /*
4537 * Get first two u16's so we can look at IOC's intended reply MsgLength
4538 */
4539 u16cnt=0;
4540 if ((t = WaitForDoorbellInt(ioc, howlong, sleepFlag)) < 0) {
4541 failcnt++;
4542 } else {
4543 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4544 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4545 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4546 failcnt++;
4547 else {
4548 hs_reply[u16cnt++] = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4549 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4550 }
4551 }
4552
4553 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitCnt=%d First handshake reply word=%08x%s\n",
4554 ioc->name, t, le32_to_cpu(*(u32 *)hs_reply),
4555 failcnt ? " - MISSING DOORBELL HANDSHAKE!" : ""));
4556
4557 /*
4558 * If no error (and IOC said MsgLength is > 0), piece together
4559 * reply 16 bits at a time.
4560 */
4561 for (u16cnt=2; !failcnt && u16cnt < (2 * mptReply->MsgLength); u16cnt++) {
4562 if ((t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4563 failcnt++;
4564 hword = le16_to_cpu(CHIPREG_READ32(&ioc->chip->Doorbell) & 0x0000FFFF);
4565 /* don't overflow our IOC hs_reply[] buffer! */
4566 if (u16cnt < sizeof(ioc->hs_reply) / sizeof(ioc->hs_reply[0]))
4567 hs_reply[u16cnt] = hword;
4568 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4569 }
4570
4571 if (!failcnt && (t = WaitForDoorbellInt(ioc, 5, sleepFlag)) < 0)
4572 failcnt++;
4573 CHIPREG_WRITE32(&ioc->chip->IntStatus, 0);
4574
4575 if (failcnt) {
4576 printk(MYIOC_s_ERR_FMT "Handshake reply failure!\n",
4577 ioc->name);
4578 return -failcnt;
4579 }
4580 #if 0
4581 else if (u16cnt != (2 * mptReply->MsgLength)) {
4582 return -101;
4583 }
4584 else if ((mptReply->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
4585 return -102;
4586 }
4587 #endif
4588
4589 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Got Handshake reply:\n", ioc->name));
4590 DBG_DUMP_REPLY_FRAME(ioc, (u32 *)mptReply);
4591
4592 dhsprintk(ioc, printk(MYIOC_s_DEBUG_FMT "WaitForDoorbell REPLY WaitCnt=%d (sz=%d)\n",
4593 ioc->name, t, u16cnt/2));
4594 return u16cnt/2;
4595 }
4596
4597 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4598 /**
4599 * GetLanConfigPages - Fetch LANConfig pages.
4600 * @ioc: Pointer to MPT_ADAPTER structure
4601 *
4602 * Return: 0 for success
4603 * -ENOMEM if no memory available
4604 * -EPERM if not allowed due to ISR context
4605 * -EAGAIN if no msg frames currently available
4606 * -EFAULT for non-successful reply or no reply (timeout)
4607 */
4608 static int
4609 GetLanConfigPages(MPT_ADAPTER *ioc)
4610 {
4611 ConfigPageHeader_t hdr;
4612 CONFIGPARMS cfg;
4613 LANPage0_t *ppage0_alloc;
4614 dma_addr_t page0_dma;
4615 LANPage1_t *ppage1_alloc;
4616 dma_addr_t page1_dma;
4617 int rc = 0;
4618 int data_sz;
4619 int copy_sz;
4620
4621 /* Get LAN Page 0 header */
4622 hdr.PageVersion = 0;
4623 hdr.PageLength = 0;
4624 hdr.PageNumber = 0;
4625 hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4626 cfg.cfghdr.hdr = &hdr;
4627 cfg.physAddr = -1;
4628 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4629 cfg.dir = 0;
4630 cfg.pageAddr = 0;
4631 cfg.timeout = 0;
4632
4633 if ((rc = mpt_config(ioc, &cfg)) != 0)
4634 return rc;
4635
4636 if (hdr.PageLength > 0) {
4637 data_sz = hdr.PageLength * 4;
4638 ppage0_alloc = (LANPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
4639 rc = -ENOMEM;
4640 if (ppage0_alloc) {
4641 memset((u8 *)ppage0_alloc, 0, data_sz);
4642 cfg.physAddr = page0_dma;
4643 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4644
4645 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4646 /* save the data */
4647 copy_sz = min_t(int, sizeof(LANPage0_t), data_sz);
4648 memcpy(&ioc->lan_cnfg_page0, ppage0_alloc, copy_sz);
4649
4650 }
4651
4652 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
4653
4654 /* FIXME!
4655 * Normalize endianness of structure data,
4656 * by byte-swapping all > 1 byte fields!
4657 */
4658
4659 }
4660
4661 if (rc)
4662 return rc;
4663 }
4664
4665 /* Get LAN Page 1 header */
4666 hdr.PageVersion = 0;
4667 hdr.PageLength = 0;
4668 hdr.PageNumber = 1;
4669 hdr.PageType = MPI_CONFIG_PAGETYPE_LAN;
4670 cfg.cfghdr.hdr = &hdr;
4671 cfg.physAddr = -1;
4672 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4673 cfg.dir = 0;
4674 cfg.pageAddr = 0;
4675
4676 if ((rc = mpt_config(ioc, &cfg)) != 0)
4677 return rc;
4678
4679 if (hdr.PageLength == 0)
4680 return 0;
4681
4682 data_sz = hdr.PageLength * 4;
4683 rc = -ENOMEM;
4684 ppage1_alloc = (LANPage1_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page1_dma);
4685 if (ppage1_alloc) {
4686 memset((u8 *)ppage1_alloc, 0, data_sz);
4687 cfg.physAddr = page1_dma;
4688 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4689
4690 if ((rc = mpt_config(ioc, &cfg)) == 0) {
4691 /* save the data */
4692 copy_sz = min_t(int, sizeof(LANPage1_t), data_sz);
4693 memcpy(&ioc->lan_cnfg_page1, ppage1_alloc, copy_sz);
4694 }
4695
4696 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage1_alloc, page1_dma);
4697
4698 /* FIXME!
4699 * Normalize endianness of structure data,
4700 * by byte-swapping all > 1 byte fields!
4701 */
4702
4703 }
4704
4705 return rc;
4706 }
4707
4708 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4709 /**
4710 * mptbase_sas_persist_operation - Perform operation on SAS Persistent Table
4711 * @ioc: Pointer to MPT_ADAPTER structure
4712 * @persist_opcode: see below
4713 *
4714 * MPI_SAS_OP_CLEAR_NOT_PRESENT - Free all persist TargetID mappings for
4715 * devices not currently present.
4716 * MPI_SAS_OP_CLEAR_ALL_PERSISTENT - Clear al persist TargetID mappings
4717 *
4718 * NOTE: Don't use not this function during interrupt time.
4719 *
4720 * Returns 0 for success, non-zero error
4721 */
4722
4723 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4724 int
4725 mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode)
4726 {
4727 SasIoUnitControlRequest_t *sasIoUnitCntrReq;
4728 SasIoUnitControlReply_t *sasIoUnitCntrReply;
4729 MPT_FRAME_HDR *mf = NULL;
4730 MPIHeader_t *mpi_hdr;
4731
4732
4733 /* insure garbage is not sent to fw */
4734 switch(persist_opcode) {
4735
4736 case MPI_SAS_OP_CLEAR_NOT_PRESENT:
4737 case MPI_SAS_OP_CLEAR_ALL_PERSISTENT:
4738 break;
4739
4740 default:
4741 return -1;
4742 break;
4743 }
4744
4745 printk("%s: persist_opcode=%x\n",__FUNCTION__, persist_opcode);
4746
4747 /* Get a MF for this command.
4748 */
4749 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
4750 printk("%s: no msg frames!\n",__FUNCTION__);
4751 return -1;
4752 }
4753
4754 mpi_hdr = (MPIHeader_t *) mf;
4755 sasIoUnitCntrReq = (SasIoUnitControlRequest_t *)mf;
4756 memset(sasIoUnitCntrReq,0,sizeof(SasIoUnitControlRequest_t));
4757 sasIoUnitCntrReq->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL;
4758 sasIoUnitCntrReq->MsgContext = mpi_hdr->MsgContext;
4759 sasIoUnitCntrReq->Operation = persist_opcode;
4760
4761 init_timer(&ioc->persist_timer);
4762 ioc->persist_timer.data = (unsigned long) ioc;
4763 ioc->persist_timer.function = mpt_timer_expired;
4764 ioc->persist_timer.expires = jiffies + HZ*10 /* 10 sec */;
4765 ioc->persist_wait_done=0;
4766 add_timer(&ioc->persist_timer);
4767 mpt_put_msg_frame(mpt_base_index, ioc, mf);
4768 wait_event(mpt_waitq, ioc->persist_wait_done);
4769
4770 sasIoUnitCntrReply =
4771 (SasIoUnitControlReply_t *)ioc->persist_reply_frame;
4772 if (le16_to_cpu(sasIoUnitCntrReply->IOCStatus) != MPI_IOCSTATUS_SUCCESS) {
4773 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n",
4774 __FUNCTION__,
4775 sasIoUnitCntrReply->IOCStatus,
4776 sasIoUnitCntrReply->IOCLogInfo);
4777 return -1;
4778 }
4779
4780 printk("%s: success\n",__FUNCTION__);
4781 return 0;
4782 }
4783
4784 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4785
4786 static void
4787 mptbase_raid_process_event_data(MPT_ADAPTER *ioc,
4788 MpiEventDataRaid_t * pRaidEventData)
4789 {
4790 int volume;
4791 int reason;
4792 int disk;
4793 int status;
4794 int flags;
4795 int state;
4796
4797 volume = pRaidEventData->VolumeID;
4798 reason = pRaidEventData->ReasonCode;
4799 disk = pRaidEventData->PhysDiskNum;
4800 status = le32_to_cpu(pRaidEventData->SettingsStatus);
4801 flags = (status >> 0) & 0xff;
4802 state = (status >> 8) & 0xff;
4803
4804 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
4805 return;
4806 }
4807
4808 if ((reason >= MPI_EVENT_RAID_RC_PHYSDISK_CREATED &&
4809 reason <= MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED) ||
4810 (reason == MPI_EVENT_RAID_RC_SMART_DATA)) {
4811 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for PhysDisk %d id=%d\n",
4812 ioc->name, disk, volume);
4813 } else {
4814 printk(MYIOC_s_INFO_FMT "RAID STATUS CHANGE for VolumeID %d\n",
4815 ioc->name, volume);
4816 }
4817
4818 switch(reason) {
4819 case MPI_EVENT_RAID_RC_VOLUME_CREATED:
4820 printk(MYIOC_s_INFO_FMT " volume has been created\n",
4821 ioc->name);
4822 break;
4823
4824 case MPI_EVENT_RAID_RC_VOLUME_DELETED:
4825
4826 printk(MYIOC_s_INFO_FMT " volume has been deleted\n",
4827 ioc->name);
4828 break;
4829
4830 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED:
4831 printk(MYIOC_s_INFO_FMT " volume settings have been changed\n",
4832 ioc->name);
4833 break;
4834
4835 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED:
4836 printk(MYIOC_s_INFO_FMT " volume is now %s%s%s%s\n",
4837 ioc->name,
4838 state == MPI_RAIDVOL0_STATUS_STATE_OPTIMAL
4839 ? "optimal"
4840 : state == MPI_RAIDVOL0_STATUS_STATE_DEGRADED
4841 ? "degraded"
4842 : state == MPI_RAIDVOL0_STATUS_STATE_FAILED
4843 ? "failed"
4844 : "state unknown",
4845 flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED
4846 ? ", enabled" : "",
4847 flags & MPI_RAIDVOL0_STATUS_FLAG_QUIESCED
4848 ? ", quiesced" : "",
4849 flags & MPI_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS
4850 ? ", resync in progress" : "" );
4851 break;
4852
4853 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED:
4854 printk(MYIOC_s_INFO_FMT " volume membership of PhysDisk %d has changed\n",
4855 ioc->name, disk);
4856 break;
4857
4858 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED:
4859 printk(MYIOC_s_INFO_FMT " PhysDisk has been created\n",
4860 ioc->name);
4861 break;
4862
4863 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED:
4864 printk(MYIOC_s_INFO_FMT " PhysDisk has been deleted\n",
4865 ioc->name);
4866 break;
4867
4868 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED:
4869 printk(MYIOC_s_INFO_FMT " PhysDisk settings have been changed\n",
4870 ioc->name);
4871 break;
4872
4873 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED:
4874 printk(MYIOC_s_INFO_FMT " PhysDisk is now %s%s%s\n",
4875 ioc->name,
4876 state == MPI_PHYSDISK0_STATUS_ONLINE
4877 ? "online"
4878 : state == MPI_PHYSDISK0_STATUS_MISSING
4879 ? "missing"
4880 : state == MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE
4881 ? "not compatible"
4882 : state == MPI_PHYSDISK0_STATUS_FAILED
4883 ? "failed"
4884 : state == MPI_PHYSDISK0_STATUS_INITIALIZING
4885 ? "initializing"
4886 : state == MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED
4887 ? "offline requested"
4888 : state == MPI_PHYSDISK0_STATUS_FAILED_REQUESTED
4889 ? "failed requested"
4890 : state == MPI_PHYSDISK0_STATUS_OTHER_OFFLINE
4891 ? "offline"
4892 : "state unknown",
4893 flags & MPI_PHYSDISK0_STATUS_FLAG_OUT_OF_SYNC
4894 ? ", out of sync" : "",
4895 flags & MPI_PHYSDISK0_STATUS_FLAG_QUIESCED
4896 ? ", quiesced" : "" );
4897 break;
4898
4899 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED:
4900 printk(MYIOC_s_INFO_FMT " Domain Validation needed for PhysDisk %d\n",
4901 ioc->name, disk);
4902 break;
4903
4904 case MPI_EVENT_RAID_RC_SMART_DATA:
4905 printk(MYIOC_s_INFO_FMT " SMART data received, ASC/ASCQ = %02xh/%02xh\n",
4906 ioc->name, pRaidEventData->ASC, pRaidEventData->ASCQ);
4907 break;
4908
4909 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED:
4910 printk(MYIOC_s_INFO_FMT " replacement of PhysDisk %d has started\n",
4911 ioc->name, disk);
4912 break;
4913 }
4914 }
4915
4916 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4917 /**
4918 * GetIoUnitPage2 - Retrieve BIOS version and boot order information.
4919 * @ioc: Pointer to MPT_ADAPTER structure
4920 *
4921 * Returns: 0 for success
4922 * -ENOMEM if no memory available
4923 * -EPERM if not allowed due to ISR context
4924 * -EAGAIN if no msg frames currently available
4925 * -EFAULT for non-successful reply or no reply (timeout)
4926 */
4927 static int
4928 GetIoUnitPage2(MPT_ADAPTER *ioc)
4929 {
4930 ConfigPageHeader_t hdr;
4931 CONFIGPARMS cfg;
4932 IOUnitPage2_t *ppage_alloc;
4933 dma_addr_t page_dma;
4934 int data_sz;
4935 int rc;
4936
4937 /* Get the page header */
4938 hdr.PageVersion = 0;
4939 hdr.PageLength = 0;
4940 hdr.PageNumber = 2;
4941 hdr.PageType = MPI_CONFIG_PAGETYPE_IO_UNIT;
4942 cfg.cfghdr.hdr = &hdr;
4943 cfg.physAddr = -1;
4944 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
4945 cfg.dir = 0;
4946 cfg.pageAddr = 0;
4947 cfg.timeout = 0;
4948
4949 if ((rc = mpt_config(ioc, &cfg)) != 0)
4950 return rc;
4951
4952 if (hdr.PageLength == 0)
4953 return 0;
4954
4955 /* Read the config page */
4956 data_sz = hdr.PageLength * 4;
4957 rc = -ENOMEM;
4958 ppage_alloc = (IOUnitPage2_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page_dma);
4959 if (ppage_alloc) {
4960 memset((u8 *)ppage_alloc, 0, data_sz);
4961 cfg.physAddr = page_dma;
4962 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
4963
4964 /* If Good, save data */
4965 if ((rc = mpt_config(ioc, &cfg)) == 0)
4966 ioc->biosVersion = le32_to_cpu(ppage_alloc->BiosVersion);
4967
4968 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage_alloc, page_dma);
4969 }
4970
4971 return rc;
4972 }
4973
4974 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
4975 /**
4976 * mpt_GetScsiPortSettings - read SCSI Port Page 0 and 2
4977 * @ioc: Pointer to a Adapter Strucutre
4978 * @portnum: IOC port number
4979 *
4980 * Return: -EFAULT if read of config page header fails
4981 * or if no nvram
4982 * If read of SCSI Port Page 0 fails,
4983 * NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
4984 * Adapter settings: async, narrow
4985 * Return 1
4986 * If read of SCSI Port Page 2 fails,
4987 * Adapter settings valid
4988 * NVRAM = MPT_HOST_NVRAM_INVALID (0xFFFFFFFF)
4989 * Return 1
4990 * Else
4991 * Both valid
4992 * Return 0
4993 * CHECK - what type of locking mechanisms should be used????
4994 */
4995 static int
4996 mpt_GetScsiPortSettings(MPT_ADAPTER *ioc, int portnum)
4997 {
4998 u8 *pbuf;
4999 dma_addr_t buf_dma;
5000 CONFIGPARMS cfg;
5001 ConfigPageHeader_t header;
5002 int ii;
5003 int data, rc = 0;
5004
5005 /* Allocate memory
5006 */
5007 if (!ioc->spi_data.nvram) {
5008 int sz;
5009 u8 *mem;
5010 sz = MPT_MAX_SCSI_DEVICES * sizeof(int);
5011 mem = kmalloc(sz, GFP_ATOMIC);
5012 if (mem == NULL)
5013 return -EFAULT;
5014
5015 ioc->spi_data.nvram = (int *) mem;
5016
5017 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SCSI device NVRAM settings @ %p, sz=%d\n",
5018 ioc->name, ioc->spi_data.nvram, sz));
5019 }
5020
5021 /* Invalidate NVRAM information
5022 */
5023 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5024 ioc->spi_data.nvram[ii] = MPT_HOST_NVRAM_INVALID;
5025 }
5026
5027 /* Read SPP0 header, allocate memory, then read page.
5028 */
5029 header.PageVersion = 0;
5030 header.PageLength = 0;
5031 header.PageNumber = 0;
5032 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
5033 cfg.cfghdr.hdr = &header;
5034 cfg.physAddr = -1;
5035 cfg.pageAddr = portnum;
5036 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5037 cfg.dir = 0;
5038 cfg.timeout = 0; /* use default */
5039 if (mpt_config(ioc, &cfg) != 0)
5040 return -EFAULT;
5041
5042 if (header.PageLength > 0) {
5043 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
5044 if (pbuf) {
5045 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5046 cfg.physAddr = buf_dma;
5047 if (mpt_config(ioc, &cfg) != 0) {
5048 ioc->spi_data.maxBusWidth = MPT_NARROW;
5049 ioc->spi_data.maxSyncOffset = 0;
5050 ioc->spi_data.minSyncFactor = MPT_ASYNC;
5051 ioc->spi_data.busType = MPT_HOST_BUS_UNKNOWN;
5052 rc = 1;
5053 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5054 "Unable to read PortPage0 minSyncFactor=%x\n",
5055 ioc->name, ioc->spi_data.minSyncFactor));
5056 } else {
5057 /* Save the Port Page 0 data
5058 */
5059 SCSIPortPage0_t *pPP0 = (SCSIPortPage0_t *) pbuf;
5060 pPP0->Capabilities = le32_to_cpu(pPP0->Capabilities);
5061 pPP0->PhysicalInterface = le32_to_cpu(pPP0->PhysicalInterface);
5062
5063 if ( (pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_QAS) == 0 ) {
5064 ioc->spi_data.noQas |= MPT_TARGET_NO_NEGO_QAS;
5065 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5066 "noQas due to Capabilities=%x\n",
5067 ioc->name, pPP0->Capabilities));
5068 }
5069 ioc->spi_data.maxBusWidth = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_WIDE ? 1 : 0;
5070 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MAX_SYNC_OFFSET_MASK;
5071 if (data) {
5072 ioc->spi_data.maxSyncOffset = (u8) (data >> 16);
5073 data = pPP0->Capabilities & MPI_SCSIPORTPAGE0_CAP_MIN_SYNC_PERIOD_MASK;
5074 ioc->spi_data.minSyncFactor = (u8) (data >> 8);
5075 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5076 "PortPage0 minSyncFactor=%x\n",
5077 ioc->name, ioc->spi_data.minSyncFactor));
5078 } else {
5079 ioc->spi_data.maxSyncOffset = 0;
5080 ioc->spi_data.minSyncFactor = MPT_ASYNC;
5081 }
5082
5083 ioc->spi_data.busType = pPP0->PhysicalInterface & MPI_SCSIPORTPAGE0_PHY_SIGNAL_TYPE_MASK;
5084
5085 /* Update the minSyncFactor based on bus type.
5086 */
5087 if ((ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_HVD) ||
5088 (ioc->spi_data.busType == MPI_SCSIPORTPAGE0_PHY_SIGNAL_SE)) {
5089
5090 if (ioc->spi_data.minSyncFactor < MPT_ULTRA) {
5091 ioc->spi_data.minSyncFactor = MPT_ULTRA;
5092 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5093 "HVD or SE detected, minSyncFactor=%x\n",
5094 ioc->name, ioc->spi_data.minSyncFactor));
5095 }
5096 }
5097 }
5098 if (pbuf) {
5099 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
5100 }
5101 }
5102 }
5103
5104 /* SCSI Port Page 2 - Read the header then the page.
5105 */
5106 header.PageVersion = 0;
5107 header.PageLength = 0;
5108 header.PageNumber = 2;
5109 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_PORT;
5110 cfg.cfghdr.hdr = &header;
5111 cfg.physAddr = -1;
5112 cfg.pageAddr = portnum;
5113 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5114 cfg.dir = 0;
5115 if (mpt_config(ioc, &cfg) != 0)
5116 return -EFAULT;
5117
5118 if (header.PageLength > 0) {
5119 /* Allocate memory and read SCSI Port Page 2
5120 */
5121 pbuf = pci_alloc_consistent(ioc->pcidev, header.PageLength * 4, &buf_dma);
5122 if (pbuf) {
5123 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_NVRAM;
5124 cfg.physAddr = buf_dma;
5125 if (mpt_config(ioc, &cfg) != 0) {
5126 /* Nvram data is left with INVALID mark
5127 */
5128 rc = 1;
5129 } else if (ioc->pcidev->vendor == PCI_VENDOR_ID_ATTO) {
5130
5131 /* This is an ATTO adapter, read Page2 accordingly
5132 */
5133 ATTO_SCSIPortPage2_t *pPP2 = (ATTO_SCSIPortPage2_t *) pbuf;
5134 ATTODeviceInfo_t *pdevice = NULL;
5135 u16 ATTOFlags;
5136
5137 /* Save the Port Page 2 data
5138 * (reformat into a 32bit quantity)
5139 */
5140 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5141 pdevice = &pPP2->DeviceSettings[ii];
5142 ATTOFlags = le16_to_cpu(pdevice->ATTOFlags);
5143 data = 0;
5144
5145 /* Translate ATTO device flags to LSI format
5146 */
5147 if (ATTOFlags & ATTOFLAG_DISC)
5148 data |= (MPI_SCSIPORTPAGE2_DEVICE_DISCONNECT_ENABLE);
5149 if (ATTOFlags & ATTOFLAG_ID_ENB)
5150 data |= (MPI_SCSIPORTPAGE2_DEVICE_ID_SCAN_ENABLE);
5151 if (ATTOFlags & ATTOFLAG_LUN_ENB)
5152 data |= (MPI_SCSIPORTPAGE2_DEVICE_LUN_SCAN_ENABLE);
5153 if (ATTOFlags & ATTOFLAG_TAGGED)
5154 data |= (MPI_SCSIPORTPAGE2_DEVICE_TAG_QUEUE_ENABLE);
5155 if (!(ATTOFlags & ATTOFLAG_WIDE_ENB))
5156 data |= (MPI_SCSIPORTPAGE2_DEVICE_WIDE_DISABLE);
5157
5158 data = (data << 16) | (pdevice->Period << 8) | 10;
5159 ioc->spi_data.nvram[ii] = data;
5160 }
5161 } else {
5162 SCSIPortPage2_t *pPP2 = (SCSIPortPage2_t *) pbuf;
5163 MpiDeviceInfo_t *pdevice = NULL;
5164
5165 /*
5166 * Save "Set to Avoid SCSI Bus Resets" flag
5167 */
5168 ioc->spi_data.bus_reset =
5169 (le32_to_cpu(pPP2->PortFlags) &
5170 MPI_SCSIPORTPAGE2_PORT_FLAGS_AVOID_SCSI_RESET) ?
5171 0 : 1 ;
5172
5173 /* Save the Port Page 2 data
5174 * (reformat into a 32bit quantity)
5175 */
5176 data = le32_to_cpu(pPP2->PortFlags) & MPI_SCSIPORTPAGE2_PORT_FLAGS_DV_MASK;
5177 ioc->spi_data.PortFlags = data;
5178 for (ii=0; ii < MPT_MAX_SCSI_DEVICES; ii++) {
5179 pdevice = &pPP2->DeviceSettings[ii];
5180 data = (le16_to_cpu(pdevice->DeviceFlags) << 16) |
5181 (pdevice->SyncFactor << 8) | pdevice->Timeout;
5182 ioc->spi_data.nvram[ii] = data;
5183 }
5184 }
5185
5186 pci_free_consistent(ioc->pcidev, header.PageLength * 4, pbuf, buf_dma);
5187 }
5188 }
5189
5190 /* Update Adapter limits with those from NVRAM
5191 * Comment: Don't need to do this. Target performance
5192 * parameters will never exceed the adapters limits.
5193 */
5194
5195 return rc;
5196 }
5197
5198 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5199 /**
5200 * mpt_readScsiDevicePageHeaders - save version and length of SDP1
5201 * @ioc: Pointer to a Adapter Strucutre
5202 * @portnum: IOC port number
5203 *
5204 * Return: -EFAULT if read of config page header fails
5205 * or 0 if success.
5206 */
5207 static int
5208 mpt_readScsiDevicePageHeaders(MPT_ADAPTER *ioc, int portnum)
5209 {
5210 CONFIGPARMS cfg;
5211 ConfigPageHeader_t header;
5212
5213 /* Read the SCSI Device Page 1 header
5214 */
5215 header.PageVersion = 0;
5216 header.PageLength = 0;
5217 header.PageNumber = 1;
5218 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
5219 cfg.cfghdr.hdr = &header;
5220 cfg.physAddr = -1;
5221 cfg.pageAddr = portnum;
5222 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5223 cfg.dir = 0;
5224 cfg.timeout = 0;
5225 if (mpt_config(ioc, &cfg) != 0)
5226 return -EFAULT;
5227
5228 ioc->spi_data.sdp1version = cfg.cfghdr.hdr->PageVersion;
5229 ioc->spi_data.sdp1length = cfg.cfghdr.hdr->PageLength;
5230
5231 header.PageVersion = 0;
5232 header.PageLength = 0;
5233 header.PageNumber = 0;
5234 header.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
5235 if (mpt_config(ioc, &cfg) != 0)
5236 return -EFAULT;
5237
5238 ioc->spi_data.sdp0version = cfg.cfghdr.hdr->PageVersion;
5239 ioc->spi_data.sdp0length = cfg.cfghdr.hdr->PageLength;
5240
5241 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 0: version %d length %d\n",
5242 ioc->name, ioc->spi_data.sdp0version, ioc->spi_data.sdp0length));
5243
5244 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Headers: 1: version %d length %d\n",
5245 ioc->name, ioc->spi_data.sdp1version, ioc->spi_data.sdp1length));
5246 return 0;
5247 }
5248
5249 /**
5250 * mpt_inactive_raid_list_free - This clears this link list.
5251 * @ioc : pointer to per adapter structure
5252 **/
5253 static void
5254 mpt_inactive_raid_list_free(MPT_ADAPTER *ioc)
5255 {
5256 struct inactive_raid_component_info *component_info, *pNext;
5257
5258 if (list_empty(&ioc->raid_data.inactive_list))
5259 return;
5260
5261 mutex_lock(&ioc->raid_data.inactive_list_mutex);
5262 list_for_each_entry_safe(component_info, pNext,
5263 &ioc->raid_data.inactive_list, list) {
5264 list_del(&component_info->list);
5265 kfree(component_info);
5266 }
5267 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
5268 }
5269
5270 /**
5271 * mpt_inactive_raid_volumes - sets up link list of phy_disk_nums for devices belonging in an inactive volume
5272 *
5273 * @ioc : pointer to per adapter structure
5274 * @channel : volume channel
5275 * @id : volume target id
5276 **/
5277 static void
5278 mpt_inactive_raid_volumes(MPT_ADAPTER *ioc, u8 channel, u8 id)
5279 {
5280 CONFIGPARMS cfg;
5281 ConfigPageHeader_t hdr;
5282 dma_addr_t dma_handle;
5283 pRaidVolumePage0_t buffer = NULL;
5284 int i;
5285 RaidPhysDiskPage0_t phys_disk;
5286 struct inactive_raid_component_info *component_info;
5287 int handle_inactive_volumes;
5288
5289 memset(&cfg, 0 , sizeof(CONFIGPARMS));
5290 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5291 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME;
5292 cfg.pageAddr = (channel << 8) + id;
5293 cfg.cfghdr.hdr = &hdr;
5294 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5295
5296 if (mpt_config(ioc, &cfg) != 0)
5297 goto out;
5298
5299 if (!hdr.PageLength)
5300 goto out;
5301
5302 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
5303 &dma_handle);
5304
5305 if (!buffer)
5306 goto out;
5307
5308 cfg.physAddr = dma_handle;
5309 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5310
5311 if (mpt_config(ioc, &cfg) != 0)
5312 goto out;
5313
5314 if (!buffer->NumPhysDisks)
5315 goto out;
5316
5317 handle_inactive_volumes =
5318 (buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE ||
5319 (buffer->VolumeStatus.Flags & MPI_RAIDVOL0_STATUS_FLAG_ENABLED) == 0 ||
5320 buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_FAILED ||
5321 buffer->VolumeStatus.State == MPI_RAIDVOL0_STATUS_STATE_MISSING) ? 1 : 0;
5322
5323 if (!handle_inactive_volumes)
5324 goto out;
5325
5326 mutex_lock(&ioc->raid_data.inactive_list_mutex);
5327 for (i = 0; i < buffer->NumPhysDisks; i++) {
5328 if(mpt_raid_phys_disk_pg0(ioc,
5329 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0)
5330 continue;
5331
5332 if ((component_info = kmalloc(sizeof (*component_info),
5333 GFP_KERNEL)) == NULL)
5334 continue;
5335
5336 component_info->volumeID = id;
5337 component_info->volumeBus = channel;
5338 component_info->d.PhysDiskNum = phys_disk.PhysDiskNum;
5339 component_info->d.PhysDiskBus = phys_disk.PhysDiskBus;
5340 component_info->d.PhysDiskID = phys_disk.PhysDiskID;
5341 component_info->d.PhysDiskIOC = phys_disk.PhysDiskIOC;
5342
5343 list_add_tail(&component_info->list,
5344 &ioc->raid_data.inactive_list);
5345 }
5346 mutex_unlock(&ioc->raid_data.inactive_list_mutex);
5347
5348 out:
5349 if (buffer)
5350 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
5351 dma_handle);
5352 }
5353
5354 /**
5355 * mpt_raid_phys_disk_pg0 - returns phys disk page zero
5356 * @ioc: Pointer to a Adapter Structure
5357 * @phys_disk_num: io unit unique phys disk num generated by the ioc
5358 * @phys_disk: requested payload data returned
5359 *
5360 * Return:
5361 * 0 on success
5362 * -EFAULT if read of config page header fails or data pointer not NULL
5363 * -ENOMEM if pci_alloc failed
5364 **/
5365 int
5366 mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk)
5367 {
5368 CONFIGPARMS cfg;
5369 ConfigPageHeader_t hdr;
5370 dma_addr_t dma_handle;
5371 pRaidPhysDiskPage0_t buffer = NULL;
5372 int rc;
5373
5374 memset(&cfg, 0 , sizeof(CONFIGPARMS));
5375 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5376
5377 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_PHYSDISK;
5378 cfg.cfghdr.hdr = &hdr;
5379 cfg.physAddr = -1;
5380 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5381
5382 if (mpt_config(ioc, &cfg) != 0) {
5383 rc = -EFAULT;
5384 goto out;
5385 }
5386
5387 if (!hdr.PageLength) {
5388 rc = -EFAULT;
5389 goto out;
5390 }
5391
5392 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4,
5393 &dma_handle);
5394
5395 if (!buffer) {
5396 rc = -ENOMEM;
5397 goto out;
5398 }
5399
5400 cfg.physAddr = dma_handle;
5401 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5402 cfg.pageAddr = phys_disk_num;
5403
5404 if (mpt_config(ioc, &cfg) != 0) {
5405 rc = -EFAULT;
5406 goto out;
5407 }
5408
5409 rc = 0;
5410 memcpy(phys_disk, buffer, sizeof(*buffer));
5411 phys_disk->MaxLBA = le32_to_cpu(buffer->MaxLBA);
5412
5413 out:
5414
5415 if (buffer)
5416 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer,
5417 dma_handle);
5418
5419 return rc;
5420 }
5421
5422 /**
5423 * mpt_findImVolumes - Identify IDs of hidden disks and RAID Volumes
5424 * @ioc: Pointer to a Adapter Strucutre
5425 * @portnum: IOC port number
5426 *
5427 * Return:
5428 * 0 on success
5429 * -EFAULT if read of config page header fails or data pointer not NULL
5430 * -ENOMEM if pci_alloc failed
5431 **/
5432 int
5433 mpt_findImVolumes(MPT_ADAPTER *ioc)
5434 {
5435 IOCPage2_t *pIoc2;
5436 u8 *mem;
5437 dma_addr_t ioc2_dma;
5438 CONFIGPARMS cfg;
5439 ConfigPageHeader_t header;
5440 int rc = 0;
5441 int iocpage2sz;
5442 int i;
5443
5444 if (!ioc->ir_firmware)
5445 return 0;
5446
5447 /* Free the old page
5448 */
5449 kfree(ioc->raid_data.pIocPg2);
5450 ioc->raid_data.pIocPg2 = NULL;
5451 mpt_inactive_raid_list_free(ioc);
5452
5453 /* Read IOCP2 header then the page.
5454 */
5455 header.PageVersion = 0;
5456 header.PageLength = 0;
5457 header.PageNumber = 2;
5458 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5459 cfg.cfghdr.hdr = &header;
5460 cfg.physAddr = -1;
5461 cfg.pageAddr = 0;
5462 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5463 cfg.dir = 0;
5464 cfg.timeout = 0;
5465 if (mpt_config(ioc, &cfg) != 0)
5466 return -EFAULT;
5467
5468 if (header.PageLength == 0)
5469 return -EFAULT;
5470
5471 iocpage2sz = header.PageLength * 4;
5472 pIoc2 = pci_alloc_consistent(ioc->pcidev, iocpage2sz, &ioc2_dma);
5473 if (!pIoc2)
5474 return -ENOMEM;
5475
5476 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5477 cfg.physAddr = ioc2_dma;
5478 if (mpt_config(ioc, &cfg) != 0)
5479 goto out;
5480
5481 mem = kmalloc(iocpage2sz, GFP_KERNEL);
5482 if (!mem)
5483 goto out;
5484
5485 memcpy(mem, (u8 *)pIoc2, iocpage2sz);
5486 ioc->raid_data.pIocPg2 = (IOCPage2_t *) mem;
5487
5488 mpt_read_ioc_pg_3(ioc);
5489
5490 for (i = 0; i < pIoc2->NumActiveVolumes ; i++)
5491 mpt_inactive_raid_volumes(ioc,
5492 pIoc2->RaidVolume[i].VolumeBus,
5493 pIoc2->RaidVolume[i].VolumeID);
5494
5495 out:
5496 pci_free_consistent(ioc->pcidev, iocpage2sz, pIoc2, ioc2_dma);
5497
5498 return rc;
5499 }
5500
5501 static int
5502 mpt_read_ioc_pg_3(MPT_ADAPTER *ioc)
5503 {
5504 IOCPage3_t *pIoc3;
5505 u8 *mem;
5506 CONFIGPARMS cfg;
5507 ConfigPageHeader_t header;
5508 dma_addr_t ioc3_dma;
5509 int iocpage3sz = 0;
5510
5511 /* Free the old page
5512 */
5513 kfree(ioc->raid_data.pIocPg3);
5514 ioc->raid_data.pIocPg3 = NULL;
5515
5516 /* There is at least one physical disk.
5517 * Read and save IOC Page 3
5518 */
5519 header.PageVersion = 0;
5520 header.PageLength = 0;
5521 header.PageNumber = 3;
5522 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5523 cfg.cfghdr.hdr = &header;
5524 cfg.physAddr = -1;
5525 cfg.pageAddr = 0;
5526 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5527 cfg.dir = 0;
5528 cfg.timeout = 0;
5529 if (mpt_config(ioc, &cfg) != 0)
5530 return 0;
5531
5532 if (header.PageLength == 0)
5533 return 0;
5534
5535 /* Read Header good, alloc memory
5536 */
5537 iocpage3sz = header.PageLength * 4;
5538 pIoc3 = pci_alloc_consistent(ioc->pcidev, iocpage3sz, &ioc3_dma);
5539 if (!pIoc3)
5540 return 0;
5541
5542 /* Read the Page and save the data
5543 * into malloc'd memory.
5544 */
5545 cfg.physAddr = ioc3_dma;
5546 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5547 if (mpt_config(ioc, &cfg) == 0) {
5548 mem = kmalloc(iocpage3sz, GFP_KERNEL);
5549 if (mem) {
5550 memcpy(mem, (u8 *)pIoc3, iocpage3sz);
5551 ioc->raid_data.pIocPg3 = (IOCPage3_t *) mem;
5552 }
5553 }
5554
5555 pci_free_consistent(ioc->pcidev, iocpage3sz, pIoc3, ioc3_dma);
5556
5557 return 0;
5558 }
5559
5560 static void
5561 mpt_read_ioc_pg_4(MPT_ADAPTER *ioc)
5562 {
5563 IOCPage4_t *pIoc4;
5564 CONFIGPARMS cfg;
5565 ConfigPageHeader_t header;
5566 dma_addr_t ioc4_dma;
5567 int iocpage4sz;
5568
5569 /* Read and save IOC Page 4
5570 */
5571 header.PageVersion = 0;
5572 header.PageLength = 0;
5573 header.PageNumber = 4;
5574 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5575 cfg.cfghdr.hdr = &header;
5576 cfg.physAddr = -1;
5577 cfg.pageAddr = 0;
5578 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5579 cfg.dir = 0;
5580 cfg.timeout = 0;
5581 if (mpt_config(ioc, &cfg) != 0)
5582 return;
5583
5584 if (header.PageLength == 0)
5585 return;
5586
5587 if ( (pIoc4 = ioc->spi_data.pIocPg4) == NULL ) {
5588 iocpage4sz = (header.PageLength + 4) * 4; /* Allow 4 additional SEP's */
5589 pIoc4 = pci_alloc_consistent(ioc->pcidev, iocpage4sz, &ioc4_dma);
5590 if (!pIoc4)
5591 return;
5592 ioc->alloc_total += iocpage4sz;
5593 } else {
5594 ioc4_dma = ioc->spi_data.IocPg4_dma;
5595 iocpage4sz = ioc->spi_data.IocPg4Sz;
5596 }
5597
5598 /* Read the Page into dma memory.
5599 */
5600 cfg.physAddr = ioc4_dma;
5601 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5602 if (mpt_config(ioc, &cfg) == 0) {
5603 ioc->spi_data.pIocPg4 = (IOCPage4_t *) pIoc4;
5604 ioc->spi_data.IocPg4_dma = ioc4_dma;
5605 ioc->spi_data.IocPg4Sz = iocpage4sz;
5606 } else {
5607 pci_free_consistent(ioc->pcidev, iocpage4sz, pIoc4, ioc4_dma);
5608 ioc->spi_data.pIocPg4 = NULL;
5609 ioc->alloc_total -= iocpage4sz;
5610 }
5611 }
5612
5613 static void
5614 mpt_read_ioc_pg_1(MPT_ADAPTER *ioc)
5615 {
5616 IOCPage1_t *pIoc1;
5617 CONFIGPARMS cfg;
5618 ConfigPageHeader_t header;
5619 dma_addr_t ioc1_dma;
5620 int iocpage1sz = 0;
5621 u32 tmp;
5622
5623 /* Check the Coalescing Timeout in IOC Page 1
5624 */
5625 header.PageVersion = 0;
5626 header.PageLength = 0;
5627 header.PageNumber = 1;
5628 header.PageType = MPI_CONFIG_PAGETYPE_IOC;
5629 cfg.cfghdr.hdr = &header;
5630 cfg.physAddr = -1;
5631 cfg.pageAddr = 0;
5632 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5633 cfg.dir = 0;
5634 cfg.timeout = 0;
5635 if (mpt_config(ioc, &cfg) != 0)
5636 return;
5637
5638 if (header.PageLength == 0)
5639 return;
5640
5641 /* Read Header good, alloc memory
5642 */
5643 iocpage1sz = header.PageLength * 4;
5644 pIoc1 = pci_alloc_consistent(ioc->pcidev, iocpage1sz, &ioc1_dma);
5645 if (!pIoc1)
5646 return;
5647
5648 /* Read the Page and check coalescing timeout
5649 */
5650 cfg.physAddr = ioc1_dma;
5651 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5652 if (mpt_config(ioc, &cfg) == 0) {
5653
5654 tmp = le32_to_cpu(pIoc1->Flags) & MPI_IOCPAGE1_REPLY_COALESCING;
5655 if (tmp == MPI_IOCPAGE1_REPLY_COALESCING) {
5656 tmp = le32_to_cpu(pIoc1->CoalescingTimeout);
5657
5658 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Coalescing Enabled Timeout = %d\n",
5659 ioc->name, tmp));
5660
5661 if (tmp > MPT_COALESCING_TIMEOUT) {
5662 pIoc1->CoalescingTimeout = cpu_to_le32(MPT_COALESCING_TIMEOUT);
5663
5664 /* Write NVRAM and current
5665 */
5666 cfg.dir = 1;
5667 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
5668 if (mpt_config(ioc, &cfg) == 0) {
5669 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Reset Current Coalescing Timeout to = %d\n",
5670 ioc->name, MPT_COALESCING_TIMEOUT));
5671
5672 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM;
5673 if (mpt_config(ioc, &cfg) == 0) {
5674 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5675 "Reset NVRAM Coalescing Timeout to = %d\n",
5676 ioc->name, MPT_COALESCING_TIMEOUT));
5677 } else {
5678 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5679 "Reset NVRAM Coalescing Timeout Failed\n",
5680 ioc->name));
5681 }
5682
5683 } else {
5684 dprintk(ioc, printk(MYIOC_s_WARN_FMT
5685 "Reset of Current Coalescing Timeout Failed!\n",
5686 ioc->name));
5687 }
5688 }
5689
5690 } else {
5691 dprintk(ioc, printk(MYIOC_s_WARN_FMT "Coalescing Disabled\n", ioc->name));
5692 }
5693 }
5694
5695 pci_free_consistent(ioc->pcidev, iocpage1sz, pIoc1, ioc1_dma);
5696
5697 return;
5698 }
5699
5700 static void
5701 mpt_get_manufacturing_pg_0(MPT_ADAPTER *ioc)
5702 {
5703 CONFIGPARMS cfg;
5704 ConfigPageHeader_t hdr;
5705 dma_addr_t buf_dma;
5706 ManufacturingPage0_t *pbuf = NULL;
5707
5708 memset(&cfg, 0 , sizeof(CONFIGPARMS));
5709 memset(&hdr, 0 , sizeof(ConfigPageHeader_t));
5710
5711 hdr.PageType = MPI_CONFIG_PAGETYPE_MANUFACTURING;
5712 cfg.cfghdr.hdr = &hdr;
5713 cfg.physAddr = -1;
5714 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
5715 cfg.timeout = 10;
5716
5717 if (mpt_config(ioc, &cfg) != 0)
5718 goto out;
5719
5720 if (!cfg.cfghdr.hdr->PageLength)
5721 goto out;
5722
5723 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
5724 pbuf = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, &buf_dma);
5725 if (!pbuf)
5726 goto out;
5727
5728 cfg.physAddr = buf_dma;
5729
5730 if (mpt_config(ioc, &cfg) != 0)
5731 goto out;
5732
5733 memcpy(ioc->board_name, pbuf->BoardName, sizeof(ioc->board_name));
5734 memcpy(ioc->board_assembly, pbuf->BoardAssembly, sizeof(ioc->board_assembly));
5735 memcpy(ioc->board_tracer, pbuf->BoardTracerNumber, sizeof(ioc->board_tracer));
5736
5737 out:
5738
5739 if (pbuf)
5740 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, pbuf, buf_dma);
5741 }
5742
5743 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5744 /**
5745 * SendEventNotification - Send EventNotification (on or off) request to adapter
5746 * @ioc: Pointer to MPT_ADAPTER structure
5747 * @EvSwitch: Event switch flags
5748 */
5749 static int
5750 SendEventNotification(MPT_ADAPTER *ioc, u8 EvSwitch)
5751 {
5752 EventNotification_t *evnp;
5753
5754 evnp = (EventNotification_t *) mpt_get_msg_frame(mpt_base_index, ioc);
5755 if (evnp == NULL) {
5756 devtverboseprintk(ioc, printk(MYIOC_s_WARN_FMT "Unable to allocate event request frame!\n",
5757 ioc->name));
5758 return 0;
5759 }
5760 memset(evnp, 0, sizeof(*evnp));
5761
5762 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventNotification (%d) request %p\n", ioc->name, EvSwitch, evnp));
5763
5764 evnp->Function = MPI_FUNCTION_EVENT_NOTIFICATION;
5765 evnp->ChainOffset = 0;
5766 evnp->MsgFlags = 0;
5767 evnp->Switch = EvSwitch;
5768
5769 mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)evnp);
5770
5771 return 0;
5772 }
5773
5774 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5775 /**
5776 * SendEventAck - Send EventAck request to MPT adapter.
5777 * @ioc: Pointer to MPT_ADAPTER structure
5778 * @evnp: Pointer to original EventNotification request
5779 */
5780 static int
5781 SendEventAck(MPT_ADAPTER *ioc, EventNotificationReply_t *evnp)
5782 {
5783 EventAck_t *pAck;
5784
5785 if ((pAck = (EventAck_t *) mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5786 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames!!\n",
5787 ioc->name,__FUNCTION__));
5788 return -1;
5789 }
5790
5791 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending EventAck\n", ioc->name));
5792
5793 pAck->Function = MPI_FUNCTION_EVENT_ACK;
5794 pAck->ChainOffset = 0;
5795 pAck->Reserved[0] = pAck->Reserved[1] = 0;
5796 pAck->MsgFlags = 0;
5797 pAck->Reserved1[0] = pAck->Reserved1[1] = pAck->Reserved1[2] = 0;
5798 pAck->Event = evnp->Event;
5799 pAck->EventContext = evnp->EventContext;
5800
5801 mpt_put_msg_frame(mpt_base_index, ioc, (MPT_FRAME_HDR *)pAck);
5802
5803 return 0;
5804 }
5805
5806 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5807 /**
5808 * mpt_config - Generic function to issue config message
5809 * @ioc: Pointer to an adapter structure
5810 * @pCfg: Pointer to a configuration structure. Struct contains
5811 * action, page address, direction, physical address
5812 * and pointer to a configuration page header
5813 * Page header is updated.
5814 *
5815 * Returns 0 for success
5816 * -EPERM if not allowed due to ISR context
5817 * -EAGAIN if no msg frames currently available
5818 * -EFAULT for non-successful reply or no reply (timeout)
5819 */
5820 int
5821 mpt_config(MPT_ADAPTER *ioc, CONFIGPARMS *pCfg)
5822 {
5823 Config_t *pReq;
5824 ConfigExtendedPageHeader_t *pExtHdr = NULL;
5825 MPT_FRAME_HDR *mf;
5826 unsigned long flags;
5827 int ii, rc;
5828 int flagsLength;
5829 int in_isr;
5830
5831 /* Prevent calling wait_event() (below), if caller happens
5832 * to be in ISR context, because that is fatal!
5833 */
5834 in_isr = in_interrupt();
5835 if (in_isr) {
5836 dcprintk(ioc, printk(MYIOC_s_WARN_FMT "Config request not allowed in ISR context!\n",
5837 ioc->name));
5838 return -EPERM;
5839 }
5840
5841 /* Get and Populate a free Frame
5842 */
5843 if ((mf = mpt_get_msg_frame(mpt_base_index, ioc)) == NULL) {
5844 dcprintk(ioc, printk(MYIOC_s_WARN_FMT "mpt_config: no msg frames!\n",
5845 ioc->name));
5846 return -EAGAIN;
5847 }
5848 pReq = (Config_t *)mf;
5849 pReq->Action = pCfg->action;
5850 pReq->Reserved = 0;
5851 pReq->ChainOffset = 0;
5852 pReq->Function = MPI_FUNCTION_CONFIG;
5853
5854 /* Assume page type is not extended and clear "reserved" fields. */
5855 pReq->ExtPageLength = 0;
5856 pReq->ExtPageType = 0;
5857 pReq->MsgFlags = 0;
5858
5859 for (ii=0; ii < 8; ii++)
5860 pReq->Reserved2[ii] = 0;
5861
5862 pReq->Header.PageVersion = pCfg->cfghdr.hdr->PageVersion;
5863 pReq->Header.PageLength = pCfg->cfghdr.hdr->PageLength;
5864 pReq->Header.PageNumber = pCfg->cfghdr.hdr->PageNumber;
5865 pReq->Header.PageType = (pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
5866
5867 if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5868 pExtHdr = (ConfigExtendedPageHeader_t *)pCfg->cfghdr.ehdr;
5869 pReq->ExtPageLength = cpu_to_le16(pExtHdr->ExtPageLength);
5870 pReq->ExtPageType = pExtHdr->ExtPageType;
5871 pReq->Header.PageType = MPI_CONFIG_PAGETYPE_EXTENDED;
5872
5873 /* Page Length must be treated as a reserved field for the extended header. */
5874 pReq->Header.PageLength = 0;
5875 }
5876
5877 pReq->PageAddress = cpu_to_le32(pCfg->pageAddr);
5878
5879 /* Add a SGE to the config request.
5880 */
5881 if (pCfg->dir)
5882 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE;
5883 else
5884 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
5885
5886 if ((pCfg->cfghdr.hdr->PageType & MPI_CONFIG_PAGETYPE_MASK) == MPI_CONFIG_PAGETYPE_EXTENDED) {
5887 flagsLength |= pExtHdr->ExtPageLength * 4;
5888
5889 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
5890 ioc->name, pReq->ExtPageType, pReq->Header.PageNumber, pReq->Action));
5891 }
5892 else {
5893 flagsLength |= pCfg->cfghdr.hdr->PageLength * 4;
5894
5895 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Sending Config request type %d, page %d and action %d\n",
5896 ioc->name, pReq->Header.PageType, pReq->Header.PageNumber, pReq->Action));
5897 }
5898
5899 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, pCfg->physAddr);
5900
5901 /* Append pCfg pointer to end of mf
5902 */
5903 *((void **) (((u8 *) mf) + (ioc->req_sz - sizeof(void *)))) = (void *) pCfg;
5904
5905 /* Initalize the timer
5906 */
5907 init_timer(&pCfg->timer);
5908 pCfg->timer.data = (unsigned long) ioc;
5909 pCfg->timer.function = mpt_timer_expired;
5910 pCfg->wait_done = 0;
5911
5912 /* Set the timer; ensure 10 second minimum */
5913 if (pCfg->timeout < 10)
5914 pCfg->timer.expires = jiffies + HZ*10;
5915 else
5916 pCfg->timer.expires = jiffies + HZ*pCfg->timeout;
5917
5918 /* Add to end of Q, set timer and then issue this command */
5919 spin_lock_irqsave(&ioc->FreeQlock, flags);
5920 list_add_tail(&pCfg->linkage, &ioc->configQ);
5921 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5922
5923 add_timer(&pCfg->timer);
5924 mpt_put_msg_frame(mpt_base_index, ioc, mf);
5925 wait_event(mpt_waitq, pCfg->wait_done);
5926
5927 /* mf has been freed - do not access */
5928
5929 rc = pCfg->status;
5930
5931 return rc;
5932 }
5933
5934 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5935 /**
5936 * mpt_timer_expired - Callback for timer process.
5937 * Used only internal config functionality.
5938 * @data: Pointer to MPT_SCSI_HOST recast as an unsigned long
5939 */
5940 static void
5941 mpt_timer_expired(unsigned long data)
5942 {
5943 MPT_ADAPTER *ioc = (MPT_ADAPTER *) data;
5944
5945 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired! \n", ioc->name));
5946
5947 /* Perform a FW reload */
5948 if (mpt_HardResetHandler(ioc, NO_SLEEP) < 0)
5949 printk(MYIOC_s_WARN_FMT "Firmware Reload FAILED!\n", ioc->name);
5950
5951 /* No more processing.
5952 * Hard reset clean-up will wake up
5953 * process and free all resources.
5954 */
5955 dcprintk(ioc, printk(MYIOC_s_DEBUG_FMT "mpt_timer_expired complete!\n", ioc->name));
5956
5957 return;
5958 }
5959
5960 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
5961 /**
5962 * mpt_ioc_reset - Base cleanup for hard reset
5963 * @ioc: Pointer to the adapter structure
5964 * @reset_phase: Indicates pre- or post-reset functionality
5965 *
5966 * Remark: Frees resources with internally generated commands.
5967 */
5968 static int
5969 mpt_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
5970 {
5971 CONFIGPARMS *pCfg;
5972 unsigned long flags;
5973
5974 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
5975 ": IOC %s_reset routed to MPT base driver!\n",
5976 ioc->name, reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
5977 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
5978
5979 if (reset_phase == MPT_IOC_SETUP_RESET) {
5980 ;
5981 } else if (reset_phase == MPT_IOC_PRE_RESET) {
5982 /* If the internal config Q is not empty -
5983 * delete timer. MF resources will be freed when
5984 * the FIFO's are primed.
5985 */
5986 spin_lock_irqsave(&ioc->FreeQlock, flags);
5987 list_for_each_entry(pCfg, &ioc->configQ, linkage)
5988 del_timer(&pCfg->timer);
5989 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
5990
5991 } else {
5992 CONFIGPARMS *pNext;
5993
5994 /* Search the configQ for internal commands.
5995 * Flush the Q, and wake up all suspended threads.
5996 */
5997 spin_lock_irqsave(&ioc->FreeQlock, flags);
5998 list_for_each_entry_safe(pCfg, pNext, &ioc->configQ, linkage) {
5999 list_del(&pCfg->linkage);
6000
6001 pCfg->status = MPT_CONFIG_ERROR;
6002 pCfg->wait_done = 1;
6003 wake_up(&mpt_waitq);
6004 }
6005 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
6006 }
6007
6008 return 1; /* currently means nothing really */
6009 }
6010
6011
6012 #ifdef CONFIG_PROC_FS /* { */
6013 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6014 /*
6015 * procfs (%MPT_PROCFS_MPTBASEDIR/...) support stuff...
6016 */
6017 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6018 /**
6019 * procmpt_create - Create %MPT_PROCFS_MPTBASEDIR entries.
6020 *
6021 * Returns 0 for success, non-zero for failure.
6022 */
6023 static int
6024 procmpt_create(void)
6025 {
6026 struct proc_dir_entry *ent;
6027
6028 mpt_proc_root_dir = proc_mkdir(MPT_PROCFS_MPTBASEDIR, NULL);
6029 if (mpt_proc_root_dir == NULL)
6030 return -ENOTDIR;
6031
6032 ent = create_proc_entry("summary", S_IFREG|S_IRUGO, mpt_proc_root_dir);
6033 if (ent)
6034 ent->read_proc = procmpt_summary_read;
6035
6036 ent = create_proc_entry("version", S_IFREG|S_IRUGO, mpt_proc_root_dir);
6037 if (ent)
6038 ent->read_proc = procmpt_version_read;
6039
6040 return 0;
6041 }
6042
6043 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6044 /**
6045 * procmpt_destroy - Tear down %MPT_PROCFS_MPTBASEDIR entries.
6046 *
6047 * Returns 0 for success, non-zero for failure.
6048 */
6049 static void
6050 procmpt_destroy(void)
6051 {
6052 remove_proc_entry("version", mpt_proc_root_dir);
6053 remove_proc_entry("summary", mpt_proc_root_dir);
6054 remove_proc_entry(MPT_PROCFS_MPTBASEDIR, NULL);
6055 }
6056
6057 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6058 /**
6059 * procmpt_summary_read - Handle read request of a summary file
6060 * @buf: Pointer to area to write information
6061 * @start: Pointer to start pointer
6062 * @offset: Offset to start writing
6063 * @request: Amount of read data requested
6064 * @eof: Pointer to EOF integer
6065 * @data: Pointer
6066 *
6067 * Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
6068 * Returns number of characters written to process performing the read.
6069 */
6070 static int
6071 procmpt_summary_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6072 {
6073 MPT_ADAPTER *ioc;
6074 char *out = buf;
6075 int len;
6076
6077 if (data) {
6078 int more = 0;
6079
6080 ioc = data;
6081 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
6082
6083 out += more;
6084 } else {
6085 list_for_each_entry(ioc, &ioc_list, list) {
6086 int more = 0;
6087
6088 mpt_print_ioc_summary(ioc, out, &more, 0, 1);
6089
6090 out += more;
6091 if ((out-buf) >= request)
6092 break;
6093 }
6094 }
6095
6096 len = out - buf;
6097
6098 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6099 }
6100
6101 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6102 /**
6103 * procmpt_version_read - Handle read request from /proc/mpt/version.
6104 * @buf: Pointer to area to write information
6105 * @start: Pointer to start pointer
6106 * @offset: Offset to start writing
6107 * @request: Amount of read data requested
6108 * @eof: Pointer to EOF integer
6109 * @data: Pointer
6110 *
6111 * Returns number of characters written to process performing the read.
6112 */
6113 static int
6114 procmpt_version_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6115 {
6116 u8 cb_idx;
6117 int scsi, fc, sas, lan, ctl, targ, dmp;
6118 char *drvname;
6119 int len;
6120
6121 len = sprintf(buf, "%s-%s\n", "mptlinux", MPT_LINUX_VERSION_COMMON);
6122 len += sprintf(buf+len, " Fusion MPT base driver\n");
6123
6124 scsi = fc = sas = lan = ctl = targ = dmp = 0;
6125 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6126 drvname = NULL;
6127 if (MptCallbacks[cb_idx]) {
6128 switch (MptDriverClass[cb_idx]) {
6129 case MPTSPI_DRIVER:
6130 if (!scsi++) drvname = "SPI host";
6131 break;
6132 case MPTFC_DRIVER:
6133 if (!fc++) drvname = "FC host";
6134 break;
6135 case MPTSAS_DRIVER:
6136 if (!sas++) drvname = "SAS host";
6137 break;
6138 case MPTLAN_DRIVER:
6139 if (!lan++) drvname = "LAN";
6140 break;
6141 case MPTSTM_DRIVER:
6142 if (!targ++) drvname = "SCSI target";
6143 break;
6144 case MPTCTL_DRIVER:
6145 if (!ctl++) drvname = "ioctl";
6146 break;
6147 }
6148
6149 if (drvname)
6150 len += sprintf(buf+len, " Fusion MPT %s driver\n", drvname);
6151 }
6152 }
6153
6154 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6155 }
6156
6157 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6158 /**
6159 * procmpt_iocinfo_read - Handle read request from /proc/mpt/iocN/info.
6160 * @buf: Pointer to area to write information
6161 * @start: Pointer to start pointer
6162 * @offset: Offset to start writing
6163 * @request: Amount of read data requested
6164 * @eof: Pointer to EOF integer
6165 * @data: Pointer
6166 *
6167 * Returns number of characters written to process performing the read.
6168 */
6169 static int
6170 procmpt_iocinfo_read(char *buf, char **start, off_t offset, int request, int *eof, void *data)
6171 {
6172 MPT_ADAPTER *ioc = data;
6173 int len;
6174 char expVer[32];
6175 int sz;
6176 int p;
6177
6178 mpt_get_fw_exp_ver(expVer, ioc);
6179
6180 len = sprintf(buf, "%s:", ioc->name);
6181 if (ioc->facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT)
6182 len += sprintf(buf+len, " (f/w download boot flag set)");
6183 // if (ioc->facts.IOCExceptions & MPI_IOCFACTS_EXCEPT_CONFIG_CHECKSUM_FAIL)
6184 // len += sprintf(buf+len, " CONFIG_CHECKSUM_FAIL!");
6185
6186 len += sprintf(buf+len, "\n ProductID = 0x%04x (%s)\n",
6187 ioc->facts.ProductID,
6188 ioc->prod_name);
6189 len += sprintf(buf+len, " FWVersion = 0x%08x%s", ioc->facts.FWVersion.Word, expVer);
6190 if (ioc->facts.FWImageSize)
6191 len += sprintf(buf+len, " (fw_size=%d)", ioc->facts.FWImageSize);
6192 len += sprintf(buf+len, "\n MsgVersion = 0x%04x\n", ioc->facts.MsgVersion);
6193 len += sprintf(buf+len, " FirstWhoInit = 0x%02x\n", ioc->FirstWhoInit);
6194 len += sprintf(buf+len, " EventState = 0x%02x\n", ioc->facts.EventState);
6195
6196 len += sprintf(buf+len, " CurrentHostMfaHighAddr = 0x%08x\n",
6197 ioc->facts.CurrentHostMfaHighAddr);
6198 len += sprintf(buf+len, " CurrentSenseBufferHighAddr = 0x%08x\n",
6199 ioc->facts.CurrentSenseBufferHighAddr);
6200
6201 len += sprintf(buf+len, " MaxChainDepth = 0x%02x frames\n", ioc->facts.MaxChainDepth);
6202 len += sprintf(buf+len, " MinBlockSize = 0x%02x bytes\n", 4*ioc->facts.BlockSize);
6203
6204 len += sprintf(buf+len, " RequestFrames @ 0x%p (Dma @ 0x%p)\n",
6205 (void *)ioc->req_frames, (void *)(ulong)ioc->req_frames_dma);
6206 /*
6207 * Rounding UP to nearest 4-kB boundary here...
6208 */
6209 sz = (ioc->req_sz * ioc->req_depth) + 128;
6210 sz = ((sz + 0x1000UL - 1UL) / 0x1000) * 0x1000;
6211 len += sprintf(buf+len, " {CurReqSz=%d} x {CurReqDepth=%d} = %d bytes ^= 0x%x\n",
6212 ioc->req_sz, ioc->req_depth, ioc->req_sz*ioc->req_depth, sz);
6213 len += sprintf(buf+len, " {MaxReqSz=%d} {MaxReqDepth=%d}\n",
6214 4*ioc->facts.RequestFrameSize,
6215 ioc->facts.GlobalCredits);
6216
6217 len += sprintf(buf+len, " Frames @ 0x%p (Dma @ 0x%p)\n",
6218 (void *)ioc->alloc, (void *)(ulong)ioc->alloc_dma);
6219 sz = (ioc->reply_sz * ioc->reply_depth) + 128;
6220 len += sprintf(buf+len, " {CurRepSz=%d} x {CurRepDepth=%d} = %d bytes ^= 0x%x\n",
6221 ioc->reply_sz, ioc->reply_depth, ioc->reply_sz*ioc->reply_depth, sz);
6222 len += sprintf(buf+len, " {MaxRepSz=%d} {MaxRepDepth=%d}\n",
6223 ioc->facts.CurReplyFrameSize,
6224 ioc->facts.ReplyQueueDepth);
6225
6226 len += sprintf(buf+len, " MaxDevices = %d\n",
6227 (ioc->facts.MaxDevices==0) ? 255 : ioc->facts.MaxDevices);
6228 len += sprintf(buf+len, " MaxBuses = %d\n", ioc->facts.MaxBuses);
6229
6230 /* per-port info */
6231 for (p=0; p < ioc->facts.NumberOfPorts; p++) {
6232 len += sprintf(buf+len, " PortNumber = %d (of %d)\n",
6233 p+1,
6234 ioc->facts.NumberOfPorts);
6235 if (ioc->bus_type == FC) {
6236 if (ioc->pfacts[p].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN) {
6237 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
6238 len += sprintf(buf+len, " LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
6239 a[5], a[4], a[3], a[2], a[1], a[0]);
6240 }
6241 len += sprintf(buf+len, " WWN = %08X%08X:%08X%08X\n",
6242 ioc->fc_port_page0[p].WWNN.High,
6243 ioc->fc_port_page0[p].WWNN.Low,
6244 ioc->fc_port_page0[p].WWPN.High,
6245 ioc->fc_port_page0[p].WWPN.Low);
6246 }
6247 }
6248
6249 MPT_PROC_READ_RETURN(buf,start,offset,request,eof,len);
6250 }
6251
6252 #endif /* CONFIG_PROC_FS } */
6253
6254 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6255 static void
6256 mpt_get_fw_exp_ver(char *buf, MPT_ADAPTER *ioc)
6257 {
6258 buf[0] ='\0';
6259 if ((ioc->facts.FWVersion.Word >> 24) == 0x0E) {
6260 sprintf(buf, " (Exp %02d%02d)",
6261 (ioc->facts.FWVersion.Word >> 16) & 0x00FF, /* Month */
6262 (ioc->facts.FWVersion.Word >> 8) & 0x1F); /* Day */
6263
6264 /* insider hack! */
6265 if ((ioc->facts.FWVersion.Word >> 8) & 0x80)
6266 strcat(buf, " [MDBG]");
6267 }
6268 }
6269
6270 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6271 /**
6272 * mpt_print_ioc_summary - Write ASCII summary of IOC to a buffer.
6273 * @ioc: Pointer to MPT_ADAPTER structure
6274 * @buffer: Pointer to buffer where IOC summary info should be written
6275 * @size: Pointer to number of bytes we wrote (set by this routine)
6276 * @len: Offset at which to start writing in buffer
6277 * @showlan: Display LAN stuff?
6278 *
6279 * This routine writes (english readable) ASCII text, which represents
6280 * a summary of IOC information, to a buffer.
6281 */
6282 void
6283 mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int showlan)
6284 {
6285 char expVer[32];
6286 int y;
6287
6288 mpt_get_fw_exp_ver(expVer, ioc);
6289
6290 /*
6291 * Shorter summary of attached ioc's...
6292 */
6293 y = sprintf(buffer+len, "%s: %s, %s%08xh%s, Ports=%d, MaxQ=%d",
6294 ioc->name,
6295 ioc->prod_name,
6296 MPT_FW_REV_MAGIC_ID_STRING, /* "FwRev=" or somesuch */
6297 ioc->facts.FWVersion.Word,
6298 expVer,
6299 ioc->facts.NumberOfPorts,
6300 ioc->req_depth);
6301
6302 if (showlan && (ioc->pfacts[0].ProtocolFlags & MPI_PORTFACTS_PROTOCOL_LAN)) {
6303 u8 *a = (u8*)&ioc->lan_cnfg_page1.HardwareAddressLow;
6304 y += sprintf(buffer+len+y, ", LanAddr=%02X:%02X:%02X:%02X:%02X:%02X",
6305 a[5], a[4], a[3], a[2], a[1], a[0]);
6306 }
6307
6308 y += sprintf(buffer+len+y, ", IRQ=%d", ioc->pci_irq);
6309
6310 if (!ioc->active)
6311 y += sprintf(buffer+len+y, " (disabled)");
6312
6313 y += sprintf(buffer+len+y, "\n");
6314
6315 *size = y;
6316 }
6317
6318 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6319 /*
6320 * Reset Handling
6321 */
6322 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6323 /**
6324 * mpt_HardResetHandler - Generic reset handler
6325 * @ioc: Pointer to MPT_ADAPTER structure
6326 * @sleepFlag: Indicates if sleep or schedule must be called.
6327 *
6328 * Issues SCSI Task Management call based on input arg values.
6329 * If TaskMgmt fails, returns associated SCSI request.
6330 *
6331 * Remark: _HardResetHandler can be invoked from an interrupt thread (timer)
6332 * or a non-interrupt thread. In the former, must not call schedule().
6333 *
6334 * Note: A return of -1 is a FATAL error case, as it means a
6335 * FW reload/initialization failed.
6336 *
6337 * Returns 0 for SUCCESS or -1 if FAILED.
6338 */
6339 int
6340 mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
6341 {
6342 int rc;
6343 unsigned long flags;
6344
6345 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler Entered!\n", ioc->name));
6346 #ifdef MFCNT
6347 printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
6348 printk("MF count 0x%x !\n", ioc->mfcnt);
6349 #endif
6350
6351 /* Reset the adapter. Prevent more than 1 call to
6352 * mpt_do_ioc_recovery at any instant in time.
6353 */
6354 spin_lock_irqsave(&ioc->diagLock, flags);
6355 if ((ioc->diagPending) || (ioc->alt_ioc && ioc->alt_ioc->diagPending)){
6356 spin_unlock_irqrestore(&ioc->diagLock, flags);
6357 return 0;
6358 } else {
6359 ioc->diagPending = 1;
6360 }
6361 spin_unlock_irqrestore(&ioc->diagLock, flags);
6362
6363 /* FIXME: If do_ioc_recovery fails, repeat....
6364 */
6365
6366 /* The SCSI driver needs to adjust timeouts on all current
6367 * commands prior to the diagnostic reset being issued.
6368 * Prevents timeouts occurring during a diagnostic reset...very bad.
6369 * For all other protocol drivers, this is a no-op.
6370 */
6371 {
6372 u8 cb_idx;
6373 int r = 0;
6374
6375 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6376 if (MptResetHandlers[cb_idx]) {
6377 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling IOC reset_setup handler #%d\n",
6378 ioc->name, cb_idx));
6379 r += mpt_signal_reset(cb_idx, ioc, MPT_IOC_SETUP_RESET);
6380 if (ioc->alt_ioc) {
6381 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Calling alt-%s setup reset handler #%d\n",
6382 ioc->name, ioc->alt_ioc->name, cb_idx));
6383 r += mpt_signal_reset(cb_idx, ioc->alt_ioc, MPT_IOC_SETUP_RESET);
6384 }
6385 }
6386 }
6387 }
6388
6389 if ((rc = mpt_do_ioc_recovery(ioc, MPT_HOSTEVENT_IOC_RECOVER, sleepFlag)) != 0) {
6390 printk(MYIOC_s_WARN_FMT "Cannot recover rc = %d!\n", ioc->name, rc);
6391 }
6392 ioc->reload_fw = 0;
6393 if (ioc->alt_ioc)
6394 ioc->alt_ioc->reload_fw = 0;
6395
6396 spin_lock_irqsave(&ioc->diagLock, flags);
6397 ioc->diagPending = 0;
6398 if (ioc->alt_ioc)
6399 ioc->alt_ioc->diagPending = 0;
6400 spin_unlock_irqrestore(&ioc->diagLock, flags);
6401
6402 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "HardResetHandler rc = %d!\n", ioc->name, rc));
6403
6404 return rc;
6405 }
6406
6407 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6408 static void
6409 EventDescriptionStr(u8 event, u32 evData0, char *evStr)
6410 {
6411 char *ds = NULL;
6412
6413 switch(event) {
6414 case MPI_EVENT_NONE:
6415 ds = "None";
6416 break;
6417 case MPI_EVENT_LOG_DATA:
6418 ds = "Log Data";
6419 break;
6420 case MPI_EVENT_STATE_CHANGE:
6421 ds = "State Change";
6422 break;
6423 case MPI_EVENT_UNIT_ATTENTION:
6424 ds = "Unit Attention";
6425 break;
6426 case MPI_EVENT_IOC_BUS_RESET:
6427 ds = "IOC Bus Reset";
6428 break;
6429 case MPI_EVENT_EXT_BUS_RESET:
6430 ds = "External Bus Reset";
6431 break;
6432 case MPI_EVENT_RESCAN:
6433 ds = "Bus Rescan Event";
6434 break;
6435 case MPI_EVENT_LINK_STATUS_CHANGE:
6436 if (evData0 == MPI_EVENT_LINK_STATUS_FAILURE)
6437 ds = "Link Status(FAILURE) Change";
6438 else
6439 ds = "Link Status(ACTIVE) Change";
6440 break;
6441 case MPI_EVENT_LOOP_STATE_CHANGE:
6442 if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LIP)
6443 ds = "Loop State(LIP) Change";
6444 else if (evData0 == MPI_EVENT_LOOP_STATE_CHANGE_LPE)
6445 ds = "Loop State(LPE) Change"; /* ??? */
6446 else
6447 ds = "Loop State(LPB) Change"; /* ??? */
6448 break;
6449 case MPI_EVENT_LOGOUT:
6450 ds = "Logout";
6451 break;
6452 case MPI_EVENT_EVENT_CHANGE:
6453 if (evData0)
6454 ds = "Events ON";
6455 else
6456 ds = "Events OFF";
6457 break;
6458 case MPI_EVENT_INTEGRATED_RAID:
6459 {
6460 u8 ReasonCode = (u8)(evData0 >> 16);
6461 switch (ReasonCode) {
6462 case MPI_EVENT_RAID_RC_VOLUME_CREATED :
6463 ds = "Integrated Raid: Volume Created";
6464 break;
6465 case MPI_EVENT_RAID_RC_VOLUME_DELETED :
6466 ds = "Integrated Raid: Volume Deleted";
6467 break;
6468 case MPI_EVENT_RAID_RC_VOLUME_SETTINGS_CHANGED :
6469 ds = "Integrated Raid: Volume Settings Changed";
6470 break;
6471 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED :
6472 ds = "Integrated Raid: Volume Status Changed";
6473 break;
6474 case MPI_EVENT_RAID_RC_VOLUME_PHYSDISK_CHANGED :
6475 ds = "Integrated Raid: Volume Physdisk Changed";
6476 break;
6477 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED :
6478 ds = "Integrated Raid: Physdisk Created";
6479 break;
6480 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED :
6481 ds = "Integrated Raid: Physdisk Deleted";
6482 break;
6483 case MPI_EVENT_RAID_RC_PHYSDISK_SETTINGS_CHANGED :
6484 ds = "Integrated Raid: Physdisk Settings Changed";
6485 break;
6486 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED :
6487 ds = "Integrated Raid: Physdisk Status Changed";
6488 break;
6489 case MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED :
6490 ds = "Integrated Raid: Domain Validation Needed";
6491 break;
6492 case MPI_EVENT_RAID_RC_SMART_DATA :
6493 ds = "Integrated Raid; Smart Data";
6494 break;
6495 case MPI_EVENT_RAID_RC_REPLACE_ACTION_STARTED :
6496 ds = "Integrated Raid: Replace Action Started";
6497 break;
6498 default:
6499 ds = "Integrated Raid";
6500 break;
6501 }
6502 break;
6503 }
6504 case MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE:
6505 ds = "SCSI Device Status Change";
6506 break;
6507 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
6508 {
6509 u8 id = (u8)(evData0);
6510 u8 channel = (u8)(evData0 >> 8);
6511 u8 ReasonCode = (u8)(evData0 >> 16);
6512 switch (ReasonCode) {
6513 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED:
6514 snprintf(evStr, EVENT_DESCR_STR_SZ,
6515 "SAS Device Status Change: Added: "
6516 "id=%d channel=%d", id, channel);
6517 break;
6518 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING:
6519 snprintf(evStr, EVENT_DESCR_STR_SZ,
6520 "SAS Device Status Change: Deleted: "
6521 "id=%d channel=%d", id, channel);
6522 break;
6523 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA:
6524 snprintf(evStr, EVENT_DESCR_STR_SZ,
6525 "SAS Device Status Change: SMART Data: "
6526 "id=%d channel=%d", id, channel);
6527 break;
6528 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED:
6529 snprintf(evStr, EVENT_DESCR_STR_SZ,
6530 "SAS Device Status Change: No Persistancy: "
6531 "id=%d channel=%d", id, channel);
6532 break;
6533 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED:
6534 snprintf(evStr, EVENT_DESCR_STR_SZ,
6535 "SAS Device Status Change: Unsupported Device "
6536 "Discovered : id=%d channel=%d", id, channel);
6537 break;
6538 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET:
6539 snprintf(evStr, EVENT_DESCR_STR_SZ,
6540 "SAS Device Status Change: Internal Device "
6541 "Reset : id=%d channel=%d", id, channel);
6542 break;
6543 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL:
6544 snprintf(evStr, EVENT_DESCR_STR_SZ,
6545 "SAS Device Status Change: Internal Task "
6546 "Abort : id=%d channel=%d", id, channel);
6547 break;
6548 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL:
6549 snprintf(evStr, EVENT_DESCR_STR_SZ,
6550 "SAS Device Status Change: Internal Abort "
6551 "Task Set : id=%d channel=%d", id, channel);
6552 break;
6553 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL:
6554 snprintf(evStr, EVENT_DESCR_STR_SZ,
6555 "SAS Device Status Change: Internal Clear "
6556 "Task Set : id=%d channel=%d", id, channel);
6557 break;
6558 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL:
6559 snprintf(evStr, EVENT_DESCR_STR_SZ,
6560 "SAS Device Status Change: Internal Query "
6561 "Task : id=%d channel=%d", id, channel);
6562 break;
6563 default:
6564 snprintf(evStr, EVENT_DESCR_STR_SZ,
6565 "SAS Device Status Change: Unknown: "
6566 "id=%d channel=%d", id, channel);
6567 break;
6568 }
6569 break;
6570 }
6571 case MPI_EVENT_ON_BUS_TIMER_EXPIRED:
6572 ds = "Bus Timer Expired";
6573 break;
6574 case MPI_EVENT_QUEUE_FULL:
6575 {
6576 u16 curr_depth = (u16)(evData0 >> 16);
6577 u8 channel = (u8)(evData0 >> 8);
6578 u8 id = (u8)(evData0);
6579
6580 snprintf(evStr, EVENT_DESCR_STR_SZ,
6581 "Queue Full: channel=%d id=%d depth=%d",
6582 channel, id, curr_depth);
6583 break;
6584 }
6585 case MPI_EVENT_SAS_SES:
6586 ds = "SAS SES Event";
6587 break;
6588 case MPI_EVENT_PERSISTENT_TABLE_FULL:
6589 ds = "Persistent Table Full";
6590 break;
6591 case MPI_EVENT_SAS_PHY_LINK_STATUS:
6592 {
6593 u8 LinkRates = (u8)(evData0 >> 8);
6594 u8 PhyNumber = (u8)(evData0);
6595 LinkRates = (LinkRates & MPI_EVENT_SAS_PLS_LR_CURRENT_MASK) >>
6596 MPI_EVENT_SAS_PLS_LR_CURRENT_SHIFT;
6597 switch (LinkRates) {
6598 case MPI_EVENT_SAS_PLS_LR_RATE_UNKNOWN:
6599 snprintf(evStr, EVENT_DESCR_STR_SZ,
6600 "SAS PHY Link Status: Phy=%d:"
6601 " Rate Unknown",PhyNumber);
6602 break;
6603 case MPI_EVENT_SAS_PLS_LR_RATE_PHY_DISABLED:
6604 snprintf(evStr, EVENT_DESCR_STR_SZ,
6605 "SAS PHY Link Status: Phy=%d:"
6606 " Phy Disabled",PhyNumber);
6607 break;
6608 case MPI_EVENT_SAS_PLS_LR_RATE_FAILED_SPEED_NEGOTIATION:
6609 snprintf(evStr, EVENT_DESCR_STR_SZ,
6610 "SAS PHY Link Status: Phy=%d:"
6611 " Failed Speed Nego",PhyNumber);
6612 break;
6613 case MPI_EVENT_SAS_PLS_LR_RATE_SATA_OOB_COMPLETE:
6614 snprintf(evStr, EVENT_DESCR_STR_SZ,
6615 "SAS PHY Link Status: Phy=%d:"
6616 " Sata OOB Completed",PhyNumber);
6617 break;
6618 case MPI_EVENT_SAS_PLS_LR_RATE_1_5:
6619 snprintf(evStr, EVENT_DESCR_STR_SZ,
6620 "SAS PHY Link Status: Phy=%d:"
6621 " Rate 1.5 Gbps",PhyNumber);
6622 break;
6623 case MPI_EVENT_SAS_PLS_LR_RATE_3_0:
6624 snprintf(evStr, EVENT_DESCR_STR_SZ,
6625 "SAS PHY Link Status: Phy=%d:"
6626 " Rate 3.0 Gpbs",PhyNumber);
6627 break;
6628 default:
6629 snprintf(evStr, EVENT_DESCR_STR_SZ,
6630 "SAS PHY Link Status: Phy=%d", PhyNumber);
6631 break;
6632 }
6633 break;
6634 }
6635 case MPI_EVENT_SAS_DISCOVERY_ERROR:
6636 ds = "SAS Discovery Error";
6637 break;
6638 case MPI_EVENT_IR_RESYNC_UPDATE:
6639 {
6640 u8 resync_complete = (u8)(evData0 >> 16);
6641 snprintf(evStr, EVENT_DESCR_STR_SZ,
6642 "IR Resync Update: Complete = %d:",resync_complete);
6643 break;
6644 }
6645 case MPI_EVENT_IR2:
6646 {
6647 u8 ReasonCode = (u8)(evData0 >> 16);
6648 switch (ReasonCode) {
6649 case MPI_EVENT_IR2_RC_LD_STATE_CHANGED:
6650 ds = "IR2: LD State Changed";
6651 break;
6652 case MPI_EVENT_IR2_RC_PD_STATE_CHANGED:
6653 ds = "IR2: PD State Changed";
6654 break;
6655 case MPI_EVENT_IR2_RC_BAD_BLOCK_TABLE_FULL:
6656 ds = "IR2: Bad Block Table Full";
6657 break;
6658 case MPI_EVENT_IR2_RC_PD_INSERTED:
6659 ds = "IR2: PD Inserted";
6660 break;
6661 case MPI_EVENT_IR2_RC_PD_REMOVED:
6662 ds = "IR2: PD Removed";
6663 break;
6664 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED:
6665 ds = "IR2: Foreign CFG Detected";
6666 break;
6667 case MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR:
6668 ds = "IR2: Rebuild Medium Error";
6669 break;
6670 default:
6671 ds = "IR2";
6672 break;
6673 }
6674 break;
6675 }
6676 case MPI_EVENT_SAS_DISCOVERY:
6677 {
6678 if (evData0)
6679 ds = "SAS Discovery: Start";
6680 else
6681 ds = "SAS Discovery: Stop";
6682 break;
6683 }
6684 case MPI_EVENT_LOG_ENTRY_ADDED:
6685 ds = "SAS Log Entry Added";
6686 break;
6687
6688 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE:
6689 {
6690 u8 phy_num = (u8)(evData0);
6691 u8 port_num = (u8)(evData0 >> 8);
6692 u8 port_width = (u8)(evData0 >> 16);
6693 u8 primative = (u8)(evData0 >> 24);
6694 snprintf(evStr, EVENT_DESCR_STR_SZ,
6695 "SAS Broadcase Primative: phy=%d port=%d "
6696 "width=%d primative=0x%02x",
6697 phy_num, port_num, port_width, primative);
6698 break;
6699 }
6700
6701 case MPI_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE:
6702 {
6703 u8 reason = (u8)(evData0);
6704 u8 port_num = (u8)(evData0 >> 8);
6705 u16 handle = le16_to_cpu(evData0 >> 16);
6706
6707 snprintf(evStr, EVENT_DESCR_STR_SZ,
6708 "SAS Initiator Device Status Change: reason=0x%02x "
6709 "port=%d handle=0x%04x",
6710 reason, port_num, handle);
6711 break;
6712 }
6713
6714 case MPI_EVENT_SAS_INIT_TABLE_OVERFLOW:
6715 {
6716 u8 max_init = (u8)(evData0);
6717 u8 current_init = (u8)(evData0 >> 8);
6718
6719 snprintf(evStr, EVENT_DESCR_STR_SZ,
6720 "SAS Initiator Device Table Overflow: max initiators=%02d "
6721 "current initators=%02d",
6722 max_init, current_init);
6723 break;
6724 }
6725 case MPI_EVENT_SAS_SMP_ERROR:
6726 {
6727 u8 status = (u8)(evData0);
6728 u8 port_num = (u8)(evData0 >> 8);
6729 u8 result = (u8)(evData0 >> 16);
6730
6731 if (status == MPI_EVENT_SAS_SMP_FUNCTION_RESULT_VALID)
6732 snprintf(evStr, EVENT_DESCR_STR_SZ,
6733 "SAS SMP Error: port=%d result=0x%02x",
6734 port_num, result);
6735 else if (status == MPI_EVENT_SAS_SMP_CRC_ERROR)
6736 snprintf(evStr, EVENT_DESCR_STR_SZ,
6737 "SAS SMP Error: port=%d : CRC Error",
6738 port_num);
6739 else if (status == MPI_EVENT_SAS_SMP_TIMEOUT)
6740 snprintf(evStr, EVENT_DESCR_STR_SZ,
6741 "SAS SMP Error: port=%d : Timeout",
6742 port_num);
6743 else if (status == MPI_EVENT_SAS_SMP_NO_DESTINATION)
6744 snprintf(evStr, EVENT_DESCR_STR_SZ,
6745 "SAS SMP Error: port=%d : No Destination",
6746 port_num);
6747 else if (status == MPI_EVENT_SAS_SMP_BAD_DESTINATION)
6748 snprintf(evStr, EVENT_DESCR_STR_SZ,
6749 "SAS SMP Error: port=%d : Bad Destination",
6750 port_num);
6751 else
6752 snprintf(evStr, EVENT_DESCR_STR_SZ,
6753 "SAS SMP Error: port=%d : status=0x%02x",
6754 port_num, status);
6755 break;
6756 }
6757
6758 /*
6759 * MPT base "custom" events may be added here...
6760 */
6761 default:
6762 ds = "Unknown";
6763 break;
6764 }
6765 if (ds)
6766 strncpy(evStr, ds, EVENT_DESCR_STR_SZ);
6767 }
6768
6769 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6770 /**
6771 * ProcessEventNotification - Route EventNotificationReply to all event handlers
6772 * @ioc: Pointer to MPT_ADAPTER structure
6773 * @pEventReply: Pointer to EventNotification reply frame
6774 * @evHandlers: Pointer to integer, number of event handlers
6775 *
6776 * Routes a received EventNotificationReply to all currently registered
6777 * event handlers.
6778 * Returns sum of event handlers return values.
6779 */
6780 static int
6781 ProcessEventNotification(MPT_ADAPTER *ioc, EventNotificationReply_t *pEventReply, int *evHandlers)
6782 {
6783 u16 evDataLen;
6784 u32 evData0 = 0;
6785 // u32 evCtx;
6786 int ii;
6787 u8 cb_idx;
6788 int r = 0;
6789 int handlers = 0;
6790 char evStr[EVENT_DESCR_STR_SZ];
6791 u8 event;
6792
6793 /*
6794 * Do platform normalization of values
6795 */
6796 event = le32_to_cpu(pEventReply->Event) & 0xFF;
6797 // evCtx = le32_to_cpu(pEventReply->EventContext);
6798 evDataLen = le16_to_cpu(pEventReply->EventDataLength);
6799 if (evDataLen) {
6800 evData0 = le32_to_cpu(pEventReply->Data[0]);
6801 }
6802
6803 EventDescriptionStr(event, evData0, evStr);
6804 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event:(%02Xh) : %s\n",
6805 ioc->name,
6806 event,
6807 evStr));
6808
6809 #ifdef CONFIG_FUSION_LOGGING
6810 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6811 ": Event data:\n", ioc->name));
6812 for (ii = 0; ii < evDataLen; ii++)
6813 devtverboseprintk(ioc, printk(" %08x",
6814 le32_to_cpu(pEventReply->Data[ii])));
6815 devtverboseprintk(ioc, printk("\n"));
6816 #endif
6817
6818 /*
6819 * Do general / base driver event processing
6820 */
6821 switch(event) {
6822 case MPI_EVENT_EVENT_CHANGE: /* 0A */
6823 if (evDataLen) {
6824 u8 evState = evData0 & 0xFF;
6825
6826 /* CHECKME! What if evState unexpectedly says OFF (0)? */
6827
6828 /* Update EventState field in cached IocFacts */
6829 if (ioc->facts.Function) {
6830 ioc->facts.EventState = evState;
6831 }
6832 }
6833 break;
6834 case MPI_EVENT_INTEGRATED_RAID:
6835 mptbase_raid_process_event_data(ioc,
6836 (MpiEventDataRaid_t *)pEventReply->Data);
6837 break;
6838 default:
6839 break;
6840 }
6841
6842 /*
6843 * Should this event be logged? Events are written sequentially.
6844 * When buffer is full, start again at the top.
6845 */
6846 if (ioc->events && (ioc->eventTypes & ( 1 << event))) {
6847 int idx;
6848
6849 idx = ioc->eventContext % MPTCTL_EVENT_LOG_SIZE;
6850
6851 ioc->events[idx].event = event;
6852 ioc->events[idx].eventContext = ioc->eventContext;
6853
6854 for (ii = 0; ii < 2; ii++) {
6855 if (ii < evDataLen)
6856 ioc->events[idx].data[ii] = le32_to_cpu(pEventReply->Data[ii]);
6857 else
6858 ioc->events[idx].data[ii] = 0;
6859 }
6860
6861 ioc->eventContext++;
6862 }
6863
6864
6865 /*
6866 * Call each currently registered protocol event handler.
6867 */
6868 for (cb_idx = MPT_MAX_PROTOCOL_DRIVERS-1; cb_idx; cb_idx--) {
6869 if (MptEvHandlers[cb_idx]) {
6870 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Routing Event to event handler #%d\n",
6871 ioc->name, cb_idx));
6872 r += (*(MptEvHandlers[cb_idx]))(ioc, pEventReply);
6873 handlers++;
6874 }
6875 }
6876 /* FIXME? Examine results here? */
6877
6878 /*
6879 * If needed, send (a single) EventAck.
6880 */
6881 if (pEventReply->AckRequired == MPI_EVENT_NOTIFICATION_ACK_REQUIRED) {
6882 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT
6883 "EventAck required\n",ioc->name));
6884 if ((ii = SendEventAck(ioc, pEventReply)) != 0) {
6885 devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SendEventAck returned %d\n",
6886 ioc->name, ii));
6887 }
6888 }
6889
6890 *evHandlers = handlers;
6891 return r;
6892 }
6893
6894 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6895 /**
6896 * mpt_fc_log_info - Log information returned from Fibre Channel IOC.
6897 * @ioc: Pointer to MPT_ADAPTER structure
6898 * @log_info: U32 LogInfo reply word from the IOC
6899 *
6900 * Refer to lsi/mpi_log_fc.h.
6901 */
6902 static void
6903 mpt_fc_log_info(MPT_ADAPTER *ioc, u32 log_info)
6904 {
6905 char *desc = "unknown";
6906
6907 switch (log_info & 0xFF000000) {
6908 case MPI_IOCLOGINFO_FC_INIT_BASE:
6909 desc = "FCP Initiator";
6910 break;
6911 case MPI_IOCLOGINFO_FC_TARGET_BASE:
6912 desc = "FCP Target";
6913 break;
6914 case MPI_IOCLOGINFO_FC_LAN_BASE:
6915 desc = "LAN";
6916 break;
6917 case MPI_IOCLOGINFO_FC_MSG_BASE:
6918 desc = "MPI Message Layer";
6919 break;
6920 case MPI_IOCLOGINFO_FC_LINK_BASE:
6921 desc = "FC Link";
6922 break;
6923 case MPI_IOCLOGINFO_FC_CTX_BASE:
6924 desc = "Context Manager";
6925 break;
6926 case MPI_IOCLOGINFO_FC_INVALID_FIELD_BYTE_OFFSET:
6927 desc = "Invalid Field Offset";
6928 break;
6929 case MPI_IOCLOGINFO_FC_STATE_CHANGE:
6930 desc = "State Change Info";
6931 break;
6932 }
6933
6934 printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): SubClass={%s}, Value=(0x%06x)\n",
6935 ioc->name, log_info, desc, (log_info & 0xFFFFFF));
6936 }
6937
6938 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
6939 /**
6940 * mpt_spi_log_info - Log information returned from SCSI Parallel IOC.
6941 * @ioc: Pointer to MPT_ADAPTER structure
6942 * @mr: Pointer to MPT reply frame
6943 * @log_info: U32 LogInfo word from the IOC
6944 *
6945 * Refer to lsi/sp_log.h.
6946 */
6947 static void
6948 mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
6949 {
6950 u32 info = log_info & 0x00FF0000;
6951 char *desc = "unknown";
6952
6953 switch (info) {
6954 case 0x00010000:
6955 desc = "bug! MID not found";
6956 if (ioc->reload_fw == 0)
6957 ioc->reload_fw++;
6958 break;
6959
6960 case 0x00020000:
6961 desc = "Parity Error";
6962 break;
6963
6964 case 0x00030000:
6965 desc = "ASYNC Outbound Overrun";
6966 break;
6967
6968 case 0x00040000:
6969 desc = "SYNC Offset Error";
6970 break;
6971
6972 case 0x00050000:
6973 desc = "BM Change";
6974 break;
6975
6976 case 0x00060000:
6977 desc = "Msg In Overflow";
6978 break;
6979
6980 case 0x00070000:
6981 desc = "DMA Error";
6982 break;
6983
6984 case 0x00080000:
6985 desc = "Outbound DMA Overrun";
6986 break;
6987
6988 case 0x00090000:
6989 desc = "Task Management";
6990 break;
6991
6992 case 0x000A0000:
6993 desc = "Device Problem";
6994 break;
6995
6996 case 0x000B0000:
6997 desc = "Invalid Phase Change";
6998 break;
6999
7000 case 0x000C0000:
7001 desc = "Untagged Table Size";
7002 break;
7003
7004 }
7005
7006 printk(MYIOC_s_INFO_FMT "LogInfo(0x%08x): F/W: %s\n", ioc->name, log_info, desc);
7007 }
7008
7009 /* strings for sas loginfo */
7010 static char *originator_str[] = {
7011 "IOP", /* 00h */
7012 "PL", /* 01h */
7013 "IR" /* 02h */
7014 };
7015 static char *iop_code_str[] = {
7016 NULL, /* 00h */
7017 "Invalid SAS Address", /* 01h */
7018 NULL, /* 02h */
7019 "Invalid Page", /* 03h */
7020 "Diag Message Error", /* 04h */
7021 "Task Terminated", /* 05h */
7022 "Enclosure Management", /* 06h */
7023 "Target Mode" /* 07h */
7024 };
7025 static char *pl_code_str[] = {
7026 NULL, /* 00h */
7027 "Open Failure", /* 01h */
7028 "Invalid Scatter Gather List", /* 02h */
7029 "Wrong Relative Offset or Frame Length", /* 03h */
7030 "Frame Transfer Error", /* 04h */
7031 "Transmit Frame Connected Low", /* 05h */
7032 "SATA Non-NCQ RW Error Bit Set", /* 06h */
7033 "SATA Read Log Receive Data Error", /* 07h */
7034 "SATA NCQ Fail All Commands After Error", /* 08h */
7035 "SATA Error in Receive Set Device Bit FIS", /* 09h */
7036 "Receive Frame Invalid Message", /* 0Ah */
7037 "Receive Context Message Valid Error", /* 0Bh */
7038 "Receive Frame Current Frame Error", /* 0Ch */
7039 "SATA Link Down", /* 0Dh */
7040 "Discovery SATA Init W IOS", /* 0Eh */
7041 "Config Invalid Page", /* 0Fh */
7042 "Discovery SATA Init Timeout", /* 10h */
7043 "Reset", /* 11h */
7044 "Abort", /* 12h */
7045 "IO Not Yet Executed", /* 13h */
7046 "IO Executed", /* 14h */
7047 "Persistent Reservation Out Not Affiliation "
7048 "Owner", /* 15h */
7049 "Open Transmit DMA Abort", /* 16h */
7050 "IO Device Missing Delay Retry", /* 17h */
7051 "IO Cancelled Due to Recieve Error", /* 18h */
7052 NULL, /* 19h */
7053 NULL, /* 1Ah */
7054 NULL, /* 1Bh */
7055 NULL, /* 1Ch */
7056 NULL, /* 1Dh */
7057 NULL, /* 1Eh */
7058 NULL, /* 1Fh */
7059 "Enclosure Management" /* 20h */
7060 };
7061 static char *ir_code_str[] = {
7062 "Raid Action Error", /* 00h */
7063 NULL, /* 00h */
7064 NULL, /* 01h */
7065 NULL, /* 02h */
7066 NULL, /* 03h */
7067 NULL, /* 04h */
7068 NULL, /* 05h */
7069 NULL, /* 06h */
7070 NULL /* 07h */
7071 };
7072 static char *raid_sub_code_str[] = {
7073 NULL, /* 00h */
7074 "Volume Creation Failed: Data Passed too "
7075 "Large", /* 01h */
7076 "Volume Creation Failed: Duplicate Volumes "
7077 "Attempted", /* 02h */
7078 "Volume Creation Failed: Max Number "
7079 "Supported Volumes Exceeded", /* 03h */
7080 "Volume Creation Failed: DMA Error", /* 04h */
7081 "Volume Creation Failed: Invalid Volume Type", /* 05h */
7082 "Volume Creation Failed: Error Reading "
7083 "MFG Page 4", /* 06h */
7084 "Volume Creation Failed: Creating Internal "
7085 "Structures", /* 07h */
7086 NULL, /* 08h */
7087 NULL, /* 09h */
7088 NULL, /* 0Ah */
7089 NULL, /* 0Bh */
7090 NULL, /* 0Ch */
7091 NULL, /* 0Dh */
7092 NULL, /* 0Eh */
7093 NULL, /* 0Fh */
7094 "Activation failed: Already Active Volume", /* 10h */
7095 "Activation failed: Unsupported Volume Type", /* 11h */
7096 "Activation failed: Too Many Active Volumes", /* 12h */
7097 "Activation failed: Volume ID in Use", /* 13h */
7098 "Activation failed: Reported Failure", /* 14h */
7099 "Activation failed: Importing a Volume", /* 15h */
7100 NULL, /* 16h */
7101 NULL, /* 17h */
7102 NULL, /* 18h */
7103 NULL, /* 19h */
7104 NULL, /* 1Ah */
7105 NULL, /* 1Bh */
7106 NULL, /* 1Ch */
7107 NULL, /* 1Dh */
7108 NULL, /* 1Eh */
7109 NULL, /* 1Fh */
7110 "Phys Disk failed: Too Many Phys Disks", /* 20h */
7111 "Phys Disk failed: Data Passed too Large", /* 21h */
7112 "Phys Disk failed: DMA Error", /* 22h */
7113 "Phys Disk failed: Invalid <channel:id>", /* 23h */
7114 "Phys Disk failed: Creating Phys Disk Config "
7115 "Page", /* 24h */
7116 NULL, /* 25h */
7117 NULL, /* 26h */
7118 NULL, /* 27h */
7119 NULL, /* 28h */
7120 NULL, /* 29h */
7121 NULL, /* 2Ah */
7122 NULL, /* 2Bh */
7123 NULL, /* 2Ch */
7124 NULL, /* 2Dh */
7125 NULL, /* 2Eh */
7126 NULL, /* 2Fh */
7127 "Compatibility Error: IR Disabled", /* 30h */
7128 "Compatibility Error: Inquiry Comand Failed", /* 31h */
7129 "Compatibility Error: Device not Direct Access "
7130 "Device ", /* 32h */
7131 "Compatibility Error: Removable Device Found", /* 33h */
7132 "Compatibility Error: Device SCSI Version not "
7133 "2 or Higher", /* 34h */
7134 "Compatibility Error: SATA Device, 48 BIT LBA "
7135 "not Supported", /* 35h */
7136 "Compatibility Error: Device doesn't have "
7137 "512 Byte Block Sizes", /* 36h */
7138 "Compatibility Error: Volume Type Check Failed", /* 37h */
7139 "Compatibility Error: Volume Type is "
7140 "Unsupported by FW", /* 38h */
7141 "Compatibility Error: Disk Drive too Small for "
7142 "use in Volume", /* 39h */
7143 "Compatibility Error: Phys Disk for Create "
7144 "Volume not Found", /* 3Ah */
7145 "Compatibility Error: Too Many or too Few "
7146 "Disks for Volume Type", /* 3Bh */
7147 "Compatibility Error: Disk stripe Sizes "
7148 "Must be 64KB", /* 3Ch */
7149 "Compatibility Error: IME Size Limited to < 2TB", /* 3Dh */
7150 };
7151
7152 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7153 /**
7154 * mpt_sas_log_info - Log information returned from SAS IOC.
7155 * @ioc: Pointer to MPT_ADAPTER structure
7156 * @log_info: U32 LogInfo reply word from the IOC
7157 *
7158 * Refer to lsi/mpi_log_sas.h.
7159 **/
7160 static void
7161 mpt_sas_log_info(MPT_ADAPTER *ioc, u32 log_info)
7162 {
7163 union loginfo_type {
7164 u32 loginfo;
7165 struct {
7166 u32 subcode:16;
7167 u32 code:8;
7168 u32 originator:4;
7169 u32 bus_type:4;
7170 }dw;
7171 };
7172 union loginfo_type sas_loginfo;
7173 char *originator_desc = NULL;
7174 char *code_desc = NULL;
7175 char *sub_code_desc = NULL;
7176
7177 sas_loginfo.loginfo = log_info;
7178 if ((sas_loginfo.dw.bus_type != 3 /*SAS*/) &&
7179 (sas_loginfo.dw.originator < sizeof(originator_str)/sizeof(char*)))
7180 return;
7181
7182 originator_desc = originator_str[sas_loginfo.dw.originator];
7183
7184 switch (sas_loginfo.dw.originator) {
7185
7186 case 0: /* IOP */
7187 if (sas_loginfo.dw.code <
7188 sizeof(iop_code_str)/sizeof(char*))
7189 code_desc = iop_code_str[sas_loginfo.dw.code];
7190 break;
7191 case 1: /* PL */
7192 if (sas_loginfo.dw.code <
7193 sizeof(pl_code_str)/sizeof(char*))
7194 code_desc = pl_code_str[sas_loginfo.dw.code];
7195 break;
7196 case 2: /* IR */
7197 if (sas_loginfo.dw.code >=
7198 sizeof(ir_code_str)/sizeof(char*))
7199 break;
7200 code_desc = ir_code_str[sas_loginfo.dw.code];
7201 if (sas_loginfo.dw.subcode >=
7202 sizeof(raid_sub_code_str)/sizeof(char*))
7203 break;
7204 if (sas_loginfo.dw.code == 0)
7205 sub_code_desc =
7206 raid_sub_code_str[sas_loginfo.dw.subcode];
7207 break;
7208 default:
7209 return;
7210 }
7211
7212 if (sub_code_desc != NULL)
7213 printk(MYIOC_s_INFO_FMT
7214 "LogInfo(0x%08x): Originator={%s}, Code={%s},"
7215 " SubCode={%s}\n",
7216 ioc->name, log_info, originator_desc, code_desc,
7217 sub_code_desc);
7218 else if (code_desc != NULL)
7219 printk(MYIOC_s_INFO_FMT
7220 "LogInfo(0x%08x): Originator={%s}, Code={%s},"
7221 " SubCode(0x%04x)\n",
7222 ioc->name, log_info, originator_desc, code_desc,
7223 sas_loginfo.dw.subcode);
7224 else
7225 printk(MYIOC_s_INFO_FMT
7226 "LogInfo(0x%08x): Originator={%s}, Code=(0x%02x),"
7227 " SubCode(0x%04x)\n",
7228 ioc->name, log_info, originator_desc,
7229 sas_loginfo.dw.code, sas_loginfo.dw.subcode);
7230 }
7231
7232 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7233 /**
7234 * mpt_iocstatus_info_config - IOCSTATUS information for config pages
7235 * @ioc: Pointer to MPT_ADAPTER structure
7236 * @ioc_status: U32 IOCStatus word from IOC
7237 * @mf: Pointer to MPT request frame
7238 *
7239 * Refer to lsi/mpi.h.
7240 **/
7241 static void
7242 mpt_iocstatus_info_config(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
7243 {
7244 Config_t *pReq = (Config_t *)mf;
7245 char extend_desc[EVENT_DESCR_STR_SZ];
7246 char *desc = NULL;
7247 u32 form;
7248 u8 page_type;
7249
7250 if (pReq->Header.PageType == MPI_CONFIG_PAGETYPE_EXTENDED)
7251 page_type = pReq->ExtPageType;
7252 else
7253 page_type = pReq->Header.PageType;
7254
7255 /*
7256 * ignore invalid page messages for GET_NEXT_HANDLE
7257 */
7258 form = le32_to_cpu(pReq->PageAddress);
7259 if (ioc_status == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) {
7260 if (page_type == MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE ||
7261 page_type == MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER ||
7262 page_type == MPI_CONFIG_EXTPAGETYPE_ENCLOSURE) {
7263 if ((form >> MPI_SAS_DEVICE_PGAD_FORM_SHIFT) ==
7264 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE)
7265 return;
7266 }
7267 if (page_type == MPI_CONFIG_PAGETYPE_FC_DEVICE)
7268 if ((form & MPI_FC_DEVICE_PGAD_FORM_MASK) ==
7269 MPI_FC_DEVICE_PGAD_FORM_NEXT_DID)
7270 return;
7271 }
7272
7273 snprintf(extend_desc, EVENT_DESCR_STR_SZ,
7274 "type=%02Xh, page=%02Xh, action=%02Xh, form=%08Xh",
7275 page_type, pReq->Header.PageNumber, pReq->Action, form);
7276
7277 switch (ioc_status) {
7278
7279 case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
7280 desc = "Config Page Invalid Action";
7281 break;
7282
7283 case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
7284 desc = "Config Page Invalid Type";
7285 break;
7286
7287 case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
7288 desc = "Config Page Invalid Page";
7289 break;
7290
7291 case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
7292 desc = "Config Page Invalid Data";
7293 break;
7294
7295 case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
7296 desc = "Config Page No Defaults";
7297 break;
7298
7299 case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
7300 desc = "Config Page Can't Commit";
7301 break;
7302 }
7303
7304 if (!desc)
7305 return;
7306
7307 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s: %s\n",
7308 ioc->name, ioc_status, desc, extend_desc));
7309 }
7310
7311 /**
7312 * mpt_iocstatus_info - IOCSTATUS information returned from IOC.
7313 * @ioc: Pointer to MPT_ADAPTER structure
7314 * @ioc_status: U32 IOCStatus word from IOC
7315 * @mf: Pointer to MPT request frame
7316 *
7317 * Refer to lsi/mpi.h.
7318 **/
7319 static void
7320 mpt_iocstatus_info(MPT_ADAPTER *ioc, u32 ioc_status, MPT_FRAME_HDR *mf)
7321 {
7322 u32 status = ioc_status & MPI_IOCSTATUS_MASK;
7323 char *desc = NULL;
7324
7325 switch (status) {
7326
7327 /****************************************************************************/
7328 /* Common IOCStatus values for all replies */
7329 /****************************************************************************/
7330
7331 case MPI_IOCSTATUS_INVALID_FUNCTION: /* 0x0001 */
7332 desc = "Invalid Function";
7333 break;
7334
7335 case MPI_IOCSTATUS_BUSY: /* 0x0002 */
7336 desc = "Busy";
7337 break;
7338
7339 case MPI_IOCSTATUS_INVALID_SGL: /* 0x0003 */
7340 desc = "Invalid SGL";
7341 break;
7342
7343 case MPI_IOCSTATUS_INTERNAL_ERROR: /* 0x0004 */
7344 desc = "Internal Error";
7345 break;
7346
7347 case MPI_IOCSTATUS_RESERVED: /* 0x0005 */
7348 desc = "Reserved";
7349 break;
7350
7351 case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: /* 0x0006 */
7352 desc = "Insufficient Resources";
7353 break;
7354
7355 case MPI_IOCSTATUS_INVALID_FIELD: /* 0x0007 */
7356 desc = "Invalid Field";
7357 break;
7358
7359 case MPI_IOCSTATUS_INVALID_STATE: /* 0x0008 */
7360 desc = "Invalid State";
7361 break;
7362
7363 /****************************************************************************/
7364 /* Config IOCStatus values */
7365 /****************************************************************************/
7366
7367 case MPI_IOCSTATUS_CONFIG_INVALID_ACTION: /* 0x0020 */
7368 case MPI_IOCSTATUS_CONFIG_INVALID_TYPE: /* 0x0021 */
7369 case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: /* 0x0022 */
7370 case MPI_IOCSTATUS_CONFIG_INVALID_DATA: /* 0x0023 */
7371 case MPI_IOCSTATUS_CONFIG_NO_DEFAULTS: /* 0x0024 */
7372 case MPI_IOCSTATUS_CONFIG_CANT_COMMIT: /* 0x0025 */
7373 mpt_iocstatus_info_config(ioc, status, mf);
7374 break;
7375
7376 /****************************************************************************/
7377 /* SCSIIO Reply (SPI, FCP, SAS) initiator values */
7378 /* */
7379 /* Look at mptscsih_iocstatus_info_scsiio in mptscsih.c */
7380 /* */
7381 /****************************************************************************/
7382
7383 case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: /* 0x0040 */
7384 case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* 0x0045 */
7385 case MPI_IOCSTATUS_SCSI_INVALID_BUS: /* 0x0041 */
7386 case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: /* 0x0042 */
7387 case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: /* 0x0043 */
7388 case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: /* 0x0044 */
7389 case MPI_IOCSTATUS_SCSI_IO_DATA_ERROR: /* 0x0046 */
7390 case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* 0x0047 */
7391 case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* 0x0048 */
7392 case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: /* 0x0049 */
7393 case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* 0x004A */
7394 case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* 0x004B */
7395 case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* 0x004C */
7396 break;
7397
7398 /****************************************************************************/
7399 /* SCSI Target values */
7400 /****************************************************************************/
7401
7402 case MPI_IOCSTATUS_TARGET_PRIORITY_IO: /* 0x0060 */
7403 desc = "Target: Priority IO";
7404 break;
7405
7406 case MPI_IOCSTATUS_TARGET_INVALID_PORT: /* 0x0061 */
7407 desc = "Target: Invalid Port";
7408 break;
7409
7410 case MPI_IOCSTATUS_TARGET_INVALID_IO_INDEX: /* 0x0062 */
7411 desc = "Target Invalid IO Index:";
7412 break;
7413
7414 case MPI_IOCSTATUS_TARGET_ABORTED: /* 0x0063 */
7415 desc = "Target: Aborted";
7416 break;
7417
7418 case MPI_IOCSTATUS_TARGET_NO_CONN_RETRYABLE: /* 0x0064 */
7419 desc = "Target: No Conn Retryable";
7420 break;
7421
7422 case MPI_IOCSTATUS_TARGET_NO_CONNECTION: /* 0x0065 */
7423 desc = "Target: No Connection";
7424 break;
7425
7426 case MPI_IOCSTATUS_TARGET_XFER_COUNT_MISMATCH: /* 0x006A */
7427 desc = "Target: Transfer Count Mismatch";
7428 break;
7429
7430 case MPI_IOCSTATUS_TARGET_STS_DATA_NOT_SENT: /* 0x006B */
7431 desc = "Target: STS Data not Sent";
7432 break;
7433
7434 case MPI_IOCSTATUS_TARGET_DATA_OFFSET_ERROR: /* 0x006D */
7435 desc = "Target: Data Offset Error";
7436 break;
7437
7438 case MPI_IOCSTATUS_TARGET_TOO_MUCH_WRITE_DATA: /* 0x006E */
7439 desc = "Target: Too Much Write Data";
7440 break;
7441
7442 case MPI_IOCSTATUS_TARGET_IU_TOO_SHORT: /* 0x006F */
7443 desc = "Target: IU Too Short";
7444 break;
7445
7446 case MPI_IOCSTATUS_TARGET_ACK_NAK_TIMEOUT: /* 0x0070 */
7447 desc = "Target: ACK NAK Timeout";
7448 break;
7449
7450 case MPI_IOCSTATUS_TARGET_NAK_RECEIVED: /* 0x0071 */
7451 desc = "Target: Nak Received";
7452 break;
7453
7454 /****************************************************************************/
7455 /* Fibre Channel Direct Access values */
7456 /****************************************************************************/
7457
7458 case MPI_IOCSTATUS_FC_ABORTED: /* 0x0066 */
7459 desc = "FC: Aborted";
7460 break;
7461
7462 case MPI_IOCSTATUS_FC_RX_ID_INVALID: /* 0x0067 */
7463 desc = "FC: RX ID Invalid";
7464 break;
7465
7466 case MPI_IOCSTATUS_FC_DID_INVALID: /* 0x0068 */
7467 desc = "FC: DID Invalid";
7468 break;
7469
7470 case MPI_IOCSTATUS_FC_NODE_LOGGED_OUT: /* 0x0069 */
7471 desc = "FC: Node Logged Out";
7472 break;
7473
7474 case MPI_IOCSTATUS_FC_EXCHANGE_CANCELED: /* 0x006C */
7475 desc = "FC: Exchange Canceled";
7476 break;
7477
7478 /****************************************************************************/
7479 /* LAN values */
7480 /****************************************************************************/
7481
7482 case MPI_IOCSTATUS_LAN_DEVICE_NOT_FOUND: /* 0x0080 */
7483 desc = "LAN: Device not Found";
7484 break;
7485
7486 case MPI_IOCSTATUS_LAN_DEVICE_FAILURE: /* 0x0081 */
7487 desc = "LAN: Device Failure";
7488 break;
7489
7490 case MPI_IOCSTATUS_LAN_TRANSMIT_ERROR: /* 0x0082 */
7491 desc = "LAN: Transmit Error";
7492 break;
7493
7494 case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED: /* 0x0083 */
7495 desc = "LAN: Transmit Aborted";
7496 break;
7497
7498 case MPI_IOCSTATUS_LAN_RECEIVE_ERROR: /* 0x0084 */
7499 desc = "LAN: Receive Error";
7500 break;
7501
7502 case MPI_IOCSTATUS_LAN_RECEIVE_ABORTED: /* 0x0085 */
7503 desc = "LAN: Receive Aborted";
7504 break;
7505
7506 case MPI_IOCSTATUS_LAN_PARTIAL_PACKET: /* 0x0086 */
7507 desc = "LAN: Partial Packet";
7508 break;
7509
7510 case MPI_IOCSTATUS_LAN_CANCELED: /* 0x0087 */
7511 desc = "LAN: Canceled";
7512 break;
7513
7514 /****************************************************************************/
7515 /* Serial Attached SCSI values */
7516 /****************************************************************************/
7517
7518 case MPI_IOCSTATUS_SAS_SMP_REQUEST_FAILED: /* 0x0090 */
7519 desc = "SAS: SMP Request Failed";
7520 break;
7521
7522 case MPI_IOCSTATUS_SAS_SMP_DATA_OVERRUN: /* 0x0090 */
7523 desc = "SAS: SMP Data Overrun";
7524 break;
7525
7526 default:
7527 desc = "Others";
7528 break;
7529 }
7530
7531 if (!desc)
7532 return;
7533
7534 dreplyprintk(ioc, printk(MYIOC_s_DEBUG_FMT "IOCStatus(0x%04X): %s\n",
7535 ioc->name, status, desc));
7536 }
7537
7538 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7539 EXPORT_SYMBOL(mpt_attach);
7540 EXPORT_SYMBOL(mpt_detach);
7541 #ifdef CONFIG_PM
7542 EXPORT_SYMBOL(mpt_resume);
7543 EXPORT_SYMBOL(mpt_suspend);
7544 #endif
7545 EXPORT_SYMBOL(ioc_list);
7546 EXPORT_SYMBOL(mpt_register);
7547 EXPORT_SYMBOL(mpt_deregister);
7548 EXPORT_SYMBOL(mpt_event_register);
7549 EXPORT_SYMBOL(mpt_event_deregister);
7550 EXPORT_SYMBOL(mpt_reset_register);
7551 EXPORT_SYMBOL(mpt_reset_deregister);
7552 EXPORT_SYMBOL(mpt_device_driver_register);
7553 EXPORT_SYMBOL(mpt_device_driver_deregister);
7554 EXPORT_SYMBOL(mpt_get_msg_frame);
7555 EXPORT_SYMBOL(mpt_put_msg_frame);
7556 EXPORT_SYMBOL(mpt_put_msg_frame_hi_pri);
7557 EXPORT_SYMBOL(mpt_free_msg_frame);
7558 EXPORT_SYMBOL(mpt_add_sge);
7559 EXPORT_SYMBOL(mpt_send_handshake_request);
7560 EXPORT_SYMBOL(mpt_verify_adapter);
7561 EXPORT_SYMBOL(mpt_GetIocState);
7562 EXPORT_SYMBOL(mpt_print_ioc_summary);
7563 EXPORT_SYMBOL(mpt_HardResetHandler);
7564 EXPORT_SYMBOL(mpt_config);
7565 EXPORT_SYMBOL(mpt_findImVolumes);
7566 EXPORT_SYMBOL(mpt_alloc_fw_memory);
7567 EXPORT_SYMBOL(mpt_free_fw_memory);
7568 EXPORT_SYMBOL(mptbase_sas_persist_operation);
7569 EXPORT_SYMBOL(mpt_raid_phys_disk_pg0);
7570
7571 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7572 /**
7573 * fusion_init - Fusion MPT base driver initialization routine.
7574 *
7575 * Returns 0 for success, non-zero for failure.
7576 */
7577 static int __init
7578 fusion_init(void)
7579 {
7580 u8 cb_idx;
7581
7582 show_mptmod_ver(my_NAME, my_VERSION);
7583 printk(KERN_INFO COPYRIGHT "\n");
7584
7585 for (cb_idx = 0; cb_idx < MPT_MAX_PROTOCOL_DRIVERS; cb_idx++) {
7586 MptCallbacks[cb_idx] = NULL;
7587 MptDriverClass[cb_idx] = MPTUNKNOWN_DRIVER;
7588 MptEvHandlers[cb_idx] = NULL;
7589 MptResetHandlers[cb_idx] = NULL;
7590 }
7591
7592 /* Register ourselves (mptbase) in order to facilitate
7593 * EventNotification handling.
7594 */
7595 mpt_base_index = mpt_register(mpt_base_reply, MPTBASE_DRIVER);
7596
7597 /* Register for hard reset handling callbacks.
7598 */
7599 mpt_reset_register(mpt_base_index, mpt_ioc_reset);
7600
7601 #ifdef CONFIG_PROC_FS
7602 (void) procmpt_create();
7603 #endif
7604 return 0;
7605 }
7606
7607 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
7608 /**
7609 * fusion_exit - Perform driver unload cleanup.
7610 *
7611 * This routine frees all resources associated with each MPT adapter
7612 * and removes all %MPT_PROCFS_MPTBASEDIR entries.
7613 */
7614 static void __exit
7615 fusion_exit(void)
7616 {
7617
7618 mpt_reset_deregister(mpt_base_index);
7619
7620 #ifdef CONFIG_PROC_FS
7621 procmpt_destroy();
7622 #endif
7623 }
7624
7625 module_init(fusion_init);
7626 module_exit(fusion_exit);
Support for the Chinese Samsung S3C2440 based development boards