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