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