?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / message / fusion / mptfc.c
blobc819c23b55b1aeb3ca477fd6c689c9cbc0134ff3
1 /*
2 * linux/drivers/message/fusion/mptfc.c
3 * For use with LSI Logic PCI chip/adapter(s)
4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
5 *
6 * Copyright (c) 1999-2007 LSI Logic Corporation
7 * (mailto:mpt_linux_developer@lsil.com)
8 *
9 */
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11 /*
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; version 2 of the License.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 NO WARRANTY
22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26 solely responsible for determining the appropriateness of using and
27 distributing the Program and assumes all risks associated with its
28 exercise of rights under this Agreement, including but not limited to
29 the risks and costs of program errors, damage to or loss of data,
30 programs or equipment, and unavailability or interruption of operations.
31
32 DISCLAIMER OF LIABILITY
33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40
41 You should have received a copy of the GNU General Public License
42 along with this program; if not, write to the Free Software
43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44 */
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46 #include "linux_compat.h" /* linux-2.6 tweaks */
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/init.h>
50 #include <linux/errno.h>
51 #include <linux/kdev_t.h>
52 #include <linux/blkdev.h>
53 #include <linux/delay.h> /* for mdelay */
54 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
55 #include <linux/reboot.h> /* notifier code */
56 #include <linux/sched.h>
57 #include <linux/workqueue.h>
58 #include <linux/sort.h>
59
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_device.h>
63 #include <scsi/scsi_host.h>
64 #include <scsi/scsi_tcq.h>
65 #include <scsi/scsi_transport_fc.h>
66
67 #include "mptbase.h"
68 #include "mptscsih.h"
69
70 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
71 #define my_NAME "Fusion MPT FC Host driver"
72 #define my_VERSION MPT_LINUX_VERSION_COMMON
73 #define MYNAM "mptfc"
74
75 MODULE_AUTHOR(MODULEAUTHOR);
76 MODULE_DESCRIPTION(my_NAME);
77 MODULE_LICENSE("GPL");
78 MODULE_VERSION(my_VERSION);
79
80 /* Command line args */
81 #define MPTFC_DEV_LOSS_TMO (60)
82 static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO; /* reasonable default */
83 module_param(mptfc_dev_loss_tmo, int, 0);
84 MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the "
85 " transport to wait for an rport to "
86 " return following a device loss event."
87 " Default=60.");
88
89 static int mptfcDoneCtx = -1;
90 static int mptfcTaskCtx = -1;
91 static int mptfcInternalCtx = -1; /* Used only for internal commands */
92
93 static int mptfc_target_alloc(struct scsi_target *starget);
94 static int mptfc_slave_alloc(struct scsi_device *sdev);
95 static int mptfc_qcmd(struct scsi_cmnd *SCpnt,
96 void (*done)(struct scsi_cmnd *));
97 static void mptfc_target_destroy(struct scsi_target *starget);
98 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
99 static void __devexit mptfc_remove(struct pci_dev *pdev);
100 static int mptfc_abort(struct scsi_cmnd *SCpnt);
101 static int mptfc_dev_reset(struct scsi_cmnd *SCpnt);
102 static int mptfc_bus_reset(struct scsi_cmnd *SCpnt);
103 static int mptfc_host_reset(struct scsi_cmnd *SCpnt);
104
105 static struct scsi_host_template mptfc_driver_template = {
106 .module = THIS_MODULE,
107 .proc_name = "mptfc",
108 .proc_info = mptscsih_proc_info,
109 .name = "MPT FC Host",
110 .info = mptscsih_info,
111 .queuecommand = mptfc_qcmd,
112 .target_alloc = mptfc_target_alloc,
113 .slave_alloc = mptfc_slave_alloc,
114 .slave_configure = mptscsih_slave_configure,
115 .target_destroy = mptfc_target_destroy,
116 .slave_destroy = mptscsih_slave_destroy,
117 .change_queue_depth = mptscsih_change_queue_depth,
118 .eh_abort_handler = mptfc_abort,
119 .eh_device_reset_handler = mptfc_dev_reset,
120 .eh_bus_reset_handler = mptfc_bus_reset,
121 .eh_host_reset_handler = mptfc_host_reset,
122 .bios_param = mptscsih_bios_param,
123 .can_queue = MPT_FC_CAN_QUEUE,
124 .this_id = -1,
125 .sg_tablesize = MPT_SCSI_SG_DEPTH,
126 .max_sectors = 8192,
127 .cmd_per_lun = 7,
128 .use_clustering = ENABLE_CLUSTERING,
129 };
130
131 /****************************************************************************
132 * Supported hardware
133 */
134
135 static struct pci_device_id mptfc_pci_table[] = {
136 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC909,
137 PCI_ANY_ID, PCI_ANY_ID },
138 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919,
139 PCI_ANY_ID, PCI_ANY_ID },
140 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929,
141 PCI_ANY_ID, PCI_ANY_ID },
142 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919X,
143 PCI_ANY_ID, PCI_ANY_ID },
144 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929X,
145 PCI_ANY_ID, PCI_ANY_ID },
146 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC939X,
147 PCI_ANY_ID, PCI_ANY_ID },
148 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949X,
149 PCI_ANY_ID, PCI_ANY_ID },
150 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949E,
151 PCI_ANY_ID, PCI_ANY_ID },
152 {0} /* Terminating entry */
153 };
154 MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
155
156 static struct scsi_transport_template *mptfc_transport_template = NULL;
157
158 static struct fc_function_template mptfc_transport_functions = {
159 .dd_fcrport_size = 8,
160 .show_host_node_name = 1,
161 .show_host_port_name = 1,
162 .show_host_supported_classes = 1,
163 .show_host_port_id = 1,
164 .show_rport_supported_classes = 1,
165 .show_starget_node_name = 1,
166 .show_starget_port_name = 1,
167 .show_starget_port_id = 1,
168 .set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo,
169 .show_rport_dev_loss_tmo = 1,
170 .show_host_supported_speeds = 1,
171 .show_host_maxframe_size = 1,
172 .show_host_speed = 1,
173 .show_host_fabric_name = 1,
174 .show_host_port_type = 1,
175 .show_host_port_state = 1,
176 .show_host_symbolic_name = 1,
177 };
178
179 static int
180 mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
181 int (*func)(struct scsi_cmnd *SCpnt),
182 const char *caller)
183 {
184 struct scsi_device *sdev = SCpnt->device;
185 struct Scsi_Host *shost = sdev->host;
186 struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
187 unsigned long flags;
188 int ready;
189
190 spin_lock_irqsave(shost->host_lock, flags);
191 while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY) {
192 spin_unlock_irqrestore(shost->host_lock, flags);
193 dfcprintk ((MYIOC_s_INFO_FMT
194 "mptfc_block_error_handler.%d: %d:%d, port status is "
195 "DID_IMM_RETRY, deferring %s recovery.\n",
196 ((MPT_SCSI_HOST *) shost->hostdata)->ioc->name,
197 ((MPT_SCSI_HOST *) shost->hostdata)->ioc->sh->host_no,
198 SCpnt->device->id,SCpnt->device->lun,caller));
199 msleep(1000);
200 spin_lock_irqsave(shost->host_lock, flags);
201 }
202 spin_unlock_irqrestore(shost->host_lock, flags);
203
204 if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata) {
205 dfcprintk ((MYIOC_s_INFO_FMT
206 "%s.%d: %d:%d, failing recovery, "
207 "port state %d, vdev %p.\n", caller,
208 ((MPT_SCSI_HOST *) shost->hostdata)->ioc->name,
209 ((MPT_SCSI_HOST *) shost->hostdata)->ioc->sh->host_no,
210 SCpnt->device->id,SCpnt->device->lun,ready,
211 SCpnt->device->hostdata));
212 return FAILED;
213 }
214 dfcprintk ((MYIOC_s_INFO_FMT
215 "%s.%d: %d:%d, executing recovery.\n", caller,
216 ((MPT_SCSI_HOST *) shost->hostdata)->ioc->name,
217 ((MPT_SCSI_HOST *) shost->hostdata)->ioc->sh->host_no,
218 SCpnt->device->id,SCpnt->device->lun));
219 return (*func)(SCpnt);
220 }
221
222 static int
223 mptfc_abort(struct scsi_cmnd *SCpnt)
224 {
225 return
226 mptfc_block_error_handler(SCpnt, mptscsih_abort, __FUNCTION__);
227 }
228
229 static int
230 mptfc_dev_reset(struct scsi_cmnd *SCpnt)
231 {
232 return
233 mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __FUNCTION__);
234 }
235
236 static int
237 mptfc_bus_reset(struct scsi_cmnd *SCpnt)
238 {
239 return
240 mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __FUNCTION__);
241 }
242
243 static int
244 mptfc_host_reset(struct scsi_cmnd *SCpnt)
245 {
246 return
247 mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __FUNCTION__);
248 }
249
250 static void
251 mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
252 {
253 if (timeout > 0)
254 rport->dev_loss_tmo = timeout;
255 else
256 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
257 }
258
259 static int
260 mptfc_FcDevPage0_cmp_func(const void *a, const void *b)
261 {
262 FCDevicePage0_t **aa = (FCDevicePage0_t **)a;
263 FCDevicePage0_t **bb = (FCDevicePage0_t **)b;
264
265 if ((*aa)->CurrentBus == (*bb)->CurrentBus) {
266 if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID)
267 return 0;
268 if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID)
269 return -1;
270 return 1;
271 }
272 if ((*aa)->CurrentBus < (*bb)->CurrentBus)
273 return -1;
274 return 1;
275 }
276
277 static int
278 mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port,
279 void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg))
280 {
281 ConfigPageHeader_t hdr;
282 CONFIGPARMS cfg;
283 FCDevicePage0_t *ppage0_alloc, *fc;
284 dma_addr_t page0_dma;
285 int data_sz;
286 int ii;
287
288 FCDevicePage0_t *p0_array=NULL, *p_p0;
289 FCDevicePage0_t **pp0_array=NULL, **p_pp0;
290
291 int rc = -ENOMEM;
292 U32 port_id = 0xffffff;
293 int num_targ = 0;
294 int max_bus = ioc->facts.MaxBuses;
295 int max_targ = ioc->facts.MaxDevices;
296
297 if (max_bus == 0 || max_targ == 0)
298 goto out;
299
300 data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ;
301 p_p0 = p0_array = kzalloc(data_sz, GFP_KERNEL);
302 if (!p0_array)
303 goto out;
304
305 data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ;
306 p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL);
307 if (!pp0_array)
308 goto out;
309
310 do {
311 /* Get FC Device Page 0 header */
312 hdr.PageVersion = 0;
313 hdr.PageLength = 0;
314 hdr.PageNumber = 0;
315 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE;
316 cfg.cfghdr.hdr = &hdr;
317 cfg.physAddr = -1;
318 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
319 cfg.dir = 0;
320 cfg.pageAddr = port_id;
321 cfg.timeout = 0;
322
323 if ((rc = mpt_config(ioc, &cfg)) != 0)
324 break;
325
326 if (hdr.PageLength <= 0)
327 break;
328
329 data_sz = hdr.PageLength * 4;
330 ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz,
331 &page0_dma);
332 rc = -ENOMEM;
333 if (!ppage0_alloc)
334 break;
335
336 cfg.physAddr = page0_dma;
337 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
338
339 if ((rc = mpt_config(ioc, &cfg)) == 0) {
340 ppage0_alloc->PortIdentifier =
341 le32_to_cpu(ppage0_alloc->PortIdentifier);
342
343 ppage0_alloc->WWNN.Low =
344 le32_to_cpu(ppage0_alloc->WWNN.Low);
345
346 ppage0_alloc->WWNN.High =
347 le32_to_cpu(ppage0_alloc->WWNN.High);
348
349 ppage0_alloc->WWPN.Low =
350 le32_to_cpu(ppage0_alloc->WWPN.Low);
351
352 ppage0_alloc->WWPN.High =
353 le32_to_cpu(ppage0_alloc->WWPN.High);
354
355 ppage0_alloc->BBCredit =
356 le16_to_cpu(ppage0_alloc->BBCredit);
357
358 ppage0_alloc->MaxRxFrameSize =
359 le16_to_cpu(ppage0_alloc->MaxRxFrameSize);
360
361 port_id = ppage0_alloc->PortIdentifier;
362 num_targ++;
363 *p_p0 = *ppage0_alloc; /* save data */
364 *p_pp0++ = p_p0++; /* save addr */
365 }
366 pci_free_consistent(ioc->pcidev, data_sz,
367 (u8 *) ppage0_alloc, page0_dma);
368 if (rc != 0)
369 break;
370
371 } while (port_id <= 0xff0000);
372
373 if (num_targ) {
374 /* sort array */
375 if (num_targ > 1)
376 sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *),
377 mptfc_FcDevPage0_cmp_func, NULL);
378 /* call caller's func for each targ */
379 for (ii = 0; ii < num_targ; ii++) {
380 fc = *(pp0_array+ii);
381 func(ioc, ioc_port, fc);
382 }
383 }
384
385 out:
386 kfree(pp0_array);
387 kfree(p0_array);
388 return rc;
389 }
390
391 static int
392 mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid)
393 {
394 /* not currently usable */
395 if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID |
396 MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID))
397 return -1;
398
399 if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID))
400 return -1;
401
402 if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET))
403 return -1;
404
405 /*
406 * board data structure already normalized to platform endianness
407 * shifted to avoid unaligned access on 64 bit architecture
408 */
409 rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low;
410 rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low;
411 rid->port_id = pg0->PortIdentifier;
412 rid->roles = FC_RPORT_ROLE_UNKNOWN;
413
414 return 0;
415 }
416
417 static void
418 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
419 {
420 struct fc_rport_identifiers rport_ids;
421 struct fc_rport *rport;
422 struct mptfc_rport_info *ri;
423 int new_ri = 1;
424 u64 pn, nn;
425 VirtTarget *vtarget;
426 u32 roles = FC_RPORT_ROLE_UNKNOWN;
427
428 if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
429 return;
430
431 roles |= FC_RPORT_ROLE_FCP_TARGET;
432 if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
433 roles |= FC_RPORT_ROLE_FCP_INITIATOR;
434
435 /* scan list looking for a match */
436 list_for_each_entry(ri, &ioc->fc_rports, list) {
437 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
438 if (pn == rport_ids.port_name) { /* match */
439 list_move_tail(&ri->list, &ioc->fc_rports);
440 new_ri = 0;
441 break;
442 }
443 }
444 if (new_ri) { /* allocate one */
445 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
446 if (!ri)
447 return;
448 list_add_tail(&ri->list, &ioc->fc_rports);
449 }
450
451 ri->pg0 = *pg0; /* add/update pg0 data */
452 ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
453
454 /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
455 if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
456 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
457 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
458 if (rport) {
459 ri->rport = rport;
460 if (new_ri) /* may have been reset by user */
461 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
462 /*
463 * if already mapped, remap here. If not mapped,
464 * target_alloc will allocate vtarget and map,
465 * slave_alloc will fill in vdev from vtarget.
466 */
467 if (ri->starget) {
468 vtarget = ri->starget->hostdata;
469 if (vtarget) {
470 vtarget->target_id = pg0->CurrentTargetID;
471 vtarget->bus_id = pg0->CurrentBus;
472 }
473 }
474 *((struct mptfc_rport_info **)rport->dd_data) = ri;
475 /* scan will be scheduled once rport becomes a target */
476 fc_remote_port_rolechg(rport,roles);
477
478 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
479 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
480 dfcprintk ((MYIOC_s_INFO_FMT
481 "mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
482 "rport tid %d, tmo %d\n",
483 ioc->name,
484 ioc->sh->host_no,
485 pg0->PortIdentifier,
486 (unsigned long long)nn,
487 (unsigned long long)pn,
488 pg0->CurrentTargetID,
489 ri->rport->scsi_target_id,
490 ri->rport->dev_loss_tmo));
491 } else {
492 list_del(&ri->list);
493 kfree(ri);
494 ri = NULL;
495 }
496 }
497 }
498
499 /*
500 * OS entry point to allow for host driver to free allocated memory
501 * Called if no device present or device being unloaded
502 */
503 static void
504 mptfc_target_destroy(struct scsi_target *starget)
505 {
506 struct fc_rport *rport;
507 struct mptfc_rport_info *ri;
508
509 rport = starget_to_rport(starget);
510 if (rport) {
511 ri = *((struct mptfc_rport_info **)rport->dd_data);
512 if (ri) /* better be! */
513 ri->starget = NULL;
514 }
515 if (starget->hostdata)
516 kfree(starget->hostdata);
517 starget->hostdata = NULL;
518 }
519
520 /*
521 * OS entry point to allow host driver to alloc memory
522 * for each scsi target. Called once per device the bus scan.
523 * Return non-zero if allocation fails.
524 */
525 static int
526 mptfc_target_alloc(struct scsi_target *starget)
527 {
528 VirtTarget *vtarget;
529 struct fc_rport *rport;
530 struct mptfc_rport_info *ri;
531 int rc;
532
533 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
534 if (!vtarget)
535 return -ENOMEM;
536 starget->hostdata = vtarget;
537
538 rc = -ENODEV;
539 rport = starget_to_rport(starget);
540 if (rport) {
541 ri = *((struct mptfc_rport_info **)rport->dd_data);
542 if (ri) { /* better be! */
543 vtarget->target_id = ri->pg0.CurrentTargetID;
544 vtarget->bus_id = ri->pg0.CurrentBus;
545 ri->starget = starget;
546 rc = 0;
547 }
548 }
549 if (rc != 0) {
550 kfree(vtarget);
551 starget->hostdata = NULL;
552 }
553
554 return rc;
555 }
556
557 /*
558 * OS entry point to allow host driver to alloc memory
559 * for each scsi device. Called once per device the bus scan.
560 * Return non-zero if allocation fails.
561 * Init memory once per LUN.
562 */
563 static int
564 mptfc_slave_alloc(struct scsi_device *sdev)
565 {
566 MPT_SCSI_HOST *hd;
567 VirtTarget *vtarget;
568 VirtDevice *vdev;
569 struct scsi_target *starget;
570 struct fc_rport *rport;
571
572
573 starget = scsi_target(sdev);
574 rport = starget_to_rport(starget);
575
576 if (!rport || fc_remote_port_chkready(rport))
577 return -ENXIO;
578
579 hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
580
581 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
582 if (!vdev) {
583 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
584 hd->ioc->name, sizeof(VirtDevice));
585 return -ENOMEM;
586 }
587
588
589 sdev->hostdata = vdev;
590 vtarget = starget->hostdata;
591
592 if (vtarget->num_luns == 0) {
593 vtarget->ioc_id = hd->ioc->id;
594 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
595 hd->Targets[sdev->id] = vtarget;
596 }
597
598 vdev->vtarget = vtarget;
599 vdev->lun = sdev->lun;
600
601 vtarget->num_luns++;
602
603
604 #ifdef DMPT_DEBUG_FC
605 {
606 u64 nn, pn;
607 struct mptfc_rport_info *ri;
608 ri = *((struct mptfc_rport_info **)rport->dd_data);
609 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
610 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
611 dfcprintk ((MYIOC_s_INFO_FMT
612 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
613 "CurrentTargetID %d, %x %llx %llx\n",
614 hd->ioc->name,
615 sdev->host->host_no,
616 vtarget->num_luns,
617 sdev->id, ri->pg0.CurrentTargetID,
618 ri->pg0.PortIdentifier,
619 (unsigned long long)pn,
620 (unsigned long long)nn));
621 }
622 #endif
623
624 return 0;
625 }
626
627 static int
628 mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
629 {
630 struct mptfc_rport_info *ri;
631 struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
632 int err;
633
634 err = fc_remote_port_chkready(rport);
635 if (unlikely(err)) {
636 SCpnt->result = err;
637 done(SCpnt);
638 return 0;
639 }
640
641 if (!SCpnt->device->hostdata) { /* vdev */
642 SCpnt->result = DID_NO_CONNECT << 16;
643 done(SCpnt);
644 return 0;
645 }
646
647 /* dd_data is null until finished adding target */
648 ri = *((struct mptfc_rport_info **)rport->dd_data);
649 if (unlikely(!ri)) {
650 dfcprintk ((MYIOC_s_INFO_FMT
651 "mptfc_qcmd.%d: %d:%d, dd_data is null.\n",
652 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->name,
653 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->sh->host_no,
654 SCpnt->device->id,SCpnt->device->lun));
655 SCpnt->result = DID_IMM_RETRY << 16;
656 done(SCpnt);
657 return 0;
658 }
659
660 err = mptscsih_qcmd(SCpnt,done);
661 #ifdef DMPT_DEBUG_FC
662 if (unlikely(err)) {
663 dfcprintk ((MYIOC_s_INFO_FMT
664 "mptfc_qcmd.%d: %d:%d, mptscsih_qcmd returns non-zero, (%x).\n",
665 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->name,
666 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->sh->host_no,
667 SCpnt->device->id,SCpnt->device->lun,err));
668 }
669 #endif
670 return err;
671 }
672
673 /*
674 * mptfc_GetFcPortPage0 - Fetch FCPort config Page0.
675 * @ioc: Pointer to MPT_ADAPTER structure
676 * @portnum: IOC Port number
677 *
678 * Return: 0 for success
679 * -ENOMEM if no memory available
680 * -EPERM if not allowed due to ISR context
681 * -EAGAIN if no msg frames currently available
682 * -EFAULT for non-successful reply or no reply (timeout)
683 * -EINVAL portnum arg out of range (hardwired to two elements)
684 */
685 static int
686 mptfc_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
687 {
688 ConfigPageHeader_t hdr;
689 CONFIGPARMS cfg;
690 FCPortPage0_t *ppage0_alloc;
691 FCPortPage0_t *pp0dest;
692 dma_addr_t page0_dma;
693 int data_sz;
694 int copy_sz;
695 int rc;
696 int count = 400;
697
698 if (portnum > 1)
699 return -EINVAL;
700
701 /* Get FCPort Page 0 header */
702 hdr.PageVersion = 0;
703 hdr.PageLength = 0;
704 hdr.PageNumber = 0;
705 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
706 cfg.cfghdr.hdr = &hdr;
707 cfg.physAddr = -1;
708 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
709 cfg.dir = 0;
710 cfg.pageAddr = portnum;
711 cfg.timeout = 0;
712
713 if ((rc = mpt_config(ioc, &cfg)) != 0)
714 return rc;
715
716 if (hdr.PageLength == 0)
717 return 0;
718
719 data_sz = hdr.PageLength * 4;
720 rc = -ENOMEM;
721 ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
722 if (ppage0_alloc) {
723
724 try_again:
725 memset((u8 *)ppage0_alloc, 0, data_sz);
726 cfg.physAddr = page0_dma;
727 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
728
729 if ((rc = mpt_config(ioc, &cfg)) == 0) {
730 /* save the data */
731 pp0dest = &ioc->fc_port_page0[portnum];
732 copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz);
733 memcpy(pp0dest, ppage0_alloc, copy_sz);
734
735 /*
736 * Normalize endianness of structure data,
737 * by byte-swapping all > 1 byte fields!
738 */
739 pp0dest->Flags = le32_to_cpu(pp0dest->Flags);
740 pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier);
741 pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low);
742 pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High);
743 pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low);
744 pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High);
745 pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass);
746 pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds);
747 pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed);
748 pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize);
749 pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low);
750 pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High);
751 pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low);
752 pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High);
753 pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
754 pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);
755
756 /*
757 * if still doing discovery,
758 * hang loose a while until finished
759 */
760 if ((pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) ||
761 (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE &&
762 (pp0dest->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_TYPE_MASK)
763 == MPI_FCPORTPAGE0_FLAGS_ATTACH_NO_INIT)) {
764 if (count-- > 0) {
765 msleep(100);
766 goto try_again;
767 }
768 printk(MYIOC_s_INFO_FMT "Firmware discovery not"
769 " complete.\n",
770 ioc->name);
771 }
772 }
773
774 pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
775 }
776
777 return rc;
778 }
779
780 static int
781 mptfc_WriteFcPortPage1(MPT_ADAPTER *ioc, int portnum)
782 {
783 ConfigPageHeader_t hdr;
784 CONFIGPARMS cfg;
785 int rc;
786
787 if (portnum > 1)
788 return -EINVAL;
789
790 if (!(ioc->fc_data.fc_port_page1[portnum].data))
791 return -EINVAL;
792
793 /* get fcport page 1 header */
794 hdr.PageVersion = 0;
795 hdr.PageLength = 0;
796 hdr.PageNumber = 1;
797 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
798 cfg.cfghdr.hdr = &hdr;
799 cfg.physAddr = -1;
800 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
801 cfg.dir = 0;
802 cfg.pageAddr = portnum;
803 cfg.timeout = 0;
804
805 if ((rc = mpt_config(ioc, &cfg)) != 0)
806 return rc;
807
808 if (hdr.PageLength == 0)
809 return -ENODEV;
810
811 if (hdr.PageLength*4 != ioc->fc_data.fc_port_page1[portnum].pg_sz)
812 return -EINVAL;
813
814 cfg.physAddr = ioc->fc_data.fc_port_page1[portnum].dma;
815 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
816 cfg.dir = 1;
817
818 rc = mpt_config(ioc, &cfg);
819
820 return rc;
821 }
822
823 static int
824 mptfc_GetFcPortPage1(MPT_ADAPTER *ioc, int portnum)
825 {
826 ConfigPageHeader_t hdr;
827 CONFIGPARMS cfg;
828 FCPortPage1_t *page1_alloc;
829 dma_addr_t page1_dma;
830 int data_sz;
831 int rc;
832
833 if (portnum > 1)
834 return -EINVAL;
835
836 /* get fcport page 1 header */
837 hdr.PageVersion = 0;
838 hdr.PageLength = 0;
839 hdr.PageNumber = 1;
840 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
841 cfg.cfghdr.hdr = &hdr;
842 cfg.physAddr = -1;
843 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
844 cfg.dir = 0;
845 cfg.pageAddr = portnum;
846 cfg.timeout = 0;
847
848 if ((rc = mpt_config(ioc, &cfg)) != 0)
849 return rc;
850
851 if (hdr.PageLength == 0)
852 return -ENODEV;
853
854 start_over:
855
856 if (ioc->fc_data.fc_port_page1[portnum].data == NULL) {
857 data_sz = hdr.PageLength * 4;
858 if (data_sz < sizeof(FCPortPage1_t))
859 data_sz = sizeof(FCPortPage1_t);
860
861 page1_alloc = (FCPortPage1_t *) pci_alloc_consistent(ioc->pcidev,
862 data_sz,
863 &page1_dma);
864 if (!page1_alloc)
865 return -ENOMEM;
866 }
867 else {
868 page1_alloc = ioc->fc_data.fc_port_page1[portnum].data;
869 page1_dma = ioc->fc_data.fc_port_page1[portnum].dma;
870 data_sz = ioc->fc_data.fc_port_page1[portnum].pg_sz;
871 if (hdr.PageLength * 4 > data_sz) {
872 ioc->fc_data.fc_port_page1[portnum].data = NULL;
873 pci_free_consistent(ioc->pcidev, data_sz, (u8 *)
874 page1_alloc, page1_dma);
875 goto start_over;
876 }
877 }
878
879 memset(page1_alloc,0,data_sz);
880
881 cfg.physAddr = page1_dma;
882 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
883
884 if ((rc = mpt_config(ioc, &cfg)) == 0) {
885 ioc->fc_data.fc_port_page1[portnum].data = page1_alloc;
886 ioc->fc_data.fc_port_page1[portnum].pg_sz = data_sz;
887 ioc->fc_data.fc_port_page1[portnum].dma = page1_dma;
888 }
889 else {
890 ioc->fc_data.fc_port_page1[portnum].data = NULL;
891 pci_free_consistent(ioc->pcidev, data_sz, (u8 *)
892 page1_alloc, page1_dma);
893 }
894
895 return rc;
896 }
897
898 static void
899 mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc)
900 {
901 int ii;
902 FCPortPage1_t *pp1;
903
904 #define MPTFC_FW_DEVICE_TIMEOUT (1)
905 #define MPTFC_FW_IO_PEND_TIMEOUT (1)
906 #define ON_FLAGS (MPI_FCPORTPAGE1_FLAGS_IMMEDIATE_ERROR_REPLY)
907 #define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS)
908
909 for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
910 if (mptfc_GetFcPortPage1(ioc, ii) != 0)
911 continue;
912 pp1 = ioc->fc_data.fc_port_page1[ii].data;
913 if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT)
914 && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT)
915 && ((pp1->Flags & ON_FLAGS) == ON_FLAGS)
916 && ((pp1->Flags & OFF_FLAGS) == 0))
917 continue;
918 pp1->InitiatorDeviceTimeout = MPTFC_FW_DEVICE_TIMEOUT;
919 pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT;
920 pp1->Flags &= ~OFF_FLAGS;
921 pp1->Flags |= ON_FLAGS;
922 mptfc_WriteFcPortPage1(ioc, ii);
923 }
924 }
925
926
927 static void
928 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
929 {
930 unsigned class = 0;
931 unsigned cos = 0;
932 unsigned speed;
933 unsigned port_type;
934 unsigned port_state;
935 FCPortPage0_t *pp0;
936 struct Scsi_Host *sh;
937 char *sn;
938
939 /* don't know what to do as only one scsi (fc) host was allocated */
940 if (portnum != 0)
941 return;
942
943 pp0 = &ioc->fc_port_page0[portnum];
944 sh = ioc->sh;
945
946 sn = fc_host_symbolic_name(sh);
947 snprintf(sn, FC_SYMBOLIC_NAME_SIZE, "%s %s%08xh",
948 ioc->prod_name,
949 MPT_FW_REV_MAGIC_ID_STRING,
950 ioc->facts.FWVersion.Word);
951
952 fc_host_tgtid_bind_type(sh) = FC_TGTID_BIND_BY_WWPN;
953
954 fc_host_maxframe_size(sh) = pp0->MaxFrameSize;
955
956 fc_host_node_name(sh) =
957 (u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
958
959 fc_host_port_name(sh) =
960 (u64)pp0->WWPN.High << 32 | (u64)pp0->WWPN.Low;
961
962 fc_host_port_id(sh) = pp0->PortIdentifier;
963
964 class = pp0->SupportedServiceClass;
965 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
966 cos |= FC_COS_CLASS1;
967 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
968 cos |= FC_COS_CLASS2;
969 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
970 cos |= FC_COS_CLASS3;
971 fc_host_supported_classes(sh) = cos;
972
973 if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT)
974 speed = FC_PORTSPEED_1GBIT;
975 else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT)
976 speed = FC_PORTSPEED_2GBIT;
977 else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT)
978 speed = FC_PORTSPEED_4GBIT;
979 else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_10GBIT)
980 speed = FC_PORTSPEED_10GBIT;
981 else
982 speed = FC_PORTSPEED_UNKNOWN;
983 fc_host_speed(sh) = speed;
984
985 speed = 0;
986 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_1GBIT_SPEED)
987 speed |= FC_PORTSPEED_1GBIT;
988 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_2GBIT_SPEED)
989 speed |= FC_PORTSPEED_2GBIT;
990 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_4GBIT_SPEED)
991 speed |= FC_PORTSPEED_4GBIT;
992 if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_10GBIT_SPEED)
993 speed |= FC_PORTSPEED_10GBIT;
994 fc_host_supported_speeds(sh) = speed;
995
996 port_state = FC_PORTSTATE_UNKNOWN;
997 if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE)
998 port_state = FC_PORTSTATE_ONLINE;
999 else if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_OFFLINE)
1000 port_state = FC_PORTSTATE_LINKDOWN;
1001 fc_host_port_state(sh) = port_state;
1002
1003 port_type = FC_PORTTYPE_UNKNOWN;
1004 if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_POINT_TO_POINT)
1005 port_type = FC_PORTTYPE_PTP;
1006 else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PRIVATE_LOOP)
1007 port_type = FC_PORTTYPE_LPORT;
1008 else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PUBLIC_LOOP)
1009 port_type = FC_PORTTYPE_NLPORT;
1010 else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_FABRIC_DIRECT)
1011 port_type = FC_PORTTYPE_NPORT;
1012 fc_host_port_type(sh) = port_type;
1013
1014 fc_host_fabric_name(sh) =
1015 (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_FABRIC_WWN_VALID) ?
1016 (u64) pp0->FabricWWNN.High << 32 | (u64) pp0->FabricWWPN.Low :
1017 (u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1018
1019 }
1020
1021 static void
1022 mptfc_setup_reset(struct work_struct *work)
1023 {
1024 MPT_ADAPTER *ioc =
1025 container_of(work, MPT_ADAPTER, fc_setup_reset_work);
1026 u64 pn;
1027 struct mptfc_rport_info *ri;
1028
1029 /* reset about to happen, delete (block) all rports */
1030 list_for_each_entry(ri, &ioc->fc_rports, list) {
1031 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1032 ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED;
1033 fc_remote_port_delete(ri->rport); /* won't sleep */
1034 ri->rport = NULL;
1035
1036 pn = (u64)ri->pg0.WWPN.High << 32 |
1037 (u64)ri->pg0.WWPN.Low;
1038 dfcprintk ((MYIOC_s_INFO_FMT
1039 "mptfc_setup_reset.%d: %llx deleted\n",
1040 ioc->name,
1041 ioc->sh->host_no,
1042 (unsigned long long)pn));
1043 }
1044 }
1045 }
1046
1047 static void
1048 mptfc_rescan_devices(struct work_struct *work)
1049 {
1050 MPT_ADAPTER *ioc =
1051 container_of(work, MPT_ADAPTER, fc_rescan_work);
1052 int ii;
1053 u64 pn;
1054 struct mptfc_rport_info *ri;
1055
1056 /* start by tagging all ports as missing */
1057 list_for_each_entry(ri, &ioc->fc_rports, list) {
1058 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1059 ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
1060 }
1061 }
1062
1063 /*
1064 * now rescan devices known to adapter,
1065 * will reregister existing rports
1066 */
1067 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1068 (void) mptfc_GetFcPortPage0(ioc, ii);
1069 mptfc_init_host_attr(ioc, ii); /* refresh */
1070 mptfc_GetFcDevPage0(ioc, ii, mptfc_register_dev);
1071 }
1072
1073 /* delete devices still missing */
1074 list_for_each_entry(ri, &ioc->fc_rports, list) {
1075 /* if newly missing, delete it */
1076 if (ri->flags & MPT_RPORT_INFO_FLAGS_MISSING) {
1077
1078 ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
1079 MPT_RPORT_INFO_FLAGS_MISSING);
1080 fc_remote_port_delete(ri->rport); /* won't sleep */
1081 ri->rport = NULL;
1082
1083 pn = (u64)ri->pg0.WWPN.High << 32 |
1084 (u64)ri->pg0.WWPN.Low;
1085 dfcprintk ((MYIOC_s_INFO_FMT
1086 "mptfc_rescan.%d: %llx deleted\n",
1087 ioc->name,
1088 ioc->sh->host_no,
1089 (unsigned long long)pn));
1090 }
1091 }
1092 }
1093
1094 static int
1095 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1096 {
1097 struct Scsi_Host *sh;
1098 MPT_SCSI_HOST *hd;
1099 MPT_ADAPTER *ioc;
1100 unsigned long flags;
1101 int ii;
1102 int numSGE = 0;
1103 int scale;
1104 int ioc_cap;
1105 int error=0;
1106 int r;
1107
1108 if ((r = mpt_attach(pdev,id)) != 0)
1109 return r;
1110
1111 ioc = pci_get_drvdata(pdev);
1112 ioc->DoneCtx = mptfcDoneCtx;
1113 ioc->TaskCtx = mptfcTaskCtx;
1114 ioc->InternalCtx = mptfcInternalCtx;
1115
1116 /* Added sanity check on readiness of the MPT adapter.
1117 */
1118 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1119 printk(MYIOC_s_WARN_FMT
1120 "Skipping because it's not operational!\n",
1121 ioc->name);
1122 error = -ENODEV;
1123 goto out_mptfc_probe;
1124 }
1125
1126 if (!ioc->active) {
1127 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1128 ioc->name);
1129 error = -ENODEV;
1130 goto out_mptfc_probe;
1131 }
1132
1133 /* Sanity check - ensure at least 1 port is INITIATOR capable
1134 */
1135 ioc_cap = 0;
1136 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1137 if (ioc->pfacts[ii].ProtocolFlags &
1138 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1139 ioc_cap ++;
1140 }
1141
1142 if (!ioc_cap) {
1143 printk(MYIOC_s_WARN_FMT
1144 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1145 ioc->name, ioc);
1146 return -ENODEV;
1147 }
1148
1149 sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
1150
1151 if (!sh) {
1152 printk(MYIOC_s_WARN_FMT
1153 "Unable to register controller with SCSI subsystem\n",
1154 ioc->name);
1155 error = -1;
1156 goto out_mptfc_probe;
1157 }
1158
1159 spin_lock_init(&ioc->fc_rescan_work_lock);
1160 INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices);
1161 INIT_WORK(&ioc->fc_setup_reset_work, mptfc_setup_reset);
1162
1163 spin_lock_irqsave(&ioc->FreeQlock, flags);
1164
1165 /* Attach the SCSI Host to the IOC structure
1166 */
1167 ioc->sh = sh;
1168
1169 sh->io_port = 0;
1170 sh->n_io_port = 0;
1171 sh->irq = 0;
1172
1173 /* set 16 byte cdb's */
1174 sh->max_cmd_len = 16;
1175
1176 sh->max_id = MPT_MAX_FC_DEVICES<256 ? MPT_MAX_FC_DEVICES : 255;
1177
1178 sh->max_lun = MPT_LAST_LUN + 1;
1179 sh->max_channel = 0;
1180 sh->this_id = ioc->pfacts[0].PortSCSIID;
1181
1182 /* Required entry.
1183 */
1184 sh->unique_id = ioc->id;
1185
1186 /* Verify that we won't exceed the maximum
1187 * number of chain buffers
1188 * We can optimize: ZZ = req_sz/sizeof(SGE)
1189 * For 32bit SGE's:
1190 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1191 * + (req_sz - 64)/sizeof(SGE)
1192 * A slightly different algorithm is required for
1193 * 64bit SGEs.
1194 */
1195 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1196 if (sizeof(dma_addr_t) == sizeof(u64)) {
1197 numSGE = (scale - 1) *
1198 (ioc->facts.MaxChainDepth-1) + scale +
1199 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1200 sizeof(u32));
1201 } else {
1202 numSGE = 1 + (scale - 1) *
1203 (ioc->facts.MaxChainDepth-1) + scale +
1204 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1205 sizeof(u32));
1206 }
1207
1208 if (numSGE < sh->sg_tablesize) {
1209 /* Reset this value */
1210 dprintk((MYIOC_s_INFO_FMT
1211 "Resetting sg_tablesize to %d from %d\n",
1212 ioc->name, numSGE, sh->sg_tablesize));
1213 sh->sg_tablesize = numSGE;
1214 }
1215
1216 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1217
1218 hd = (MPT_SCSI_HOST *) sh->hostdata;
1219 hd->ioc = ioc;
1220
1221 /* SCSI needs scsi_cmnd lookup table!
1222 * (with size equal to req_depth*PtrSz!)
1223 */
1224 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1225 if (!hd->ScsiLookup) {
1226 error = -ENOMEM;
1227 goto out_mptfc_probe;
1228 }
1229
1230 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1231 ioc->name, hd->ScsiLookup));
1232
1233 /* Allocate memory for the device structures.
1234 * A non-Null pointer at an offset
1235 * indicates a device exists.
1236 * max_id = 1 + maximum id (hosts.h)
1237 */
1238 hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
1239 if (!hd->Targets) {
1240 error = -ENOMEM;
1241 goto out_mptfc_probe;
1242 }
1243
1244 dprintk((KERN_INFO " vdev @ %p\n", hd->Targets));
1245
1246 /* Clear the TM flags
1247 */
1248 hd->tmPending = 0;
1249 hd->tmState = TM_STATE_NONE;
1250 hd->resetPending = 0;
1251 hd->abortSCpnt = NULL;
1252
1253 /* Clear the pointer used to store
1254 * single-threaded commands, i.e., those
1255 * issued during a bus scan, dv and
1256 * configuration pages.
1257 */
1258 hd->cmdPtr = NULL;
1259
1260 /* Initialize this SCSI Hosts' timers
1261 * To use, set the timer expires field
1262 * and add_timer
1263 */
1264 init_timer(&hd->timer);
1265 hd->timer.data = (unsigned long) hd;
1266 hd->timer.function = mptscsih_timer_expired;
1267
1268 init_waitqueue_head(&hd->scandv_waitq);
1269 hd->scandv_wait_done = 0;
1270 hd->last_queue_full = 0;
1271
1272 sh->transportt = mptfc_transport_template;
1273 error = scsi_add_host (sh, &ioc->pcidev->dev);
1274 if(error) {
1275 dprintk((KERN_ERR MYNAM
1276 "scsi_add_host failed\n"));
1277 goto out_mptfc_probe;
1278 }
1279
1280 /* initialize workqueue */
1281
1282 snprintf(ioc->fc_rescan_work_q_name, KOBJ_NAME_LEN, "mptfc_wq_%d",
1283 sh->host_no);
1284 ioc->fc_rescan_work_q =
1285 create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
1286 if (!ioc->fc_rescan_work_q)
1287 goto out_mptfc_probe;
1288
1289 /*
1290 * Pre-fetch FC port WWN and stuff...
1291 * (FCPortPage0_t stuff)
1292 */
1293 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1294 (void) mptfc_GetFcPortPage0(ioc, ii);
1295 }
1296 mptfc_SetFcPortPage1_defaults(ioc);
1297
1298 /*
1299 * scan for rports -
1300 * by doing it via the workqueue, some locking is eliminated
1301 */
1302
1303 queue_work(ioc->fc_rescan_work_q, &ioc->fc_rescan_work);
1304 flush_workqueue(ioc->fc_rescan_work_q);
1305
1306 return 0;
1307
1308 out_mptfc_probe:
1309
1310 mptscsih_remove(pdev);
1311 return error;
1312 }
1313
1314 static struct pci_driver mptfc_driver = {
1315 .name = "mptfc",
1316 .id_table = mptfc_pci_table,
1317 .probe = mptfc_probe,
1318 .remove = __devexit_p(mptfc_remove),
1319 .shutdown = mptscsih_shutdown,
1320 #ifdef CONFIG_PM
1321 .suspend = mptscsih_suspend,
1322 .resume = mptscsih_resume,
1323 #endif
1324 };
1325
1326 static int
1327 mptfc_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1328 {
1329 MPT_SCSI_HOST *hd;
1330 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1331 unsigned long flags;
1332 int rc=1;
1333
1334 devtverboseprintk((MYIOC_s_INFO_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
1335 ioc->name, event));
1336
1337 if (ioc->sh == NULL ||
1338 ((hd = (MPT_SCSI_HOST *)ioc->sh->hostdata) == NULL))
1339 return 1;
1340
1341 switch (event) {
1342 case MPI_EVENT_RESCAN:
1343 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1344 if (ioc->fc_rescan_work_q) {
1345 queue_work(ioc->fc_rescan_work_q,
1346 &ioc->fc_rescan_work);
1347 }
1348 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1349 break;
1350 default:
1351 rc = mptscsih_event_process(ioc,pEvReply);
1352 break;
1353 }
1354 return rc;
1355 }
1356
1357 static int
1358 mptfc_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1359 {
1360 int rc;
1361 unsigned long flags;
1362
1363 rc = mptscsih_ioc_reset(ioc,reset_phase);
1364 if (rc == 0)
1365 return rc;
1366
1367
1368 dtmprintk((KERN_WARNING MYNAM
1369 ": IOC %s_reset routed to FC host driver!\n",
1370 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
1371 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
1372
1373 if (reset_phase == MPT_IOC_SETUP_RESET) {
1374 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1375 if (ioc->fc_rescan_work_q) {
1376 queue_work(ioc->fc_rescan_work_q,
1377 &ioc->fc_setup_reset_work);
1378 }
1379 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1380 }
1381
1382 else if (reset_phase == MPT_IOC_PRE_RESET) {
1383 }
1384
1385 else { /* MPT_IOC_POST_RESET */
1386 mptfc_SetFcPortPage1_defaults(ioc);
1387 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1388 if (ioc->fc_rescan_work_q) {
1389 queue_work(ioc->fc_rescan_work_q,
1390 &ioc->fc_rescan_work);
1391 }
1392 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1393 }
1394 return 1;
1395 }
1396
1397 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1398 /**
1399 * mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1400 *
1401 * Returns 0 for success, non-zero for failure.
1402 */
1403 static int __init
1404 mptfc_init(void)
1405 {
1406 int error;
1407
1408 show_mptmod_ver(my_NAME, my_VERSION);
1409
1410 /* sanity check module parameters */
1411 if (mptfc_dev_loss_tmo <= 0)
1412 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
1413
1414 mptfc_transport_template =
1415 fc_attach_transport(&mptfc_transport_functions);
1416
1417 if (!mptfc_transport_template)
1418 return -ENODEV;
1419
1420 mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER);
1421 mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER);
1422 mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER);
1423
1424 if (mpt_event_register(mptfcDoneCtx, mptfc_event_process) == 0) {
1425 devtverboseprintk((KERN_INFO MYNAM
1426 ": Registered for IOC event notifications\n"));
1427 }
1428
1429 if (mpt_reset_register(mptfcDoneCtx, mptfc_ioc_reset) == 0) {
1430 dprintk((KERN_INFO MYNAM
1431 ": Registered for IOC reset notifications\n"));
1432 }
1433
1434 error = pci_register_driver(&mptfc_driver);
1435 if (error)
1436 fc_release_transport(mptfc_transport_template);
1437
1438 return error;
1439 }
1440
1441 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1442 /**
1443 * mptfc_remove - Remove fc infrastructure for devices
1444 * @pdev: Pointer to pci_dev structure
1445 *
1446 */
1447 static void __devexit
1448 mptfc_remove(struct pci_dev *pdev)
1449 {
1450 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1451 struct mptfc_rport_info *p, *n;
1452 struct workqueue_struct *work_q;
1453 unsigned long flags;
1454 int ii;
1455
1456 /* destroy workqueue */
1457 if ((work_q=ioc->fc_rescan_work_q)) {
1458 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1459 ioc->fc_rescan_work_q = NULL;
1460 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1461 destroy_workqueue(work_q);
1462 }
1463
1464 fc_remove_host(ioc->sh);
1465
1466 list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
1467 list_del(&p->list);
1468 kfree(p);
1469 }
1470
1471 for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
1472 if (ioc->fc_data.fc_port_page1[ii].data) {
1473 pci_free_consistent(ioc->pcidev,
1474 ioc->fc_data.fc_port_page1[ii].pg_sz,
1475 (u8 *) ioc->fc_data.fc_port_page1[ii].data,
1476 ioc->fc_data.fc_port_page1[ii].dma);
1477 ioc->fc_data.fc_port_page1[ii].data = NULL;
1478 }
1479 }
1480
1481 mptscsih_remove(pdev);
1482 }
1483
1484 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1485 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1486 /**
1487 * mptfc_exit - Unregisters MPT adapter(s)
1488 *
1489 */
1490 static void __exit
1491 mptfc_exit(void)
1492 {
1493 pci_unregister_driver(&mptfc_driver);
1494 fc_release_transport(mptfc_transport_template);
1495
1496 mpt_reset_deregister(mptfcDoneCtx);
1497 dprintk((KERN_INFO MYNAM
1498 ": Deregistered for IOC reset notifications\n"));
1499
1500 mpt_event_deregister(mptfcDoneCtx);
1501 dprintk((KERN_INFO MYNAM
1502 ": Deregistered for IOC event notifications\n"));
1503
1504 mpt_deregister(mptfcInternalCtx);
1505 mpt_deregister(mptfcTaskCtx);
1506 mpt_deregister(mptfcDoneCtx);
1507 }
1508
1509 module_init(mptfc_init);
1510 module_exit(mptfc_exit);
Linux with added FPC-III support