?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ieee1394: add preprocessor constant for invalid csr address
[linux-2.6/mini2440.git] / drivers / message / fusion / mptfc.c
blob856487741ef43b0f2458e6dc6bc55a2edc354fa1
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
345 return 0;
346 }
347
348 static void
349 mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
350 {
351 struct fc_rport_identifiers rport_ids;
352 struct fc_rport *rport;
353 struct mptfc_rport_info *ri;
354 int new_ri = 1;
355 u64 pn, nn;
356 VirtTarget *vtarget;
357 u32 roles = FC_RPORT_ROLE_UNKNOWN;
358
359 if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
360 return;
361
362 roles |= FC_RPORT_ROLE_FCP_TARGET;
363 if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
364 roles |= FC_RPORT_ROLE_FCP_INITIATOR;
365
366 /* scan list looking for a match */
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 ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
377 if (!ri)
378 return;
379 list_add_tail(&ri->list, &ioc->fc_rports);
380 }
381
382 ri->pg0 = *pg0; /* add/update pg0 data */
383 ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
384
385 /* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
386 if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
387 ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
388 rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
389 if (rport) {
390 ri->rport = rport;
391 if (new_ri) /* may have been reset by user */
392 rport->dev_loss_tmo = mptfc_dev_loss_tmo;
393 /*
394 * if already mapped, remap here. If not mapped,
395 * target_alloc will allocate vtarget and map,
396 * slave_alloc will fill in vdev from vtarget.
397 */
398 if (ri->starget) {
399 vtarget = ri->starget->hostdata;
400 if (vtarget) {
401 vtarget->target_id = pg0->CurrentTargetID;
402 vtarget->bus_id = pg0->CurrentBus;
403 }
404 }
405 *((struct mptfc_rport_info **)rport->dd_data) = ri;
406 /* scan will be scheduled once rport becomes a target */
407 fc_remote_port_rolechg(rport,roles);
408
409 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
410 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
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 (unsigned long long)nn,
418 (unsigned long long)pn,
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 }
429
430 /*
431 * OS entry point to allow for host driver to free allocated memory
432 * Called if no device present or device being unloaded
433 */
434 static void
435 mptfc_target_destroy(struct scsi_target *starget)
436 {
437 struct fc_rport *rport;
438 struct mptfc_rport_info *ri;
439
440 rport = starget_to_rport(starget);
441 if (rport) {
442 ri = *((struct mptfc_rport_info **)rport->dd_data);
443 if (ri) /* better be! */
444 ri->starget = NULL;
445 }
446 if (starget->hostdata)
447 kfree(starget->hostdata);
448 starget->hostdata = NULL;
449 }
450
451 /*
452 * OS entry point to allow host driver to alloc memory
453 * for each scsi target. Called once per device the bus scan.
454 * Return non-zero if allocation fails.
455 */
456 static int
457 mptfc_target_alloc(struct scsi_target *starget)
458 {
459 VirtTarget *vtarget;
460 struct fc_rport *rport;
461 struct mptfc_rport_info *ri;
462 int rc;
463
464 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
465 if (!vtarget)
466 return -ENOMEM;
467 starget->hostdata = vtarget;
468
469 rc = -ENODEV;
470 rport = starget_to_rport(starget);
471 if (rport) {
472 ri = *((struct mptfc_rport_info **)rport->dd_data);
473 if (ri) { /* better be! */
474 vtarget->target_id = ri->pg0.CurrentTargetID;
475 vtarget->bus_id = ri->pg0.CurrentBus;
476 ri->starget = starget;
477 rc = 0;
478 }
479 }
480 if (rc != 0) {
481 kfree(vtarget);
482 starget->hostdata = NULL;
483 }
484
485 return rc;
486 }
487
488 /*
489 * OS entry point to allow host driver to alloc memory
490 * for each scsi device. Called once per device the bus scan.
491 * Return non-zero if allocation fails.
492 * Init memory once per LUN.
493 */
494 static int
495 mptfc_slave_alloc(struct scsi_device *sdev)
496 {
497 MPT_SCSI_HOST *hd;
498 VirtTarget *vtarget;
499 VirtDevice *vdev;
500 struct scsi_target *starget;
501 struct fc_rport *rport;
502
503
504 starget = scsi_target(sdev);
505 rport = starget_to_rport(starget);
506
507 if (!rport || fc_remote_port_chkready(rport))
508 return -ENXIO;
509
510 hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
511
512 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
513 if (!vdev) {
514 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
515 hd->ioc->name, sizeof(VirtDevice));
516 return -ENOMEM;
517 }
518
519
520 sdev->hostdata = vdev;
521 vtarget = starget->hostdata;
522
523 if (vtarget->num_luns == 0) {
524 vtarget->ioc_id = hd->ioc->id;
525 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES |
526 MPT_TARGET_FLAGS_VALID_INQUIRY;
527 hd->Targets[sdev->id] = vtarget;
528 }
529
530 vdev->vtarget = vtarget;
531 vdev->lun = sdev->lun;
532
533 vtarget->num_luns++;
534
535
536 #ifdef DMPT_DEBUG_FC
537 {
538 u64 nn, pn;
539 struct mptfc_rport_info *ri;
540 ri = *((struct mptfc_rport_info **)rport->dd_data);
541 pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
542 nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
543 dfcprintk ((MYIOC_s_INFO_FMT
544 "mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
545 "CurrentTargetID %d, %x %llx %llx\n",
546 hd->ioc->name,
547 sdev->host->host_no,
548 vtarget->num_luns,
549 sdev->id, ri->pg0.CurrentTargetID,
550 ri->pg0.PortIdentifier,
551 (unsigned long long)pn,
552 (unsigned long long)nn));
553 }
554 #endif
555
556 return 0;
557 }
558
559 static int
560 mptfc_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
561 {
562 struct mptfc_rport_info *ri;
563 struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
564 int err;
565
566 err = fc_remote_port_chkready(rport);
567 if (unlikely(err)) {
568 SCpnt->result = err;
569 done(SCpnt);
570 return 0;
571 }
572
573 /* dd_data is null until finished adding target */
574 ri = *((struct mptfc_rport_info **)rport->dd_data);
575 if (unlikely(!ri)) {
576 dfcprintk ((MYIOC_s_INFO_FMT
577 "mptfc_qcmd.%d: %d:%d, dd_data is null.\n",
578 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->name,
579 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->sh->host_no,
580 SCpnt->device->id,SCpnt->device->lun));
581 SCpnt->result = DID_IMM_RETRY << 16;
582 done(SCpnt);
583 return 0;
584 }
585
586 err = mptscsih_qcmd(SCpnt,done);
587 #ifdef DMPT_DEBUG_FC
588 if (unlikely(err)) {
589 dfcprintk ((MYIOC_s_INFO_FMT
590 "mptfc_qcmd.%d: %d:%d, mptscsih_qcmd returns non-zero.\n",
591 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->name,
592 ((MPT_SCSI_HOST *) SCpnt->device->host->hostdata)->ioc->sh->host_no,
593 SCpnt->device->id,SCpnt->device->lun));
594 }
595 #endif
596 return err;
597 }
598
599 static void
600 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
601 {
602 unsigned class = 0, cos = 0;
603
604 /* don't know what to do as only one scsi (fc) host was allocated */
605 if (portnum != 0)
606 return;
607
608 class = ioc->fc_port_page0[portnum].SupportedServiceClass;
609 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
610 cos |= FC_COS_CLASS1;
611 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
612 cos |= FC_COS_CLASS2;
613 if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
614 cos |= FC_COS_CLASS3;
615
616 fc_host_node_name(ioc->sh) =
617 (u64)ioc->fc_port_page0[portnum].WWNN.High << 32
618 | (u64)ioc->fc_port_page0[portnum].WWNN.Low;
619
620 fc_host_port_name(ioc->sh) =
621 (u64)ioc->fc_port_page0[portnum].WWPN.High << 32
622 | (u64)ioc->fc_port_page0[portnum].WWPN.Low;
623
624 fc_host_port_id(ioc->sh) = ioc->fc_port_page0[portnum].PortIdentifier;
625
626 fc_host_supported_classes(ioc->sh) = cos;
627
628 fc_host_tgtid_bind_type(ioc->sh) = FC_TGTID_BIND_BY_WWPN;
629 }
630
631 static void
632 mptfc_rescan_devices(void *arg)
633 {
634 MPT_ADAPTER *ioc = (MPT_ADAPTER *)arg;
635 int ii;
636 int work_to_do;
637 u64 pn;
638 unsigned long flags;
639 struct mptfc_rport_info *ri;
640
641 do {
642 /* start by tagging all ports as missing */
643 list_for_each_entry(ri, &ioc->fc_rports, list) {
644 if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
645 ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
646 }
647 }
648
649 /*
650 * now rescan devices known to adapter,
651 * will reregister existing rports
652 */
653 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
654 (void) mptbase_GetFcPortPage0(ioc, ii);
655 mptfc_init_host_attr(ioc,ii); /* refresh */
656 mptfc_GetFcDevPage0(ioc,ii,mptfc_register_dev);
657 }
658
659 /* delete devices still missing */
660 list_for_each_entry(ri, &ioc->fc_rports, list) {
661 /* if newly missing, delete it */
662 if (ri->flags & MPT_RPORT_INFO_FLAGS_MISSING) {
663
664 ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
665 MPT_RPORT_INFO_FLAGS_MISSING);
666 fc_remote_port_delete(ri->rport); /* won't sleep */
667 ri->rport = NULL;
668
669 pn = (u64)ri->pg0.WWPN.High << 32 |
670 (u64)ri->pg0.WWPN.Low;
671 dfcprintk ((MYIOC_s_INFO_FMT
672 "mptfc_rescan.%d: %llx deleted\n",
673 ioc->name,
674 ioc->sh->host_no,
675 (unsigned long long)pn));
676 }
677 }
678
679 /*
680 * allow multiple passes as target state
681 * might have changed during scan
682 */
683 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
684 if (ioc->fc_rescan_work_count > 2) /* only need one more */
685 ioc->fc_rescan_work_count = 2;
686 work_to_do = --ioc->fc_rescan_work_count;
687 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
688 } while (work_to_do);
689 }
690
691 static int
692 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
693 {
694 struct Scsi_Host *sh;
695 MPT_SCSI_HOST *hd;
696 MPT_ADAPTER *ioc;
697 unsigned long flags;
698 int ii;
699 int numSGE = 0;
700 int scale;
701 int ioc_cap;
702 int error=0;
703 int r;
704
705 if ((r = mpt_attach(pdev,id)) != 0)
706 return r;
707
708 ioc = pci_get_drvdata(pdev);
709 ioc->DoneCtx = mptfcDoneCtx;
710 ioc->TaskCtx = mptfcTaskCtx;
711 ioc->InternalCtx = mptfcInternalCtx;
712
713 /* Added sanity check on readiness of the MPT adapter.
714 */
715 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
716 printk(MYIOC_s_WARN_FMT
717 "Skipping because it's not operational!\n",
718 ioc->name);
719 error = -ENODEV;
720 goto out_mptfc_probe;
721 }
722
723 if (!ioc->active) {
724 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
725 ioc->name);
726 error = -ENODEV;
727 goto out_mptfc_probe;
728 }
729
730 /* Sanity check - ensure at least 1 port is INITIATOR capable
731 */
732 ioc_cap = 0;
733 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
734 if (ioc->pfacts[ii].ProtocolFlags &
735 MPI_PORTFACTS_PROTOCOL_INITIATOR)
736 ioc_cap ++;
737 }
738
739 if (!ioc_cap) {
740 printk(MYIOC_s_WARN_FMT
741 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
742 ioc->name, ioc);
743 return -ENODEV;
744 }
745
746 sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
747
748 if (!sh) {
749 printk(MYIOC_s_WARN_FMT
750 "Unable to register controller with SCSI subsystem\n",
751 ioc->name);
752 error = -1;
753 goto out_mptfc_probe;
754 }
755
756 INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices,(void *)ioc);
757
758 spin_lock_irqsave(&ioc->FreeQlock, flags);
759
760 /* Attach the SCSI Host to the IOC structure
761 */
762 ioc->sh = sh;
763
764 sh->io_port = 0;
765 sh->n_io_port = 0;
766 sh->irq = 0;
767
768 /* set 16 byte cdb's */
769 sh->max_cmd_len = 16;
770
771 sh->max_id = MPT_MAX_FC_DEVICES<256 ? MPT_MAX_FC_DEVICES : 255;
772
773 sh->max_lun = MPT_LAST_LUN + 1;
774 sh->max_channel = 0;
775 sh->this_id = ioc->pfacts[0].PortSCSIID;
776
777 /* Required entry.
778 */
779 sh->unique_id = ioc->id;
780
781 /* Verify that we won't exceed the maximum
782 * number of chain buffers
783 * We can optimize: ZZ = req_sz/sizeof(SGE)
784 * For 32bit SGE's:
785 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
786 * + (req_sz - 64)/sizeof(SGE)
787 * A slightly different algorithm is required for
788 * 64bit SGEs.
789 */
790 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
791 if (sizeof(dma_addr_t) == sizeof(u64)) {
792 numSGE = (scale - 1) *
793 (ioc->facts.MaxChainDepth-1) + scale +
794 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
795 sizeof(u32));
796 } else {
797 numSGE = 1 + (scale - 1) *
798 (ioc->facts.MaxChainDepth-1) + scale +
799 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
800 sizeof(u32));
801 }
802
803 if (numSGE < sh->sg_tablesize) {
804 /* Reset this value */
805 dprintk((MYIOC_s_INFO_FMT
806 "Resetting sg_tablesize to %d from %d\n",
807 ioc->name, numSGE, sh->sg_tablesize));
808 sh->sg_tablesize = numSGE;
809 }
810
811 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
812
813 hd = (MPT_SCSI_HOST *) sh->hostdata;
814 hd->ioc = ioc;
815
816 /* SCSI needs scsi_cmnd lookup table!
817 * (with size equal to req_depth*PtrSz!)
818 */
819 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
820 if (!hd->ScsiLookup) {
821 error = -ENOMEM;
822 goto out_mptfc_probe;
823 }
824
825 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
826 ioc->name, hd->ScsiLookup));
827
828 /* Allocate memory for the device structures.
829 * A non-Null pointer at an offset
830 * indicates a device exists.
831 * max_id = 1 + maximum id (hosts.h)
832 */
833 hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC);
834 if (!hd->Targets) {
835 error = -ENOMEM;
836 goto out_mptfc_probe;
837 }
838
839 dprintk((KERN_INFO " vdev @ %p\n", hd->Targets));
840
841 /* Clear the TM flags
842 */
843 hd->tmPending = 0;
844 hd->tmState = TM_STATE_NONE;
845 hd->resetPending = 0;
846 hd->abortSCpnt = NULL;
847
848 /* Clear the pointer used to store
849 * single-threaded commands, i.e., those
850 * issued during a bus scan, dv and
851 * configuration pages.
852 */
853 hd->cmdPtr = NULL;
854
855 /* Initialize this SCSI Hosts' timers
856 * To use, set the timer expires field
857 * and add_timer
858 */
859 init_timer(&hd->timer);
860 hd->timer.data = (unsigned long) hd;
861 hd->timer.function = mptscsih_timer_expired;
862
863 hd->mpt_pq_filter = mpt_pq_filter;
864
865 ddvprintk((MYIOC_s_INFO_FMT
866 "mpt_pq_filter %x\n",
867 ioc->name,
868 mpt_pq_filter));
869
870 init_waitqueue_head(&hd->scandv_waitq);
871 hd->scandv_wait_done = 0;
872 hd->last_queue_full = 0;
873
874 sh->transportt = mptfc_transport_template;
875 error = scsi_add_host (sh, &ioc->pcidev->dev);
876 if(error) {
877 dprintk((KERN_ERR MYNAM
878 "scsi_add_host failed\n"));
879 goto out_mptfc_probe;
880 }
881
882 /* initialize workqueue */
883
884 snprintf(ioc->fc_rescan_work_q_name, KOBJ_NAME_LEN, "mptfc_wq_%d",
885 sh->host_no);
886 ioc->fc_rescan_work_q =
887 create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
888 if (!ioc->fc_rescan_work_q)
889 goto out_mptfc_probe;
890
891 /*
892 * scan for rports -
893 * by doing it via the workqueue, some locking is eliminated
894 */
895
896 ioc->fc_rescan_work_count = 1;
897 queue_work(ioc->fc_rescan_work_q, &ioc->fc_rescan_work);
898 flush_workqueue(ioc->fc_rescan_work_q);
899
900 return 0;
901
902 out_mptfc_probe:
903
904 mptscsih_remove(pdev);
905 return error;
906 }
907
908 static struct pci_driver mptfc_driver = {
909 .name = "mptfc",
910 .id_table = mptfc_pci_table,
911 .probe = mptfc_probe,
912 .remove = __devexit_p(mptfc_remove),
913 .shutdown = mptscsih_shutdown,
914 #ifdef CONFIG_PM
915 .suspend = mptscsih_suspend,
916 .resume = mptscsih_resume,
917 #endif
918 };
919
920 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
921 /**
922 * mptfc_init - Register MPT adapter(s) as SCSI host(s) with
923 * linux scsi mid-layer.
924 *
925 * Returns 0 for success, non-zero for failure.
926 */
927 static int __init
928 mptfc_init(void)
929 {
930 int error;
931
932 show_mptmod_ver(my_NAME, my_VERSION);
933
934 /* sanity check module parameter */
935 if (mptfc_dev_loss_tmo == 0)
936 mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
937
938 mptfc_transport_template =
939 fc_attach_transport(&mptfc_transport_functions);
940
941 if (!mptfc_transport_template)
942 return -ENODEV;
943
944 mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER);
945 mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER);
946 mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER);
947
948 if (mpt_event_register(mptfcDoneCtx, mptscsih_event_process) == 0) {
949 devtverboseprintk((KERN_INFO MYNAM
950 ": Registered for IOC event notifications\n"));
951 }
952
953 if (mpt_reset_register(mptfcDoneCtx, mptscsih_ioc_reset) == 0) {
954 dprintk((KERN_INFO MYNAM
955 ": Registered for IOC reset notifications\n"));
956 }
957
958 error = pci_register_driver(&mptfc_driver);
959 if (error)
960 fc_release_transport(mptfc_transport_template);
961
962 return error;
963 }
964
965 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
966 /**
967 * mptfc_remove - Removed fc infrastructure for devices
968 * @pdev: Pointer to pci_dev structure
969 *
970 */
971 static void __devexit
972 mptfc_remove(struct pci_dev *pdev)
973 {
974 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
975 struct mptfc_rport_info *p, *n;
976 struct workqueue_struct *work_q;
977 unsigned long flags;
978
979 /* destroy workqueue */
980 if ((work_q=ioc->fc_rescan_work_q)) {
981 spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
982 ioc->fc_rescan_work_q = NULL;
983 spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
984 destroy_workqueue(work_q);
985 }
986
987 fc_remove_host(ioc->sh);
988
989 list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
990 list_del(&p->list);
991 kfree(p);
992 }
993
994 mptscsih_remove(pdev);
995 }
996
997 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
998 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
999 /**
1000 * mptfc_exit - Unregisters MPT adapter(s)
1001 *
1002 */
1003 static void __exit
1004 mptfc_exit(void)
1005 {
1006 pci_unregister_driver(&mptfc_driver);
1007 fc_release_transport(mptfc_transport_template);
1008
1009 mpt_reset_deregister(mptfcDoneCtx);
1010 dprintk((KERN_INFO MYNAM
1011 ": Deregistered for IOC reset notifications\n"));
1012
1013 mpt_event_deregister(mptfcDoneCtx);
1014 dprintk((KERN_INFO MYNAM
1015 ": Deregistered for IOC event notifications\n"));
1016
1017 mpt_deregister(mptfcInternalCtx);
1018 mpt_deregister(mptfcTaskCtx);
1019 mpt_deregister(mptfcDoneCtx);
1020 }
1021
1022 module_init(mptfc_init);
1023 module_exit(mptfc_exit);
Support for the Chinese Samsung S3C2440 based development boards