Merge branch 'linus'
[linux-2.6] / drivers / message / fusion / mptfc.c
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-2005 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
79 /* Command line args */
80 static int mpt_pq_filter = 0;
81 module_param(mpt_pq_filter, int, 0);
82 MODULE_PARM_DESC(mpt_pq_filter, " Enable peripheral qualifier filter: enable=1  (default=0)");
83
84 #define MPTFC_DEV_LOSS_TMO (60)
85 static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;     /* reasonable default */
86 module_param(mptfc_dev_loss_tmo, int, 0);
87 MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the "
88                                      " transport to wait for an rport to "
89                                      " return following a device loss event."
90                                      "  Default=60.");
91
92 static int      mptfcDoneCtx = -1;
93 static int      mptfcTaskCtx = -1;
94 static int      mptfcInternalCtx = -1; /* Used only for internal commands */
95
96 static int mptfc_target_alloc(struct scsi_target *starget);
97 static int mptfc_slave_alloc(struct scsi_device *sdev);
98 static int mptfc_qcmd(struct scsi_cmnd *SCpnt,
99                       void (*done)(struct scsi_cmnd *));
100 static void mptfc_target_destroy(struct scsi_target *starget);
101 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
102 static void __devexit mptfc_remove(struct pci_dev *pdev);
103
104 static struct scsi_host_template mptfc_driver_template = {
105         .module                         = THIS_MODULE,
106         .proc_name                      = "mptfc",
107         .proc_info                      = mptscsih_proc_info,
108         .name                           = "MPT FC Host",
109         .info                           = mptscsih_info,
110         .queuecommand                   = mptfc_qcmd,
111         .target_alloc                   = mptfc_target_alloc,
112         .slave_alloc                    = mptfc_slave_alloc,
113         .slave_configure                = mptscsih_slave_configure,
114         .target_destroy                 = mptfc_target_destroy,
115         .slave_destroy                  = mptscsih_slave_destroy,
116         .change_queue_depth             = mptscsih_change_queue_depth,
117         .eh_abort_handler               = mptscsih_abort,
118         .eh_device_reset_handler        = mptscsih_dev_reset,
119         .eh_bus_reset_handler           = mptscsih_bus_reset,
120         .eh_host_reset_handler          = mptscsih_host_reset,
121         .bios_param                     = mptscsih_bios_param,
122         .can_queue                      = MPT_FC_CAN_QUEUE,
123         .this_id                        = -1,
124         .sg_tablesize                   = MPT_SCSI_SG_DEPTH,
125         .max_sectors                    = 8192,
126         .cmd_per_lun                    = 7,
127         .use_clustering                 = ENABLE_CLUSTERING,
128 };
129
130 /****************************************************************************
131  * Supported hardware
132  */
133
134 static struct pci_device_id mptfc_pci_table[] = {
135         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC909,
136                 PCI_ANY_ID, PCI_ANY_ID },
137         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC919,
138                 PCI_ANY_ID, PCI_ANY_ID },
139         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC929,
140                 PCI_ANY_ID, PCI_ANY_ID },
141         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC919X,
142                 PCI_ANY_ID, PCI_ANY_ID },
143         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC929X,
144                 PCI_ANY_ID, PCI_ANY_ID },
145         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC939X,
146                 PCI_ANY_ID, PCI_ANY_ID },
147         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC949X,
148                 PCI_ANY_ID, PCI_ANY_ID },
149         { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FC949ES,
150                 PCI_ANY_ID, PCI_ANY_ID },
151         {0}     /* Terminating entry */
152 };
153 MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
154
155 static struct scsi_transport_template *mptfc_transport_template = NULL;
156
157 static struct fc_function_template mptfc_transport_functions = {
158         .dd_fcrport_size = 8,
159         .show_host_node_name = 1,
160         .show_host_port_name = 1,
161         .show_host_supported_classes = 1,
162         .show_host_port_id = 1,
163         .show_rport_supported_classes = 1,
164         .show_starget_node_name = 1,
165         .show_starget_port_name = 1,
166         .show_starget_port_id = 1,
167         .set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo,
168         .show_rport_dev_loss_tmo = 1,
169
170 };
171
172 /* FIXME! values controlling firmware RESCAN event
173  * need to be set low to allow dev_loss_tmo to
174  * work as expected.  Currently, firmware doesn't
175  * notify driver of RESCAN event until some number
176  * of seconds elapse.  This value can be set via
177  * lsiutil.
178  */
179 static void
180 mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
181 {
182         if (timeout > 0)
183                 rport->dev_loss_tmo = timeout;
184         else
185                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
186 }
187
188 static int
189 mptfc_FcDevPage0_cmp_func(const void *a, const void *b)
190 {
191         FCDevicePage0_t **aa = (FCDevicePage0_t **)a;
192         FCDevicePage0_t **bb = (FCDevicePage0_t **)b;
193
194         if ((*aa)->CurrentBus == (*bb)->CurrentBus) {
195                 if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID)
196                         return 0;
197                 if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID)
198                         return -1;
199                 return 1;
200         }
201         if ((*aa)->CurrentBus < (*bb)->CurrentBus)
202                 return -1;
203         return 1;
204 }
205
206 static int
207 mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port,
208         void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg))
209 {
210         ConfigPageHeader_t       hdr;
211         CONFIGPARMS              cfg;
212         FCDevicePage0_t         *ppage0_alloc, *fc;
213         dma_addr_t               page0_dma;
214         int                      data_sz;
215         int                      ii;
216
217         FCDevicePage0_t         *p0_array=NULL, *p_p0;
218         FCDevicePage0_t         **pp0_array=NULL, **p_pp0;
219
220         int                      rc = -ENOMEM;
221         U32                      port_id = 0xffffff;
222         int                      num_targ = 0;
223         int                      max_bus = ioc->facts.MaxBuses;
224         int                      max_targ = ioc->facts.MaxDevices;
225
226         if (max_bus == 0 || max_targ == 0)
227                 goto out;
228
229         data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ;
230         p_p0 = p0_array =  kzalloc(data_sz, GFP_KERNEL);
231         if (!p0_array)
232                 goto out;
233
234         data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ;
235         p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL);
236         if (!pp0_array)
237                 goto out;
238
239         do {
240                 /* Get FC Device Page 0 header */
241                 hdr.PageVersion = 0;
242                 hdr.PageLength = 0;
243                 hdr.PageNumber = 0;
244                 hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE;
245                 cfg.cfghdr.hdr = &hdr;
246                 cfg.physAddr = -1;
247                 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
248                 cfg.dir = 0;
249                 cfg.pageAddr = port_id;
250                 cfg.timeout = 0;
251
252                 if ((rc = mpt_config(ioc, &cfg)) != 0)
253                         break;
254
255                 if (hdr.PageLength <= 0)
256                         break;
257
258                 data_sz = hdr.PageLength * 4;
259                 ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz,
260                                                         &page0_dma);
261                 rc = -ENOMEM;
262                 if (!ppage0_alloc)
263                         break;
264
265                 cfg.physAddr = page0_dma;
266                 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
267
268                 if ((rc = mpt_config(ioc, &cfg)) == 0) {
269                         ppage0_alloc->PortIdentifier =
270                                 le32_to_cpu(ppage0_alloc->PortIdentifier);
271
272                         ppage0_alloc->WWNN.Low =
273                                 le32_to_cpu(ppage0_alloc->WWNN.Low);
274
275                         ppage0_alloc->WWNN.High =
276                                 le32_to_cpu(ppage0_alloc->WWNN.High);
277
278                         ppage0_alloc->WWPN.Low =
279                                 le32_to_cpu(ppage0_alloc->WWPN.Low);
280
281                         ppage0_alloc->WWPN.High =
282                                 le32_to_cpu(ppage0_alloc->WWPN.High);
283
284                         ppage0_alloc->BBCredit =
285                                 le16_to_cpu(ppage0_alloc->BBCredit);
286
287                         ppage0_alloc->MaxRxFrameSize =
288                                 le16_to_cpu(ppage0_alloc->MaxRxFrameSize);
289
290                         port_id = ppage0_alloc->PortIdentifier;
291                         num_targ++;
292                         *p_p0 = *ppage0_alloc;  /* save data */
293                         *p_pp0++ = p_p0++;      /* save addr */
294                 }
295                 pci_free_consistent(ioc->pcidev, data_sz,
296                                         (u8 *) ppage0_alloc, page0_dma);
297                 if (rc != 0)
298                         break;
299
300         } while (port_id <= 0xff0000);
301
302         if (num_targ) {
303                 /* sort array */
304                 if (num_targ > 1)
305                         sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *),
306                                 mptfc_FcDevPage0_cmp_func, NULL);
307                 /* call caller's func for each targ */
308                 for (ii = 0; ii < num_targ;  ii++) {
309                         fc = *(pp0_array+ii);
310                         func(ioc, ioc_port, fc);
311                 }
312         }
313
314  out:
315         if (pp0_array)
316                 kfree(pp0_array);
317         if (p0_array)
318                 kfree(p0_array);
319         return rc;
320 }
321
322 static int
323 mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid)
324 {
325         /* not currently usable */
326         if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID |
327                           MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID))
328                 return -1;
329
330         if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID))
331                 return -1;
332
333         if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET))
334                 return -1;
335
336         /*
337          * board data structure already normalized to platform endianness
338          * shifted to avoid unaligned access on 64 bit architecture
339          */
340         rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low;
341         rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low;
342         rid->port_id =   pg0->PortIdentifier;
343         rid->roles = FC_RPORT_ROLE_UNKNOWN;
344         rid->roles |= FC_RPORT_ROLE_FCP_TARGET;
345         if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
346                 rid->roles |= FC_RPORT_ROLE_FCP_INITIATOR;
347
348         return 0;
349 }
350
351 static void
352 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
353 {
354         struct fc_rport_identifiers rport_ids;
355         struct fc_rport         *rport;
356         struct mptfc_rport_info *ri;
357         int                     new_ri = 1;
358         u64                     pn;
359         unsigned long           flags;
360         VirtTarget              *vtarget;
361
362         if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
363                 return;
364
365         /* scan list looking for a match */
366         spin_lock_irqsave(&ioc->fc_rport_lock, flags);
367         list_for_each_entry(ri, &ioc->fc_rports, list) {
368                 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
369                 if (pn == rport_ids.port_name) {        /* match */
370                         list_move_tail(&ri->list, &ioc->fc_rports);
371                         new_ri = 0;
372                         break;
373                 }
374         }
375         if (new_ri) {   /* allocate one */
376                 spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
377                 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
378                 if (!ri)
379                         return;
380                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
381                 list_add_tail(&ri->list, &ioc->fc_rports);
382         }
383
384         ri->pg0 = *pg0; /* add/update pg0 data */
385         ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
386
387         /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
388         if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
389                 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
390                 spin_unlock_irqrestore(&ioc->fc_rport_lock, flags);
391                 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
392                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
393                 if (rport) {
394                         ri->rport = rport;
395                         if (new_ri) /* may have been reset by user */
396                                 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
397                         *((struct mptfc_rport_info **)rport->dd_data) = ri;
398                         /*
399                          * if already mapped, remap here.  If not mapped,
400                          * target_alloc will allocate vtarget and map,
401                          * slave_alloc will fill in vdev from vtarget.
402                          */
403                         if (ri->starget) {
404                                 vtarget = ri->starget->hostdata;
405                                 if (vtarget) {
406                                         vtarget->target_id = pg0->CurrentTargetID;
407                                         vtarget->bus_id = pg0->CurrentBus;
408                                 }
409                                 ri->remap_needed = 0;
410                         }
411                         dfcprintk ((MYIOC_s_INFO_FMT
412                                 "mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
413                                 "rport tid %d, tmo %d\n",
414                                         ioc->name,
415                                         ioc->sh->host_no,
416                                         pg0->PortIdentifier,
417                                         pg0->WWNN,
418                                         pg0->WWPN,
419                                         pg0->CurrentTargetID,
420                                         ri->rport->scsi_target_id,
421                                         ri->rport->dev_loss_tmo));
422                 } else {
423                         list_del(&ri->list);
424                         kfree(ri);
425                         ri = NULL;
426                 }
427         }
428         spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
429
430 }
431
432 /*
433  *      OS entry point to allow for host driver to free allocated memory
434  *      Called if no device present or device being unloaded
435  */
436 static void
437 mptfc_target_destroy(struct scsi_target *starget)
438 {
439         struct fc_rport         *rport;
440         struct mptfc_rport_info *ri;
441
442         rport = starget_to_rport(starget);
443         if (rport) {
444                 ri = *((struct mptfc_rport_info **)rport->dd_data);
445                 if (ri) /* better be! */
446                         ri->starget = NULL;
447         }
448         if (starget->hostdata)
449                 kfree(starget->hostdata);
450         starget->hostdata = NULL;
451 }
452
453 /*
454  *      OS entry point to allow host driver to alloc memory
455  *      for each scsi target. Called once per device the bus scan.
456  *      Return non-zero if allocation fails.
457  */
458 static int
459 mptfc_target_alloc(struct scsi_target *starget)
460 {
461         VirtTarget              *vtarget;
462         struct fc_rport         *rport;
463         struct mptfc_rport_info *ri;
464         int                     rc;
465
466         vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
467         if (!vtarget)
468                 return -ENOMEM;
469         starget->hostdata = vtarget;
470
471         rc = -ENODEV;
472         rport = starget_to_rport(starget);
473         if (rport) {
474                 ri = *((struct mptfc_rport_info **)rport->dd_data);
475                 if (ri) {       /* better be! */
476                         vtarget->target_id = ri->pg0.CurrentTargetID;
477                         vtarget->bus_id = ri->pg0.CurrentBus;
478                         ri->starget = starget;
479                         ri->remap_needed = 0;
480                         rc = 0;
481                 }
482         }
483         if (rc != 0) {
484                 kfree(vtarget);
485                 starget->hostdata = NULL;
486         }
487
488         return rc;
489 }
490
491 /*
492  *      OS entry point to allow host driver to alloc memory
493  *      for each scsi device. Called once per device the bus scan.
494  *      Return non-zero if allocation fails.
495  *      Init memory once per LUN.
496  */
497 static int
498 mptfc_slave_alloc(struct scsi_device *sdev)
499 {
500         MPT_SCSI_HOST           *hd;
501         VirtTarget              *vtarget;
502         VirtDevice              *vdev;
503         struct scsi_target      *starget;
504         struct fc_rport         *rport;
505         unsigned long           flags;
506
507
508         rport = starget_to_rport(scsi_target(sdev));
509
510         if (!rport || fc_remote_port_chkready(rport))
511                 return -ENXIO;
512
513         hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
514
515         vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
516         if (!vdev) {
517                 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
518                                 hd->ioc->name, sizeof(VirtDevice));
519                 return -ENOMEM;
520         }
521
522         spin_lock_irqsave(&hd->ioc->fc_rport_lock,flags);
523
524         sdev->hostdata = vdev;
525         starget = scsi_target(sdev);
526         vtarget = starget->hostdata;
527
528         if (vtarget->num_luns == 0) {
529                 vtarget->ioc_id = hd->ioc->id;
530                 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES |
531                                   MPT_TARGET_FLAGS_VALID_INQUIRY;
532                 hd->Targets[sdev->id] = vtarget;
533         }
534
535         vdev->vtarget = vtarget;
536         vdev->lun = sdev->lun;
537
538         spin_unlock_irqrestore(&hd->ioc->fc_rport_lock,flags);
539
540         vtarget->num_luns++;
541
542 #ifdef DMPT_DEBUG_FC
543          {
544         struct mptfc_rport_info *ri;
545         ri = *((struct mptfc_rport_info **)rport->dd_data);
546         dfcprintk ((MYIOC_s_INFO_FMT
547                 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
548                 "CurrentTargetID %d, %x %llx %llx\n",
549                 hd->ioc->name,
550                 sdev->host->host_no,
551                 vtarget->num_luns,
552                 sdev->id, ri->pg0.CurrentTargetID,
553                 ri->pg0.PortIdentifier, ri->pg0.WWPN, ri->pg0.WWNN));
554         }
555 #endif
556
557         return 0;
558 }
559
560 static int
561 mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
562 {
563         struct mptfc_rport_info *ri;
564         struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
565         int             err;
566
567         err = fc_remote_port_chkready(rport);
568         if (unlikely(err)) {
569                 SCpnt->result = err;
570                 done(SCpnt);
571                 return 0;
572         }
573         ri = *((struct mptfc_rport_info **)rport->dd_data);
574         if (unlikely(ri->remap_needed))
575                 return SCSI_MLQUEUE_HOST_BUSY;
576
577         return mptscsih_qcmd(SCpnt,done);
578 }
579
580 static void
581 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
582 {
583         unsigned class = 0, cos = 0;
584
585         /* don't know what to do as only one scsi (fc) host was allocated */
586         if (portnum != 0)
587                 return;
588
589         class = ioc->fc_port_page0[portnum].SupportedServiceClass;
590         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
591                 cos |= FC_COS_CLASS1;
592         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
593                 cos |= FC_COS_CLASS2;
594         if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
595                 cos |= FC_COS_CLASS3;
596
597         fc_host_node_name(ioc->sh) =
598                 (u64)ioc->fc_port_page0[portnum].WWNN.High << 32
599                     | (u64)ioc->fc_port_page0[portnum].WWNN.Low;
600
601         fc_host_port_name(ioc->sh) =
602                 (u64)ioc->fc_port_page0[portnum].WWPN.High << 32
603                     | (u64)ioc->fc_port_page0[portnum].WWPN.Low;
604
605         fc_host_port_id(ioc->sh) = ioc->fc_port_page0[portnum].PortIdentifier;
606
607         fc_host_supported_classes(ioc->sh) = cos;
608
609         fc_host_tgtid_bind_type(ioc->sh) = FC_TGTID_BIND_BY_WWPN;
610 }
611
612 static void
613 mptfc_rescan_devices(void *arg)
614 {
615         MPT_ADAPTER             *ioc = (MPT_ADAPTER *)arg;
616         int                     ii;
617         int                     work_to_do;
618         unsigned long           flags;
619         struct mptfc_rport_info *ri;
620
621         do {
622                 /* start by tagging all ports as missing */
623                 spin_lock_irqsave(&ioc->fc_rport_lock,flags);
624                 list_for_each_entry(ri, &ioc->fc_rports, list) {
625                         if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
626                                 ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
627                         }
628                 }
629                 spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
630
631                 /*
632                  * now rescan devices known to adapter,
633                  * will reregister existing rports
634                  */
635                 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
636                         (void) mptbase_GetFcPortPage0(ioc, ii);
637                         mptfc_init_host_attr(ioc,ii);   /* refresh */
638                         mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
639                 }
640
641                 /* delete devices still missing */
642                 spin_lock_irqsave(&ioc->fc_rport_lock, flags);
643                 list_for_each_entry(ri, &ioc->fc_rports, list) {
644                         /* if newly missing, delete it */
645                         if ((ri->flags & (MPT_RPORT_INFO_FLAGS_REGISTERED |
646                                           MPT_RPORT_INFO_FLAGS_MISSING))
647                           == (MPT_RPORT_INFO_FLAGS_REGISTERED |
648                               MPT_RPORT_INFO_FLAGS_MISSING)) {
649
650                                 ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
651                                                MPT_RPORT_INFO_FLAGS_MISSING);
652                                 ri->remap_needed = 1;
653                                 fc_remote_port_delete(ri->rport);
654                                 /*
655                                  * remote port not really deleted 'cause
656                                  * binding is by WWPN and driver only
657                                  * registers FCP_TARGETs but cannot trust
658                                  * data structures.
659                                  */
660                                 ri->rport = NULL;
661                                 dfcprintk ((MYIOC_s_INFO_FMT
662                                         "mptfc_rescan.%d: %llx deleted\n",
663                                         ioc->name,
664                                         ioc->sh->host_no,
665                                         ri->pg0.WWPN));
666                         }
667                 }
668                 spin_unlock_irqrestore(&ioc->fc_rport_lock,flags);
669
670                 /*
671                  * allow multiple passes as target state
672                  * might have changed during scan
673                  */
674                 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
675                 if (ioc->fc_rescan_work_count > 2)      /* only need one more */
676                         ioc->fc_rescan_work_count = 2;
677                 work_to_do = --ioc->fc_rescan_work_count;
678                 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
679         } while (work_to_do);
680 }
681
682 static int
683 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
684 {
685         struct Scsi_Host        *sh;
686         MPT_SCSI_HOST           *hd;
687         MPT_ADAPTER             *ioc;
688         unsigned long            flags;
689         int                      ii;
690         int                      numSGE = 0;
691         int                      scale;
692         int                      ioc_cap;
693         int                     error=0;
694         int                     r;
695
696         if ((r = mpt_attach(pdev,id)) != 0)
697                 return r;
698
699         ioc = pci_get_drvdata(pdev);
700         ioc->DoneCtx = mptfcDoneCtx;
701         ioc->TaskCtx = mptfcTaskCtx;
702         ioc->InternalCtx = mptfcInternalCtx;
703
704         /*  Added sanity check on readiness of the MPT adapter.
705          */
706         if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
707                 printk(MYIOC_s_WARN_FMT
708                   "Skipping because it's not operational!\n",
709                   ioc->name);
710                 error = -ENODEV;
711                 goto out_mptfc_probe;
712         }
713
714         if (!ioc->active) {
715                 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
716                   ioc->name);
717                 error = -ENODEV;
718                 goto out_mptfc_probe;
719         }
720
721         /*  Sanity check - ensure at least 1 port is INITIATOR capable
722          */
723         ioc_cap = 0;
724         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
725                 if (ioc->pfacts[ii].ProtocolFlags &
726                     MPI_PORTFACTS_PROTOCOL_INITIATOR)
727                         ioc_cap ++;
728         }
729
730         if (!ioc_cap) {
731                 printk(MYIOC_s_WARN_FMT
732                         "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
733                         ioc->name, ioc);
734                 return -ENODEV;
735         }
736
737         sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
738
739         if (!sh) {
740                 printk(MYIOC_s_WARN_FMT
741                         "Unable to register controller with SCSI subsystem\n",
742                         ioc->name);
743                 error = -1;
744                 goto out_mptfc_probe;
745         }
746
747         INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices,(void *)ioc);
748
749         spin_lock_irqsave(&ioc->FreeQlock, flags);
750
751         /* Attach the SCSI Host to the IOC structure
752          */
753         ioc->sh = sh;
754
755         sh->io_port = 0;
756         sh->n_io_port = 0;
757         sh->irq = 0;
758
759         /* set 16 byte cdb's */
760         sh->max_cmd_len = 16;
761
762         sh->max_id = MPT_MAX_FC_DEVICES<256 ? MPT_MAX_FC_DEVICES : 255;
763
764         sh->max_lun = MPT_LAST_LUN + 1;
765         sh->max_channel = 0;
766         sh->this_id = ioc->pfacts[0].PortSCSIID;
767
768         /* Required entry.
769          */
770         sh->unique_id = ioc->id;
771
772         /* Verify that we won't exceed the maximum
773          * number of chain buffers
774          * We can optimize:  ZZ = req_sz/sizeof(SGE)
775          * For 32bit SGE's:
776          *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
777          *               + (req_sz - 64)/sizeof(SGE)
778          * A slightly different algorithm is required for
779          * 64bit SGEs.
780          */
781         scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
782         if (sizeof(dma_addr_t) == sizeof(u64)) {
783                 numSGE = (scale - 1) *
784                   (ioc->facts.MaxChainDepth-1) + scale +
785                   (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
786                   sizeof(u32));
787         } else {
788                 numSGE = 1 + (scale - 1) *
789                   (ioc->facts.MaxChainDepth-1) + scale +
790                   (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
791                   sizeof(u32));
792         }
793
794         if (numSGE < sh->sg_tablesize) {
795                 /* Reset this value */
796                 dprintk((MYIOC_s_INFO_FMT
797                   "Resetting sg_tablesize to %d from %d\n",
798                   ioc->name, numSGE, sh->sg_tablesize));
799                 sh->sg_tablesize = numSGE;
800         }
801
802         spin_unlock_irqrestore(&ioc->FreeQlock, flags);
803
804         hd = (MPT_SCSI_HOST *) sh->hostdata;
805         hd->ioc = ioc;
806
807         /* SCSI needs scsi_cmnd lookup table!
808          * (with size equal to req_depth*PtrSz!)
809          */
810         hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
811         if (!hd->ScsiLookup) {
812                 error = -ENOMEM;
813                 goto out_mptfc_probe;
814         }
815
816         dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
817                  ioc->name, hd->ScsiLookup));
818
819         /* Allocate memory for the device structures.
820          * A non-Null pointer at an offset
821          * indicates a device exists.
822          * max_id = 1 + maximum id (hosts.h)
823          */
824         hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
825         if (!hd->Targets) {
826                 error = -ENOMEM;
827                 goto out_mptfc_probe;
828         }
829
830         dprintk((KERN_INFO "  vdev @ %p\n", hd->Targets));
831
832         /* Clear the TM flags
833          */
834         hd->tmPending = 0;
835         hd->tmState = TM_STATE_NONE;
836         hd->resetPending = 0;
837         hd->abortSCpnt = NULL;
838
839         /* Clear the pointer used to store
840          * single-threaded commands, i.e., those
841          * issued during a bus scan, dv and
842          * configuration pages.
843          */
844         hd->cmdPtr = NULL;
845
846         /* Initialize this SCSI Hosts' timers
847          * To use, set the timer expires field
848          * and add_timer
849          */
850         init_timer(&hd->timer);
851         hd->timer.data = (unsigned long) hd;
852         hd->timer.function = mptscsih_timer_expired;
853
854         hd->mpt_pq_filter = mpt_pq_filter;
855
856         ddvprintk((MYIOC_s_INFO_FMT
857                 "mpt_pq_filter %x\n",
858                 ioc->name, 
859                 mpt_pq_filter));
860
861         init_waitqueue_head(&hd->scandv_waitq);
862         hd->scandv_wait_done = 0;
863         hd->last_queue_full = 0;
864
865         sh->transportt = mptfc_transport_template;
866         error = scsi_add_host (sh, &ioc->pcidev->dev);
867         if(error) {
868                 dprintk((KERN_ERR MYNAM
869                   "scsi_add_host failed\n"));
870                 goto out_mptfc_probe;
871         }
872
873         for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
874                 mptfc_init_host_attr(ioc,ii);
875                 mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
876         }
877
878         return 0;
879
880 out_mptfc_probe:
881
882         mptscsih_remove(pdev);
883         return error;
884 }
885
886 static struct pci_driver mptfc_driver = {
887         .name           = "mptfc",
888         .id_table       = mptfc_pci_table,
889         .probe          = mptfc_probe,
890         .remove         = __devexit_p(mptfc_remove),
891         .shutdown       = mptscsih_shutdown,
892 #ifdef CONFIG_PM
893         .suspend        = mptscsih_suspend,
894         .resume         = mptscsih_resume,
895 #endif
896 };
897
898 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
899 /**
900  *      mptfc_init - Register MPT adapter(s) as SCSI host(s) with
901  *      linux scsi mid-layer.
902  *
903  *      Returns 0 for success, non-zero for failure.
904  */
905 static int __init
906 mptfc_init(void)
907 {
908         int error;
909
910         show_mptmod_ver(my_NAME, my_VERSION);
911
912         /* sanity check module parameter */
913         if (mptfc_dev_loss_tmo == 0)
914                 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
915
916         mptfc_transport_template =
917                 fc_attach_transport(&mptfc_transport_functions);
918
919         if (!mptfc_transport_template)
920                 return -ENODEV;
921
922         mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER);
923         mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER);
924         mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER);
925
926         if (mpt_event_register(mptfcDoneCtx, mptscsih_event_process) == 0) {
927                 devtverboseprintk((KERN_INFO MYNAM
928                   ": Registered for IOC event notifications\n"));
929         }
930
931         if (mpt_reset_register(mptfcDoneCtx, mptscsih_ioc_reset) == 0) {
932                 dprintk((KERN_INFO MYNAM
933                   ": Registered for IOC reset notifications\n"));
934         }
935
936         error = pci_register_driver(&mptfc_driver);
937         if (error)
938                 fc_release_transport(mptfc_transport_template);
939
940         return error;
941 }
942
943 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
944 /**
945  *      mptfc_remove - Removed fc infrastructure for devices
946  *      @pdev: Pointer to pci_dev structure
947  *
948  */
949 static void __devexit
950 mptfc_remove(struct pci_dev *pdev)
951 {
952         MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
953         struct mptfc_rport_info *p, *n;
954
955         fc_remove_host(ioc->sh);
956
957         list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
958                 list_del(&p->list);
959                 kfree(p);
960         }
961
962         mptscsih_remove(pdev);
963 }
964
965 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
966 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
967 /**
968  *      mptfc_exit - Unregisters MPT adapter(s)
969  *
970  */
971 static void __exit
972 mptfc_exit(void)
973 {
974         pci_unregister_driver(&mptfc_driver);
975         fc_release_transport(mptfc_transport_template);
976
977         mpt_reset_deregister(mptfcDoneCtx);
978         dprintk((KERN_INFO MYNAM
979           ": Deregistered for IOC reset notifications\n"));
980
981         mpt_event_deregister(mptfcDoneCtx);
982         dprintk((KERN_INFO MYNAM
983           ": Deregistered for IOC event notifications\n"));
984
985         mpt_deregister(mptfcInternalCtx);
986         mpt_deregister(mptfcTaskCtx);
987         mpt_deregister(mptfcDoneCtx);
988 }
989
990 module_init(mptfc_init);
991 module_exit(mptfc_exit);