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