1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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>
54#include <linux/interrupt.h>
55#include <linux/reboot.h>
56#include <linux/workqueue.h>
57#include <linux/raid_class.h>
58
59#include <scsi/scsi.h>
60#include <scsi/scsi_cmnd.h>
61#include <scsi/scsi_device.h>
62#include <scsi/scsi_host.h>
63#include <scsi/scsi_tcq.h>
64#include <scsi/scsi_transport.h>
65#include <scsi/scsi_transport_spi.h>
66#include <scsi/scsi_dbg.h>
67
68#include "mptbase.h"
69#include "mptscsih.h"
70
71
72#define my_NAME "Fusion MPT SPI Host driver"
73#define my_VERSION MPT_LINUX_VERSION_COMMON
74#define MYNAM "mptspi"
75
76MODULE_AUTHOR(MODULEAUTHOR);
77MODULE_DESCRIPTION(my_NAME);
78MODULE_LICENSE("GPL");
79MODULE_VERSION(my_VERSION);
80
81
82static int mpt_saf_te = MPTSCSIH_SAF_TE;
83module_param(mpt_saf_te, int, 0);
84MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
85
86static void mptspi_write_offset(struct scsi_target *, int);
87static void mptspi_write_width(struct scsi_target *, int);
88static int mptspi_write_spi_device_pg1(struct scsi_target *,
89 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
90
91static struct scsi_transport_template *mptspi_transport_template = NULL;
92
93static u8 mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
94static u8 mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
95static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS;
96
97
98
99
100
101
102
103
104
105
106static void
107mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
108 struct scsi_device *sdev)
109{
110 MPT_ADAPTER *ioc = hd->ioc;
111 SpiCfgData *pspi_data = &ioc->spi_data;
112 int id = (int) target->id;
113 int nvram;
114 u8 width = MPT_NARROW;
115 u8 factor = MPT_ASYNC;
116 u8 offset = 0;
117 u8 nfactor;
118 u8 noQas = 1;
119
120 target->negoFlags = pspi_data->noQas;
121
122 if (sdev->scsi_level < SCSI_2) {
123 width = 0;
124 factor = MPT_ULTRA2;
125 offset = pspi_data->maxSyncOffset;
126 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
127 } else {
128 if (scsi_device_wide(sdev))
129 width = 1;
130
131 if (scsi_device_sync(sdev)) {
132 factor = pspi_data->minSyncFactor;
133 if (!scsi_device_dt(sdev))
134 factor = MPT_ULTRA2;
135 else {
136 if (!scsi_device_ius(sdev) &&
137 !scsi_device_qas(sdev))
138 factor = MPT_ULTRA160;
139 else {
140 factor = MPT_ULTRA320;
141 if (scsi_device_qas(sdev)) {
142 ddvprintk(ioc,
143 printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
144 "byte56=%02x on id=%d!\n", ioc->name,
145 scsi_device_qas(sdev), id));
146 noQas = 0;
147 }
148 if (sdev->type == TYPE_TAPE &&
149 scsi_device_ius(sdev))
150 target->negoFlags |= MPT_TAPE_NEGO_IDP;
151 }
152 }
153 offset = pspi_data->maxSyncOffset;
154
155
156
157
158
159
160
161 if (target->raidVolume == 1)
162 noQas = 0;
163 } else {
164 factor = MPT_ASYNC;
165 offset = 0;
166 }
167 }
168
169 if (!sdev->tagged_supported)
170 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
171
172
173
174 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
175 nvram = pspi_data->nvram[id];
176 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
177
178 if (width)
179 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
180
181 if (offset > 0) {
182
183
184
185 if (nfactor) {
186 if (nfactor < pspi_data->minSyncFactor )
187 nfactor = pspi_data->minSyncFactor;
188
189 factor = max(factor, nfactor);
190 if (factor == MPT_ASYNC)
191 offset = 0;
192 } else {
193 offset = 0;
194 factor = MPT_ASYNC;
195 }
196 } else {
197 factor = MPT_ASYNC;
198 }
199 }
200
201
202
203 if ((!width) && (factor < MPT_ULTRA2))
204 factor = MPT_ULTRA2;
205
206
207
208 target->minSyncFactor = factor;
209 target->maxOffset = offset;
210 target->maxWidth = width;
211
212 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
213
214
215
216 if (!width)
217 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
218
219 if (!offset)
220 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
221
222 if ( factor > MPT_ULTRA320 )
223 noQas = 0;
224
225 if (noQas && (pspi_data->noQas == 0)) {
226 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
227 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
228
229
230
231
232 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
233 "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
234 }
235}
236
237
238
239
240
241
242
243
244
245
246
247
248static int
249mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
250{
251 MPT_ADAPTER *ioc = hd->ioc;
252 Config_t *pReq;
253 IOCPage4_t *IOCPage4Ptr;
254 MPT_FRAME_HDR *mf;
255 dma_addr_t dataDma;
256 u16 req_idx;
257 u32 frameOffset;
258 u32 flagsLength;
259 int ii;
260
261
262
263 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
264 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
265 "writeIOCPage4 : no msg frames!\n",ioc->name));
266 return -EAGAIN;
267 }
268
269
270
271
272 pReq = (Config_t *)mf;
273
274 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
275 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
276
277
278
279 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
280 pReq->Reserved = 0;
281 pReq->ChainOffset = 0;
282 pReq->Function = MPI_FUNCTION_CONFIG;
283 pReq->ExtPageLength = 0;
284 pReq->ExtPageType = 0;
285 pReq->MsgFlags = 0;
286 for (ii=0; ii < 8; ii++) {
287 pReq->Reserved2[ii] = 0;
288 }
289
290 IOCPage4Ptr = ioc->spi_data.pIocPg4;
291 dataDma = ioc->spi_data.IocPg4_dma;
292 ii = IOCPage4Ptr->ActiveSEP++;
293 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
294 IOCPage4Ptr->SEP[ii].SEPBus = channel;
295 pReq->Header = IOCPage4Ptr->Header;
296 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
297
298
299
300 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
301 (IOCPage4Ptr->Header.PageLength + ii) * 4;
302
303 ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
304
305 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
306 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
307 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
308
309 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
310
311 return 0;
312}
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327static void
328mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
329 struct scsi_device *sdev)
330{
331
332
333
334
335 if (sdev->inq_periph_qual != 0)
336 return;
337
338 if (vtarget == NULL)
339 return;
340
341 vtarget->type = sdev->type;
342
343 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
344
345
346 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
347 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
348 }else if ((sdev->type == TYPE_PROCESSOR) &&
349 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
350 if (sdev->inquiry_len > 49 ) {
351 if (sdev->inquiry[44] == 'S' &&
352 sdev->inquiry[45] == 'A' &&
353 sdev->inquiry[46] == 'F' &&
354 sdev->inquiry[47] == '-' &&
355 sdev->inquiry[48] == 'T' &&
356 sdev->inquiry[49] == 'E' ) {
357 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
358 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
359 }
360 }
361 }
362 mptspi_setTargetNegoParms(hd, vtarget, sdev);
363}
364
365
366
367
368
369
370
371
372
373
374
375static int
376mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
377{
378 int i, rc = 0;
379 MPT_ADAPTER *ioc = hd->ioc;
380
381 if (!ioc->raid_data.pIocPg2)
382 goto out;
383
384 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
385 goto out;
386 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
387 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
388 rc = 1;
389 goto out;
390 }
391 }
392
393 out:
394 return rc;
395}
396
397static int mptspi_target_alloc(struct scsi_target *starget)
398{
399 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
400 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
401 VirtTarget *vtarget;
402 MPT_ADAPTER *ioc;
403
404 if (hd == NULL)
405 return -ENODEV;
406
407 ioc = hd->ioc;
408 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
409 if (!vtarget)
410 return -ENOMEM;
411
412 vtarget->ioc_id = ioc->id;
413 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
414 vtarget->id = (u8)starget->id;
415 vtarget->channel = (u8)starget->channel;
416 vtarget->starget = starget;
417 starget->hostdata = vtarget;
418
419 if (starget->channel == 1) {
420 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
421 return 0;
422 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
423
424 vtarget->channel = 0;
425
426 vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
427 starget->id);
428 }
429
430 if (starget->channel == 0 &&
431 mptspi_is_raid(hd, starget->id)) {
432 vtarget->raidVolume = 1;
433 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
434 "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
435 starget->id));
436 }
437
438 if (ioc->spi_data.nvram &&
439 ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
440 u32 nvram = ioc->spi_data.nvram[starget->id];
441 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
442 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
443 } else {
444 spi_min_period(starget) = ioc->spi_data.minSyncFactor;
445 spi_max_width(starget) = ioc->spi_data.maxBusWidth;
446 }
447 spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
448
449 spi_offset(starget) = 0;
450 spi_period(starget) = 0xFF;
451 mptspi_write_width(starget, 0);
452
453 return 0;
454}
455
456static void
457mptspi_target_destroy(struct scsi_target *starget)
458{
459 if (starget->hostdata)
460 kfree(starget->hostdata);
461 starget->hostdata = NULL;
462}
463
464
465
466
467
468
469
470
471static void
472mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
473{
474 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
475 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
476 hd->ioc->name, starget->id, ii,
477 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
478 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
479 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
480 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
481 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
482 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
483 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
484 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
485 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
486 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
487}
488
489
490
491
492
493
494
495
496static void
497mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
498{
499 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
500 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
501 hd->ioc->name, starget->id, ii,
502 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
503 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
504 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
505 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
506 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
507 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
508 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
509 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
510 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
511 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
512}
513
514static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
515 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
516{
517 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
518 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
519 struct _MPT_ADAPTER *ioc = hd->ioc;
520 struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
521 dma_addr_t spi_dev_pg0_dma;
522 int size;
523 struct _x_config_parms cfg;
524 struct _CONFIG_PAGE_HEADER hdr;
525 int err = -EBUSY;
526
527
528 if (starget->channel == 0 &&
529 mptspi_is_raid(hd, starget->id))
530 return -1;
531
532 size = ioc->spi_data.sdp0length * 4;
533
534
535
536
537
538
539 spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
540 if (spi_dev_pg0 == NULL) {
541 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
542 "dma_alloc_coherent for parameters failed\n", ioc->name);
543 return -EINVAL;
544 }
545
546 memset(&hdr, 0, sizeof(hdr));
547
548 hdr.PageVersion = ioc->spi_data.sdp0version;
549 hdr.PageLength = ioc->spi_data.sdp0length;
550 hdr.PageNumber = 0;
551 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
552
553 memset(&cfg, 0, sizeof(cfg));
554
555 cfg.cfghdr.hdr = &hdr;
556 cfg.physAddr = spi_dev_pg0_dma;
557 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
558 cfg.dir = 0;
559 cfg.pageAddr = starget->id;
560
561 if (mpt_config(ioc, &cfg)) {
562 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
563 goto out_free;
564 }
565 err = 0;
566 memcpy(pass_pg0, spi_dev_pg0, size);
567
568 mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
569
570 out_free:
571 dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
572 return err;
573}
574
575static u32 mptspi_getRP(struct scsi_target *starget)
576{
577 u32 nego = 0;
578
579 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
580 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
581 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
582 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
583 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
584 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
585 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
586 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
587
588 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
589 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
590 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
591
592 return nego;
593}
594
595static void mptspi_read_parameters(struct scsi_target *starget)
596{
597 int nego;
598 struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
599
600 mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
601
602 nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
603
604 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
605 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
606 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
607 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
608 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
609 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
610 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
611 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
612 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
613 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
614 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
615}
616
617int
618mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
619{
620 MPT_ADAPTER *ioc = hd->ioc;
621 MpiRaidActionRequest_t *pReq;
622 MPT_FRAME_HDR *mf;
623 int ret;
624 unsigned long timeleft;
625
626 mutex_lock(&ioc->internal_cmds.mutex);
627
628
629
630 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
631 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
632 "%s: no msg frames!\n", ioc->name, __func__));
633 ret = -EAGAIN;
634 goto out;
635 }
636 pReq = (MpiRaidActionRequest_t *)mf;
637 if (quiesce)
638 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
639 else
640 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
641 pReq->Reserved1 = 0;
642 pReq->ChainOffset = 0;
643 pReq->Function = MPI_FUNCTION_RAID_ACTION;
644 pReq->VolumeID = id;
645 pReq->VolumeBus = channel;
646 pReq->PhysDiskNum = 0;
647 pReq->MsgFlags = 0;
648 pReq->Reserved2 = 0;
649 pReq->ActionDataWord = 0;
650
651 ioc->add_sge((char *)&pReq->ActionDataSGE,
652 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
653
654 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
655 ioc->name, pReq->Action, channel, id));
656
657 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
658 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
659 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
660 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
661 ret = -ETIME;
662 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
663 ioc->name, __func__));
664 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
665 goto out;
666 if (!timeleft) {
667 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
668 ioc->name, __func__);
669 mpt_HardResetHandler(ioc, CAN_SLEEP);
670 mpt_free_msg_frame(ioc, mf);
671 }
672 goto out;
673 }
674
675 ret = ioc->internal_cmds.completion_code;
676
677 out:
678 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
679 mutex_unlock(&ioc->internal_cmds.mutex);
680 return ret;
681}
682
683static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
684 struct scsi_device *sdev)
685{
686 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
687 MPT_ADAPTER *ioc = hd->ioc;
688
689
690 if (sdev->channel == 0 &&
691 mptspi_is_raid(hd, sdev->id))
692 return;
693
694
695 if (sdev->channel == 1 &&
696 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
697 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
698 "Integrated RAID quiesce failed\n", ioc->name);
699 return;
700 }
701
702 hd->spi_pending |= (1 << sdev->id);
703 spi_dv_device(sdev);
704 hd->spi_pending &= ~(1 << sdev->id);
705
706 if (sdev->channel == 1 &&
707 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
708 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
709 "Integrated RAID resume failed\n", ioc->name);
710
711 mptspi_read_parameters(sdev->sdev_target);
712 spi_display_xfer_agreement(sdev->sdev_target);
713 mptspi_read_parameters(sdev->sdev_target);
714}
715
716static int mptspi_slave_alloc(struct scsi_device *sdev)
717{
718 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
719 VirtTarget *vtarget;
720 VirtDevice *vdevice;
721 struct scsi_target *starget;
722 MPT_ADAPTER *ioc = hd->ioc;
723
724 if (sdev->channel == 1 &&
725 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
726 return -ENXIO;
727
728 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
729 if (!vdevice) {
730 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
731 ioc->name, sizeof(VirtDevice));
732 return -ENOMEM;
733 }
734
735 vdevice->lun = sdev->lun;
736 sdev->hostdata = vdevice;
737
738 starget = scsi_target(sdev);
739 vtarget = starget->hostdata;
740 vdevice->vtarget = vtarget;
741 vtarget->num_luns++;
742
743 if (sdev->channel == 1)
744 sdev->no_uld_attach = 1;
745
746 return 0;
747}
748
749static int mptspi_slave_configure(struct scsi_device *sdev)
750{
751 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
752 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
753 int ret;
754
755 mptspi_initTarget(hd, vtarget, sdev);
756
757 ret = mptscsih_slave_configure(sdev);
758
759 if (ret)
760 return ret;
761
762 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
763 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
764 sdev->id, spi_min_period(scsi_target(sdev)),
765 spi_max_offset(scsi_target(sdev)),
766 spi_max_width(scsi_target(sdev))));
767
768 if ((sdev->channel == 1 ||
769 !(mptspi_is_raid(hd, sdev->id))) &&
770 !spi_initial_dv(sdev->sdev_target))
771 mptspi_dv_device(hd, sdev);
772
773 return 0;
774}
775
776static int
777mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
778{
779 struct _MPT_SCSI_HOST *hd = shost_priv(SCpnt->device->host);
780 VirtDevice *vdevice = SCpnt->device->hostdata;
781 MPT_ADAPTER *ioc = hd->ioc;
782
783 if (!vdevice || !vdevice->vtarget) {
784 SCpnt->result = DID_NO_CONNECT << 16;
785 done(SCpnt);
786 return 0;
787 }
788
789 if (SCpnt->device->channel == 1 &&
790 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
791 SCpnt->result = DID_NO_CONNECT << 16;
792 done(SCpnt);
793 return 0;
794 }
795
796 if (spi_dv_pending(scsi_target(SCpnt->device)))
797 ddvprintk(ioc, scsi_print_command(SCpnt));
798
799 return mptscsih_qcmd(SCpnt,done);
800}
801
802static void mptspi_slave_destroy(struct scsi_device *sdev)
803{
804 struct scsi_target *starget = scsi_target(sdev);
805 VirtTarget *vtarget = starget->hostdata;
806 VirtDevice *vdevice = sdev->hostdata;
807
808
809 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
810 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
811
812
813 pg1.RequestedParameters = 0;
814 pg1.Reserved = 0;
815 pg1.Configuration = 0;
816
817 mptspi_write_spi_device_pg1(starget, &pg1);
818 }
819
820 mptscsih_slave_destroy(sdev);
821}
822
823static struct scsi_host_template mptspi_driver_template = {
824 .module = THIS_MODULE,
825 .proc_name = "mptspi",
826 .proc_info = mptscsih_proc_info,
827 .name = "MPT SPI Host",
828 .info = mptscsih_info,
829 .queuecommand = mptspi_qcmd,
830 .target_alloc = mptspi_target_alloc,
831 .slave_alloc = mptspi_slave_alloc,
832 .slave_configure = mptspi_slave_configure,
833 .target_destroy = mptspi_target_destroy,
834 .slave_destroy = mptspi_slave_destroy,
835 .change_queue_depth = mptscsih_change_queue_depth,
836 .eh_abort_handler = mptscsih_abort,
837 .eh_device_reset_handler = mptscsih_dev_reset,
838 .eh_bus_reset_handler = mptscsih_bus_reset,
839 .eh_host_reset_handler = mptscsih_host_reset,
840 .bios_param = mptscsih_bios_param,
841 .can_queue = MPT_SCSI_CAN_QUEUE,
842 .this_id = -1,
843 .sg_tablesize = MPT_SCSI_SG_DEPTH,
844 .max_sectors = 8192,
845 .cmd_per_lun = 7,
846 .use_clustering = ENABLE_CLUSTERING,
847 .shost_attrs = mptscsih_host_attrs,
848};
849
850static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
851 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
852{
853 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
854 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
855 struct _MPT_ADAPTER *ioc = hd->ioc;
856 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
857 dma_addr_t pg1_dma;
858 int size;
859 struct _x_config_parms cfg;
860 struct _CONFIG_PAGE_HEADER hdr;
861 int err = -EBUSY;
862
863
864 if (starget->channel == 0 &&
865 mptspi_is_raid(hd, starget->id))
866 return -1;
867
868 size = ioc->spi_data.sdp1length * 4;
869
870 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
871 if (pg1 == NULL) {
872 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
873 "dma_alloc_coherent for parameters failed\n", ioc->name);
874 return -EINVAL;
875 }
876
877 memset(&hdr, 0, sizeof(hdr));
878
879 hdr.PageVersion = ioc->spi_data.sdp1version;
880 hdr.PageLength = ioc->spi_data.sdp1length;
881 hdr.PageNumber = 1;
882 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
883
884 memset(&cfg, 0, sizeof(cfg));
885
886 cfg.cfghdr.hdr = &hdr;
887 cfg.physAddr = pg1_dma;
888 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
889 cfg.dir = 1;
890 cfg.pageAddr = starget->id;
891
892 memcpy(pg1, pass_pg1, size);
893
894 pg1->Header.PageVersion = hdr.PageVersion;
895 pg1->Header.PageLength = hdr.PageLength;
896 pg1->Header.PageNumber = hdr.PageNumber;
897 pg1->Header.PageType = hdr.PageType;
898
899 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
900
901 if (mpt_config(ioc, &cfg)) {
902 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
903 "mpt_config failed\n", ioc->name);
904 goto out_free;
905 }
906 err = 0;
907
908 out_free:
909 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
910 return err;
911}
912
913static void mptspi_write_offset(struct scsi_target *starget, int offset)
914{
915 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
916 u32 nego;
917
918 if (offset < 0)
919 offset = 0;
920
921 if (offset > 255)
922 offset = 255;
923
924 if (spi_offset(starget) == -1)
925 mptspi_read_parameters(starget);
926
927 spi_offset(starget) = offset;
928
929 nego = mptspi_getRP(starget);
930
931 pg1.RequestedParameters = cpu_to_le32(nego);
932 pg1.Reserved = 0;
933 pg1.Configuration = 0;
934
935 mptspi_write_spi_device_pg1(starget, &pg1);
936}
937
938static void mptspi_write_period(struct scsi_target *starget, int period)
939{
940 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
941 u32 nego;
942
943 if (period < 8)
944 period = 8;
945
946 if (period > 255)
947 period = 255;
948
949 if (spi_period(starget) == -1)
950 mptspi_read_parameters(starget);
951
952 if (period == 8) {
953 spi_iu(starget) = 1;
954 spi_dt(starget) = 1;
955 } else if (period == 9) {
956 spi_dt(starget) = 1;
957 }
958
959 spi_period(starget) = period;
960
961 nego = mptspi_getRP(starget);
962
963 pg1.RequestedParameters = cpu_to_le32(nego);
964 pg1.Reserved = 0;
965 pg1.Configuration = 0;
966
967 mptspi_write_spi_device_pg1(starget, &pg1);
968}
969
970static void mptspi_write_dt(struct scsi_target *starget, int dt)
971{
972 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
973 u32 nego;
974
975 if (spi_period(starget) == -1)
976 mptspi_read_parameters(starget);
977
978 if (!dt && spi_period(starget) < 10)
979 spi_period(starget) = 10;
980
981 spi_dt(starget) = dt;
982
983 nego = mptspi_getRP(starget);
984
985
986 pg1.RequestedParameters = cpu_to_le32(nego);
987 pg1.Reserved = 0;
988 pg1.Configuration = 0;
989
990 mptspi_write_spi_device_pg1(starget, &pg1);
991}
992
993static void mptspi_write_iu(struct scsi_target *starget, int iu)
994{
995 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
996 u32 nego;
997
998 if (spi_period(starget) == -1)
999 mptspi_read_parameters(starget);
1000
1001 if (!iu && spi_period(starget) < 9)
1002 spi_period(starget) = 9;
1003
1004 spi_iu(starget) = iu;
1005
1006 nego = mptspi_getRP(starget);
1007
1008 pg1.RequestedParameters = cpu_to_le32(nego);
1009 pg1.Reserved = 0;
1010 pg1.Configuration = 0;
1011
1012 mptspi_write_spi_device_pg1(starget, &pg1);
1013}
1014
1015#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1016static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1017{ \
1018 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1019 u32 nego; \
1020 \
1021 spi_##parm(starget) = parm; \
1022 \
1023 nego = mptspi_getRP(starget); \
1024 \
1025 pg1.RequestedParameters = cpu_to_le32(nego); \
1026 pg1.Reserved = 0; \
1027 pg1.Configuration = 0; \
1028 \
1029 mptspi_write_spi_device_pg1(starget, &pg1); \
1030}
1031
1032MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1033MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1034MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1035MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1036MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1037
1038static void mptspi_write_qas(struct scsi_target *starget, int qas)
1039{
1040 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1041 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1042 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1043 VirtTarget *vtarget = starget->hostdata;
1044 u32 nego;
1045
1046 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1047 hd->ioc->spi_data.noQas)
1048 spi_qas(starget) = 0;
1049 else
1050 spi_qas(starget) = qas;
1051
1052 nego = mptspi_getRP(starget);
1053
1054 pg1.RequestedParameters = cpu_to_le32(nego);
1055 pg1.Reserved = 0;
1056 pg1.Configuration = 0;
1057
1058 mptspi_write_spi_device_pg1(starget, &pg1);
1059}
1060
1061static void mptspi_write_width(struct scsi_target *starget, int width)
1062{
1063 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1064 u32 nego;
1065
1066 if (!width) {
1067 spi_dt(starget) = 0;
1068 if (spi_period(starget) < 10)
1069 spi_period(starget) = 10;
1070 }
1071
1072 spi_width(starget) = width;
1073
1074 nego = mptspi_getRP(starget);
1075
1076 pg1.RequestedParameters = cpu_to_le32(nego);
1077 pg1.Reserved = 0;
1078 pg1.Configuration = 0;
1079
1080 mptspi_write_spi_device_pg1(starget, &pg1);
1081}
1082
1083struct work_queue_wrapper {
1084 struct work_struct work;
1085 struct _MPT_SCSI_HOST *hd;
1086 int disk;
1087};
1088
1089static void mpt_work_wrapper(struct work_struct *work)
1090{
1091 struct work_queue_wrapper *wqw =
1092 container_of(work, struct work_queue_wrapper, work);
1093 struct _MPT_SCSI_HOST *hd = wqw->hd;
1094 MPT_ADAPTER *ioc = hd->ioc;
1095 struct Scsi_Host *shost = ioc->sh;
1096 struct scsi_device *sdev;
1097 int disk = wqw->disk;
1098 struct _CONFIG_PAGE_IOC_3 *pg3;
1099
1100 kfree(wqw);
1101
1102 mpt_findImVolumes(ioc);
1103 pg3 = ioc->raid_data.pIocPg3;
1104 if (!pg3)
1105 return;
1106
1107 shost_for_each_device(sdev,shost) {
1108 struct scsi_target *starget = scsi_target(sdev);
1109 VirtTarget *vtarget = starget->hostdata;
1110
1111
1112 if (sdev->channel != 1)
1113 continue;
1114
1115
1116
1117 if(vtarget->id != disk)
1118 continue;
1119
1120 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1121 "Integrated RAID requests DV of new device\n", ioc->name);
1122 mptspi_dv_device(hd, sdev);
1123 }
1124 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1125 "Integrated RAID detects new device %d\n", ioc->name, disk);
1126 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1127}
1128
1129
1130static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1131{
1132 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1133 MPT_ADAPTER *ioc = hd->ioc;
1134
1135 if (!wqw) {
1136 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1137 "Failed to act on RAID event for physical disk %d\n",
1138 ioc->name, disk);
1139 return;
1140 }
1141 INIT_WORK(&wqw->work, mpt_work_wrapper);
1142 wqw->hd = hd;
1143 wqw->disk = disk;
1144
1145 schedule_work(&wqw->work);
1146}
1147
1148static int
1149mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1150{
1151 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1152 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1153
1154 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1155 int reason
1156 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1157
1158 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1159 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1160 mpt_dv_raid(hd, disk);
1161 }
1162 }
1163 return mptscsih_event_process(ioc, pEvReply);
1164}
1165
1166static int
1167mptspi_deny_binding(struct scsi_target *starget)
1168{
1169 struct _MPT_SCSI_HOST *hd =
1170 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1171 return ((mptspi_is_raid(hd, starget->id)) &&
1172 starget->channel == 0) ? 1 : 0;
1173}
1174
1175static struct spi_function_template mptspi_transport_functions = {
1176 .get_offset = mptspi_read_parameters,
1177 .set_offset = mptspi_write_offset,
1178 .show_offset = 1,
1179 .get_period = mptspi_read_parameters,
1180 .set_period = mptspi_write_period,
1181 .show_period = 1,
1182 .get_width = mptspi_read_parameters,
1183 .set_width = mptspi_write_width,
1184 .show_width = 1,
1185 .get_iu = mptspi_read_parameters,
1186 .set_iu = mptspi_write_iu,
1187 .show_iu = 1,
1188 .get_dt = mptspi_read_parameters,
1189 .set_dt = mptspi_write_dt,
1190 .show_dt = 1,
1191 .get_qas = mptspi_read_parameters,
1192 .set_qas = mptspi_write_qas,
1193 .show_qas = 1,
1194 .get_wr_flow = mptspi_read_parameters,
1195 .set_wr_flow = mptspi_write_wr_flow,
1196 .show_wr_flow = 1,
1197 .get_rd_strm = mptspi_read_parameters,
1198 .set_rd_strm = mptspi_write_rd_strm,
1199 .show_rd_strm = 1,
1200 .get_rti = mptspi_read_parameters,
1201 .set_rti = mptspi_write_rti,
1202 .show_rti = 1,
1203 .get_pcomp_en = mptspi_read_parameters,
1204 .set_pcomp_en = mptspi_write_pcomp_en,
1205 .show_pcomp_en = 1,
1206 .get_hold_mcs = mptspi_read_parameters,
1207 .set_hold_mcs = mptspi_write_hold_mcs,
1208 .show_hold_mcs = 1,
1209 .deny_binding = mptspi_deny_binding,
1210};
1211
1212
1213
1214
1215
1216static struct pci_device_id mptspi_pci_table[] = {
1217 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1218 PCI_ANY_ID, PCI_ANY_ID },
1219 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1220 PCI_ANY_ID, PCI_ANY_ID },
1221 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1222 PCI_ANY_ID, PCI_ANY_ID },
1223 {0}
1224};
1225MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1226
1227
1228
1229
1230
1231static void
1232mptspi_dv_renegotiate_work(struct work_struct *work)
1233{
1234 struct work_queue_wrapper *wqw =
1235 container_of(work, struct work_queue_wrapper, work);
1236 struct _MPT_SCSI_HOST *hd = wqw->hd;
1237 struct scsi_device *sdev;
1238 struct scsi_target *starget;
1239 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1240 u32 nego;
1241 MPT_ADAPTER *ioc = hd->ioc;
1242
1243 kfree(wqw);
1244
1245 if (hd->spi_pending) {
1246 shost_for_each_device(sdev, ioc->sh) {
1247 if (hd->spi_pending & (1 << sdev->id))
1248 continue;
1249 starget = scsi_target(sdev);
1250 nego = mptspi_getRP(starget);
1251 pg1.RequestedParameters = cpu_to_le32(nego);
1252 pg1.Reserved = 0;
1253 pg1.Configuration = 0;
1254 mptspi_write_spi_device_pg1(starget, &pg1);
1255 }
1256 } else {
1257 shost_for_each_device(sdev, ioc->sh)
1258 mptspi_dv_device(hd, sdev);
1259 }
1260}
1261
1262static void
1263mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1264{
1265 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1266
1267 if (!wqw)
1268 return;
1269
1270 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1271 wqw->hd = hd;
1272
1273 schedule_work(&wqw->work);
1274}
1275
1276
1277
1278
1279static int
1280mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1281{
1282 int rc;
1283
1284 rc = mptscsih_ioc_reset(ioc, reset_phase);
1285
1286
1287
1288 if (reset_phase == MPT_IOC_POST_RESET &&
1289 ioc->sh) {
1290 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1291
1292 mptspi_dv_renegotiate(hd);
1293 }
1294
1295 return rc;
1296}
1297
1298#ifdef CONFIG_PM
1299
1300
1301
1302static int
1303mptspi_resume(struct pci_dev *pdev)
1304{
1305 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1306 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1307 int rc;
1308
1309 rc = mptscsih_resume(pdev);
1310 mptspi_dv_renegotiate(hd);
1311
1312 return rc;
1313}
1314#endif
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325static int
1326mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1327{
1328 struct Scsi_Host *sh;
1329 MPT_SCSI_HOST *hd;
1330 MPT_ADAPTER *ioc;
1331 unsigned long flags;
1332 int ii;
1333 int numSGE = 0;
1334 int scale;
1335 int ioc_cap;
1336 int error=0;
1337 int r;
1338
1339 if ((r = mpt_attach(pdev,id)) != 0)
1340 return r;
1341
1342 ioc = pci_get_drvdata(pdev);
1343 ioc->DoneCtx = mptspiDoneCtx;
1344 ioc->TaskCtx = mptspiTaskCtx;
1345 ioc->InternalCtx = mptspiInternalCtx;
1346
1347
1348
1349 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1350 printk(MYIOC_s_WARN_FMT
1351 "Skipping because it's not operational!\n",
1352 ioc->name);
1353 error = -ENODEV;
1354 goto out_mptspi_probe;
1355 }
1356
1357 if (!ioc->active) {
1358 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1359 ioc->name);
1360 error = -ENODEV;
1361 goto out_mptspi_probe;
1362 }
1363
1364
1365
1366 ioc_cap = 0;
1367 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1368 if (ioc->pfacts[ii].ProtocolFlags &
1369 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1370 ioc_cap ++;
1371 }
1372
1373 if (!ioc_cap) {
1374 printk(MYIOC_s_WARN_FMT
1375 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1376 ioc->name, ioc);
1377 return 0;
1378 }
1379
1380 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1381
1382 if (!sh) {
1383 printk(MYIOC_s_WARN_FMT
1384 "Unable to register controller with SCSI subsystem\n",
1385 ioc->name);
1386 error = -1;
1387 goto out_mptspi_probe;
1388 }
1389
1390 spin_lock_irqsave(&ioc->FreeQlock, flags);
1391
1392
1393
1394 ioc->sh = sh;
1395
1396 sh->io_port = 0;
1397 sh->n_io_port = 0;
1398 sh->irq = 0;
1399
1400
1401 sh->max_cmd_len = 16;
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413 sh->max_id = ioc->devices_per_bus;
1414
1415 sh->max_lun = MPT_LAST_LUN + 1;
1416
1417
1418
1419 if (ioc->ir_firmware)
1420 sh->max_channel = 1;
1421 else
1422 sh->max_channel = 0;
1423 sh->this_id = ioc->pfacts[0].PortSCSIID;
1424
1425
1426
1427 sh->unique_id = ioc->id;
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438 scale = ioc->req_sz/ioc->SGE_size;
1439 if (ioc->sg_addr_size == sizeof(u64)) {
1440 numSGE = (scale - 1) *
1441 (ioc->facts.MaxChainDepth-1) + scale +
1442 (ioc->req_sz - 60) / ioc->SGE_size;
1443 } else {
1444 numSGE = 1 + (scale - 1) *
1445 (ioc->facts.MaxChainDepth-1) + scale +
1446 (ioc->req_sz - 64) / ioc->SGE_size;
1447 }
1448
1449 if (numSGE < sh->sg_tablesize) {
1450
1451 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1452 "Resetting sg_tablesize to %d from %d\n",
1453 ioc->name, numSGE, sh->sg_tablesize));
1454 sh->sg_tablesize = numSGE;
1455 }
1456
1457 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1458
1459 hd = shost_priv(sh);
1460 hd->ioc = ioc;
1461
1462
1463
1464
1465 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1466 if (!ioc->ScsiLookup) {
1467 error = -ENOMEM;
1468 goto out_mptspi_probe;
1469 }
1470 spin_lock_init(&ioc->scsi_lookup_lock);
1471
1472 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1473 ioc->name, ioc->ScsiLookup));
1474
1475 ioc->spi_data.Saf_Te = mpt_saf_te;
1476 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1477 "saf_te %x\n",
1478 ioc->name,
1479 mpt_saf_te));
1480 ioc->spi_data.noQas = 0;
1481
1482 hd->last_queue_full = 0;
1483 hd->spi_pending = 0;
1484
1485
1486
1487 if (ioc->spi_data.sdp0length != 0)
1488 sh->transportt = mptspi_transport_template;
1489
1490 error = scsi_add_host (sh, &ioc->pcidev->dev);
1491 if(error) {
1492 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1493 "scsi_add_host failed\n", ioc->name));
1494 goto out_mptspi_probe;
1495 }
1496
1497
1498
1499
1500 if (ioc->spi_data.bus_reset)
1501 mptscsih_IssueTaskMgmt(hd,
1502 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1503 0, 0, 0, 0, 5);
1504
1505 scsi_scan_host(sh);
1506 return 0;
1507
1508out_mptspi_probe:
1509
1510 mptscsih_remove(pdev);
1511 return error;
1512}
1513
1514static struct pci_driver mptspi_driver = {
1515 .name = "mptspi",
1516 .id_table = mptspi_pci_table,
1517 .probe = mptspi_probe,
1518 .remove = __devexit_p(mptscsih_remove),
1519 .shutdown = mptscsih_shutdown,
1520#ifdef CONFIG_PM
1521 .suspend = mptscsih_suspend,
1522 .resume = mptspi_resume,
1523#endif
1524};
1525
1526
1527
1528
1529
1530
1531
1532static int __init
1533mptspi_init(void)
1534{
1535 int error;
1536
1537 show_mptmod_ver(my_NAME, my_VERSION);
1538
1539 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1540 if (!mptspi_transport_template)
1541 return -ENODEV;
1542
1543 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1544 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1545 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1546
1547 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1548 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1549
1550 error = pci_register_driver(&mptspi_driver);
1551 if (error)
1552 spi_release_transport(mptspi_transport_template);
1553
1554 return error;
1555}
1556
1557
1558
1559
1560
1561
1562static void __exit
1563mptspi_exit(void)
1564{
1565 pci_unregister_driver(&mptspi_driver);
1566
1567 mpt_reset_deregister(mptspiDoneCtx);
1568 mpt_event_deregister(mptspiDoneCtx);
1569
1570 mpt_deregister(mptspiInternalCtx);
1571 mpt_deregister(mptspiTaskCtx);
1572 mpt_deregister(mptspiDoneCtx);
1573 spi_release_transport(mptspi_transport_template);
1574}
1575
1576module_init(mptspi_init);
1577module_exit(mptspi_exit);
1578
