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