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>
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 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 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 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 const 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 .dma_alignment = 511,
847 .shost_groups = mptscsih_host_attr_groups,
848};
849
850static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
851 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
852{
853 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
854 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
855 struct _MPT_ADAPTER *ioc = hd->ioc;
856 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
857 dma_addr_t pg1_dma;
858 int size;
859 struct _x_config_parms cfg;
860 struct _CONFIG_PAGE_HEADER hdr;
861 int err = -EBUSY;
862 u32 nego_parms;
863 u32 period;
864 struct scsi_device *sdev;
865 int i;
866
867 /* don't allow updating nego parameters on RAID devices */
868 if (starget->channel == 0 &&
869 mptspi_is_raid(hd, starget->id))
870 return -1;
871
872 size = ioc->spi_data.sdp1length * 4;
873
874 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
875 if (pg1 == NULL) {
876 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
877 "dma_alloc_coherent for parameters failed\n", ioc->name);
878 return -EINVAL;
879 }
880
881 memset(&hdr, 0, sizeof(hdr));
882
883 hdr.PageVersion = ioc->spi_data.sdp1version;
884 hdr.PageLength = ioc->spi_data.sdp1length;
885 hdr.PageNumber = 1;
886 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
887
888 memset(&cfg, 0, sizeof(cfg));
889
890 cfg.cfghdr.hdr = &hdr;
891 cfg.physAddr = pg1_dma;
892 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
893 cfg.dir = 1;
894 cfg.pageAddr = starget->id;
895
896 memcpy(pg1, pass_pg1, size);
897
898 pg1->Header.PageVersion = hdr.PageVersion;
899 pg1->Header.PageLength = hdr.PageLength;
900 pg1->Header.PageNumber = hdr.PageNumber;
901 pg1->Header.PageType = hdr.PageType;
902
903 nego_parms = le32_to_cpu(pg1->RequestedParameters);
904 period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
905 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
906 if (period == 8) {
907 /* Turn on inline data padding for TAPE when running U320 */
908 for (i = 0 ; i < 16; i++) {
909 sdev = scsi_device_lookup_by_target(starget, i);
910 if (sdev && sdev->type == TYPE_TAPE) {
911 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
912 "IDP:ON\n", ioc->name);
913 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
914 pg1->RequestedParameters =
915 cpu_to_le32(nego_parms);
916 break;
917 }
918 }
919 }
920
921 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
922
923 if (mpt_config(ioc, &cfg)) {
924 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
925 "mpt_config failed\n", ioc->name);
926 goto out_free;
927 }
928 err = 0;
929
930 out_free:
931 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
932 return err;
933}
934
935static void mptspi_write_offset(struct scsi_target *starget, int offset)
936{
937 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
938 u32 nego;
939
940 if (offset < 0)
941 offset = 0;
942
943 if (offset > 255)
944 offset = 255;
945
946 if (spi_offset(starget) == -1)
947 mptspi_read_parameters(starget);
948
949 spi_offset(starget) = offset;
950
951 nego = mptspi_getRP(starget);
952
953 pg1.RequestedParameters = cpu_to_le32(nego);
954 pg1.Reserved = 0;
955 pg1.Configuration = 0;
956
957 mptspi_write_spi_device_pg1(starget, &pg1);
958}
959
960static void mptspi_write_period(struct scsi_target *starget, int period)
961{
962 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
963 u32 nego;
964
965 if (period < 8)
966 period = 8;
967
968 if (period > 255)
969 period = 255;
970
971 if (spi_period(starget) == -1)
972 mptspi_read_parameters(starget);
973
974 if (period == 8) {
975 spi_iu(starget) = 1;
976 spi_dt(starget) = 1;
977 } else if (period == 9) {
978 spi_dt(starget) = 1;
979 }
980
981 spi_period(starget) = period;
982
983 nego = mptspi_getRP(starget);
984
985 pg1.RequestedParameters = cpu_to_le32(nego);
986 pg1.Reserved = 0;
987 pg1.Configuration = 0;
988
989 mptspi_write_spi_device_pg1(starget, &pg1);
990}
991
992static void mptspi_write_dt(struct scsi_target *starget, int dt)
993{
994 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
995 u32 nego;
996
997 if (spi_period(starget) == -1)
998 mptspi_read_parameters(starget);
999
1000 if (!dt && spi_period(starget) < 10)
1001 spi_period(starget) = 10;
1002
1003 spi_dt(starget) = dt;
1004
1005 nego = mptspi_getRP(starget);
1006
1007
1008 pg1.RequestedParameters = cpu_to_le32(nego);
1009 pg1.Reserved = 0;
1010 pg1.Configuration = 0;
1011
1012 mptspi_write_spi_device_pg1(starget, &pg1);
1013}
1014
1015static void mptspi_write_iu(struct scsi_target *starget, int iu)
1016{
1017 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1018 u32 nego;
1019
1020 if (spi_period(starget) == -1)
1021 mptspi_read_parameters(starget);
1022
1023 if (!iu && spi_period(starget) < 9)
1024 spi_period(starget) = 9;
1025
1026 spi_iu(starget) = iu;
1027
1028 nego = mptspi_getRP(starget);
1029
1030 pg1.RequestedParameters = cpu_to_le32(nego);
1031 pg1.Reserved = 0;
1032 pg1.Configuration = 0;
1033
1034 mptspi_write_spi_device_pg1(starget, &pg1);
1035}
1036
1037#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1038static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1039{ \
1040 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1041 u32 nego; \
1042 \
1043 spi_##parm(starget) = parm; \
1044 \
1045 nego = mptspi_getRP(starget); \
1046 \
1047 pg1.RequestedParameters = cpu_to_le32(nego); \
1048 pg1.Reserved = 0; \
1049 pg1.Configuration = 0; \
1050 \
1051 mptspi_write_spi_device_pg1(starget, &pg1); \
1052}
1053
1054MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1055MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1056MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1057MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1058MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1059
1060static void mptspi_write_qas(struct scsi_target *starget, int qas)
1061{
1062 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1063 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1064 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1065 VirtTarget *vtarget = starget->hostdata;
1066 u32 nego;
1067
1068 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1069 hd->ioc->spi_data.noQas)
1070 spi_qas(starget) = 0;
1071 else
1072 spi_qas(starget) = qas;
1073
1074 nego = mptspi_getRP(starget);
1075
1076 pg1.RequestedParameters = cpu_to_le32(nego);
1077 pg1.Reserved = 0;
1078 pg1.Configuration = 0;
1079
1080 mptspi_write_spi_device_pg1(starget, &pg1);
1081}
1082
1083static void mptspi_write_width(struct scsi_target *starget, int width)
1084{
1085 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1086 u32 nego;
1087
1088 if (!width) {
1089 spi_dt(starget) = 0;
1090 if (spi_period(starget) < 10)
1091 spi_period(starget) = 10;
1092 }
1093
1094 spi_width(starget) = width;
1095
1096 nego = mptspi_getRP(starget);
1097
1098 pg1.RequestedParameters = cpu_to_le32(nego);
1099 pg1.Reserved = 0;
1100 pg1.Configuration = 0;
1101
1102 mptspi_write_spi_device_pg1(starget, &pg1);
1103}
1104
1105struct work_queue_wrapper {
1106 struct work_struct work;
1107 struct _MPT_SCSI_HOST *hd;
1108 int disk;
1109};
1110
1111static void mpt_work_wrapper(struct work_struct *work)
1112{
1113 struct work_queue_wrapper *wqw =
1114 container_of(work, struct work_queue_wrapper, work);
1115 struct _MPT_SCSI_HOST *hd = wqw->hd;
1116 MPT_ADAPTER *ioc = hd->ioc;
1117 struct Scsi_Host *shost = ioc->sh;
1118 struct scsi_device *sdev;
1119 int disk = wqw->disk;
1120 struct _CONFIG_PAGE_IOC_3 *pg3;
1121
1122 kfree(wqw);
1123
1124 mpt_findImVolumes(ioc);
1125 pg3 = ioc->raid_data.pIocPg3;
1126 if (!pg3)
1127 return;
1128
1129 shost_for_each_device(sdev,shost) {
1130 struct scsi_target *starget = scsi_target(sdev);
1131 VirtTarget *vtarget = starget->hostdata;
1132
1133 /* only want to search RAID components */
1134 if (sdev->channel != 1)
1135 continue;
1136
1137 /* The id is the raid PhysDiskNum, even if
1138 * starget->id is the actual target address */
1139 if(vtarget->id != disk)
1140 continue;
1141
1142 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1143 "Integrated RAID requests DV of new device\n", ioc->name);
1144 mptspi_dv_device(hd, sdev);
1145 }
1146 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1147 "Integrated RAID detects new device %d\n", ioc->name, disk);
1148 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN);
1149}
1150
1151
1152static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1153{
1154 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1155 MPT_ADAPTER *ioc = hd->ioc;
1156
1157 if (!wqw) {
1158 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1159 "Failed to act on RAID event for physical disk %d\n",
1160 ioc->name, disk);
1161 return;
1162 }
1163 INIT_WORK(&wqw->work, mpt_work_wrapper);
1164 wqw->hd = hd;
1165 wqw->disk = disk;
1166
1167 schedule_work(&wqw->work);
1168}
1169
1170static int
1171mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1172{
1173 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1174 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1175
1176 if (ioc->bus_type != SPI)
1177 return 0;
1178
1179 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1180 int reason
1181 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1182
1183 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1184 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1185 mpt_dv_raid(hd, disk);
1186 }
1187 }
1188 return mptscsih_event_process(ioc, pEvReply);
1189}
1190
1191static int
1192mptspi_deny_binding(struct scsi_target *starget)
1193{
1194 struct _MPT_SCSI_HOST *hd =
1195 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1196 return ((mptspi_is_raid(hd, starget->id)) &&
1197 starget->channel == 0) ? 1 : 0;
1198}
1199
1200static struct spi_function_template mptspi_transport_functions = {
1201 .get_offset = mptspi_read_parameters,
1202 .set_offset = mptspi_write_offset,
1203 .show_offset = 1,
1204 .get_period = mptspi_read_parameters,
1205 .set_period = mptspi_write_period,
1206 .show_period = 1,
1207 .get_width = mptspi_read_parameters,
1208 .set_width = mptspi_write_width,
1209 .show_width = 1,
1210 .get_iu = mptspi_read_parameters,
1211 .set_iu = mptspi_write_iu,
1212 .show_iu = 1,
1213 .get_dt = mptspi_read_parameters,
1214 .set_dt = mptspi_write_dt,
1215 .show_dt = 1,
1216 .get_qas = mptspi_read_parameters,
1217 .set_qas = mptspi_write_qas,
1218 .show_qas = 1,
1219 .get_wr_flow = mptspi_read_parameters,
1220 .set_wr_flow = mptspi_write_wr_flow,
1221 .show_wr_flow = 1,
1222 .get_rd_strm = mptspi_read_parameters,
1223 .set_rd_strm = mptspi_write_rd_strm,
1224 .show_rd_strm = 1,
1225 .get_rti = mptspi_read_parameters,
1226 .set_rti = mptspi_write_rti,
1227 .show_rti = 1,
1228 .get_pcomp_en = mptspi_read_parameters,
1229 .set_pcomp_en = mptspi_write_pcomp_en,
1230 .show_pcomp_en = 1,
1231 .get_hold_mcs = mptspi_read_parameters,
1232 .set_hold_mcs = mptspi_write_hold_mcs,
1233 .show_hold_mcs = 1,
1234 .deny_binding = mptspi_deny_binding,
1235};
1236
1237/****************************************************************************
1238 * Supported hardware
1239 */
1240
1241static const struct pci_device_id mptspi_pci_table[] = {
1242 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1243 PCI_ANY_ID, PCI_ANY_ID },
1244 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1245 PCI_ANY_ID, PCI_ANY_ID },
1246 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1247 PCI_ANY_ID, PCI_ANY_ID },
1248 {0} /* Terminating entry */
1249};
1250MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1251
1252
1253/*
1254 * renegotiate for a given target
1255 */
1256static void
1257mptspi_dv_renegotiate_work(struct work_struct *work)
1258{
1259 struct work_queue_wrapper *wqw =
1260 container_of(work, struct work_queue_wrapper, work);
1261 struct _MPT_SCSI_HOST *hd = wqw->hd;
1262 struct scsi_device *sdev;
1263 struct scsi_target *starget;
1264 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1265 u32 nego;
1266 MPT_ADAPTER *ioc = hd->ioc;
1267
1268 kfree(wqw);
1269
1270 if (hd->spi_pending) {
1271 shost_for_each_device(sdev, ioc->sh) {
1272 if (hd->spi_pending & (1 << sdev->id))
1273 continue;
1274 starget = scsi_target(sdev);
1275 nego = mptspi_getRP(starget);
1276 pg1.RequestedParameters = cpu_to_le32(nego);
1277 pg1.Reserved = 0;
1278 pg1.Configuration = 0;
1279 mptspi_write_spi_device_pg1(starget, &pg1);
1280 }
1281 } else {
1282 shost_for_each_device(sdev, ioc->sh)
1283 mptspi_dv_device(hd, sdev);
1284 }
1285}
1286
1287static void
1288mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1289{
1290 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1291
1292 if (!wqw)
1293 return;
1294
1295 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1296 wqw->hd = hd;
1297
1298 schedule_work(&wqw->work);
1299}
1300
1301/*
1302 * spi module reset handler
1303 */
1304static int
1305mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1306{
1307 int rc;
1308
1309 rc = mptscsih_ioc_reset(ioc, reset_phase);
1310 if ((ioc->bus_type != SPI) || (!rc))
1311 return rc;
1312
1313 /* only try to do a renegotiation if we're properly set up
1314 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1315 if (reset_phase == MPT_IOC_POST_RESET &&
1316 ioc->sh) {
1317 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1318
1319 mptspi_dv_renegotiate(hd);
1320 }
1321
1322 return rc;
1323}
1324
1325#ifdef CONFIG_PM
1326/*
1327 * spi module resume handler
1328 */
1329static int
1330mptspi_resume(struct pci_dev *pdev)
1331{
1332 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1333 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1334 int rc;
1335
1336 rc = mptscsih_resume(pdev);
1337 mptspi_dv_renegotiate(hd);
1338
1339 return rc;
1340}
1341#endif
1342
1343/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1344/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1345/*
1346 * mptspi_probe - Installs scsi devices per bus.
1347 * @pdev: Pointer to pci_dev structure
1348 *
1349 * Returns 0 for success, non-zero for failure.
1350 *
1351 */
1352static int
1353mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1354{
1355 struct Scsi_Host *sh;
1356 MPT_SCSI_HOST *hd;
1357 MPT_ADAPTER *ioc;
1358 unsigned long flags;
1359 int ii;
1360 int numSGE = 0;
1361 int scale;
1362 int ioc_cap;
1363 int error=0;
1364 int r;
1365
1366 if ((r = mpt_attach(pdev,id)) != 0)
1367 return r;
1368
1369 ioc = pci_get_drvdata(pdev);
1370 ioc->DoneCtx = mptspiDoneCtx;
1371 ioc->TaskCtx = mptspiTaskCtx;
1372 ioc->InternalCtx = mptspiInternalCtx;
1373
1374 /* Added sanity check on readiness of the MPT adapter.
1375 */
1376 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1377 printk(MYIOC_s_WARN_FMT
1378 "Skipping because it's not operational!\n",
1379 ioc->name);
1380 error = -ENODEV;
1381 goto out_mptspi_probe;
1382 }
1383
1384 if (!ioc->active) {
1385 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1386 ioc->name);
1387 error = -ENODEV;
1388 goto out_mptspi_probe;
1389 }
1390
1391 /* Sanity check - ensure at least 1 port is INITIATOR capable
1392 */
1393 ioc_cap = 0;
1394 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1395 if (ioc->pfacts[ii].ProtocolFlags &
1396 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1397 ioc_cap ++;
1398 }
1399
1400 if (!ioc_cap) {
1401 printk(MYIOC_s_WARN_FMT
1402 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1403 ioc->name, ioc);
1404 return 0;
1405 }
1406
1407 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1408
1409 if (!sh) {
1410 printk(MYIOC_s_WARN_FMT
1411 "Unable to register controller with SCSI subsystem\n",
1412 ioc->name);
1413 error = -1;
1414 goto out_mptspi_probe;
1415 }
1416
1417 /* VMWare emulation doesn't properly implement WRITE_SAME
1418 */
1419 if (pdev->subsystem_vendor == 0x15AD)
1420 sh->no_write_same = 1;
1421
1422 spin_lock_irqsave(&ioc->FreeQlock, flags);
1423
1424 /* Attach the SCSI Host to the IOC structure
1425 */
1426 ioc->sh = sh;
1427
1428 sh->io_port = 0;
1429 sh->n_io_port = 0;
1430 sh->irq = 0;
1431
1432 /* set 16 byte cdb's */
1433 sh->max_cmd_len = 16;
1434
1435 /* Yikes! This is important!
1436 * Otherwise, by default, linux
1437 * only scans target IDs 0-7!
1438 * pfactsN->MaxDevices unreliable
1439 * (not supported in early
1440 * versions of the FW).
1441 * max_id = 1 + actual max id,
1442 * max_lun = 1 + actual last lun,
1443 * see hosts.h :o(
1444 */
1445 sh->max_id = ioc->devices_per_bus;
1446
1447 sh->max_lun = MPT_LAST_LUN + 1;
1448 /*
1449 * If RAID Firmware Detected, setup virtual channel
1450 */
1451 if (ioc->ir_firmware)
1452 sh->max_channel = 1;
1453 else
1454 sh->max_channel = 0;
1455 sh->this_id = ioc->pfacts[0].PortSCSIID;
1456
1457 /* Required entry.
1458 */
1459 sh->unique_id = ioc->id;
1460
1461 /* Verify that we won't exceed the maximum
1462 * number of chain buffers
1463 * We can optimize: ZZ = req_sz/sizeof(SGE)
1464 * For 32bit SGE's:
1465 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1466 * + (req_sz - 64)/sizeof(SGE)
1467 * A slightly different algorithm is required for
1468 * 64bit SGEs.
1469 */
1470 scale = ioc->req_sz/ioc->SGE_size;
1471 if (ioc->sg_addr_size == sizeof(u64)) {
1472 numSGE = (scale - 1) *
1473 (ioc->facts.MaxChainDepth-1) + scale +
1474 (ioc->req_sz - 60) / ioc->SGE_size;
1475 } else {
1476 numSGE = 1 + (scale - 1) *
1477 (ioc->facts.MaxChainDepth-1) + scale +
1478 (ioc->req_sz - 64) / ioc->SGE_size;
1479 }
1480
1481 if (numSGE < sh->sg_tablesize) {
1482 /* Reset this value */
1483 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1484 "Resetting sg_tablesize to %d from %d\n",
1485 ioc->name, numSGE, sh->sg_tablesize));
1486 sh->sg_tablesize = numSGE;
1487 }
1488
1489 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1490
1491 hd = shost_priv(sh);
1492 hd->ioc = ioc;
1493
1494 /* SCSI needs scsi_cmnd lookup table!
1495 * (with size equal to req_depth*PtrSz!)
1496 */
1497 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_KERNEL);
1498 if (!ioc->ScsiLookup) {
1499 error = -ENOMEM;
1500 goto out_mptspi_probe;
1501 }
1502 spin_lock_init(&ioc->scsi_lookup_lock);
1503
1504 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1505 ioc->name, ioc->ScsiLookup));
1506
1507 ioc->spi_data.Saf_Te = mpt_saf_te;
1508 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1509 "saf_te %x\n",
1510 ioc->name,
1511 mpt_saf_te));
1512 ioc->spi_data.noQas = 0;
1513
1514 hd->last_queue_full = 0;
1515 hd->spi_pending = 0;
1516
1517 /* Some versions of the firmware don't support page 0; without
1518 * that we can't get the parameters */
1519 if (ioc->spi_data.sdp0length != 0)
1520 sh->transportt = mptspi_transport_template;
1521
1522 error = scsi_add_host (sh, &ioc->pcidev->dev);
1523 if(error) {
1524 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1525 "scsi_add_host failed\n", ioc->name));
1526 goto out_mptspi_probe;
1527 }
1528
1529 /*
1530 * issue internal bus reset
1531 */
1532 if (ioc->spi_data.bus_reset)
1533 mptscsih_IssueTaskMgmt(hd,
1534 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1535 0, 0, 0, 0, 5);
1536
1537 scsi_scan_host(sh);
1538 return 0;
1539
1540out_mptspi_probe:
1541
1542 mptscsih_remove(pdev);
1543 return error;
1544}
1545
1546static void mptspi_remove(struct pci_dev *pdev)
1547{
1548 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1549
1550 scsi_remove_host(ioc->sh);
1551 mptscsih_remove(pdev);
1552}
1553
1554static struct pci_driver mptspi_driver = {
1555 .name = "mptspi",
1556 .id_table = mptspi_pci_table,
1557 .probe = mptspi_probe,
1558 .remove = mptspi_remove,
1559 .shutdown = mptscsih_shutdown,
1560#ifdef CONFIG_PM
1561 .suspend = mptscsih_suspend,
1562 .resume = mptspi_resume,
1563#endif
1564};
1565
1566/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1567/**
1568 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1569 *
1570 * Returns 0 for success, non-zero for failure.
1571 */
1572static int __init
1573mptspi_init(void)
1574{
1575 int error;
1576
1577 show_mptmod_ver(my_NAME, my_VERSION);
1578
1579 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1580 if (!mptspi_transport_template)
1581 return -ENODEV;
1582
1583 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1584 "mptscsih_io_done");
1585 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1586 "mptscsih_taskmgmt_complete");
1587 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1588 MPTSPI_DRIVER, "mptscsih_scandv_complete");
1589
1590 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1591 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1592
1593 error = pci_register_driver(&mptspi_driver);
1594 if (error)
1595 spi_release_transport(mptspi_transport_template);
1596
1597 return error;
1598}
1599
1600/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1601/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1602/**
1603 * mptspi_exit - Unregisters MPT adapter(s)
1604 */
1605static void __exit
1606mptspi_exit(void)
1607{
1608 pci_unregister_driver(&mptspi_driver);
1609
1610 mpt_reset_deregister(mptspiDoneCtx);
1611 mpt_event_deregister(mptspiDoneCtx);
1612
1613 mpt_deregister(mptspiInternalCtx);
1614 mpt_deregister(mptspiTaskCtx);
1615 mpt_deregister(mptspiDoneCtx);
1616 spi_release_transport(mptspi_transport_template);
1617}
1618
1619module_init(mptspi_init);
1620module_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 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 kfree(starget->hostdata);
465 starget->hostdata = NULL;
466}
467
468/**
469 * mptspi_print_write_nego - negotiation parameters debug info that is being sent
470 * @hd: Pointer to a SCSI HOST structure
471 * @starget: SCSI target
472 * @ii: negotiation parameters
473 *
474 */
475static void
476mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
477{
478 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
479 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
480 hd->ioc->name, starget->id, ii,
481 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
482 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
483 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
484 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
485 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
486 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
487 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
488 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
489 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
490 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
491}
492
493/**
494 * mptspi_print_read_nego - negotiation parameters debug info that is being read
495 * @hd: Pointer to a SCSI HOST structure
496 * @starget: SCSI target
497 * @ii: negotiation parameters
498 *
499 */
500static void
501mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
502{
503 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
504 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
505 hd->ioc->name, starget->id, ii,
506 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
507 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
508 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
509 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
510 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
511 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
512 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
513 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
514 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
515 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
516}
517
518static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
519 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
520{
521 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
522 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
523 struct _MPT_ADAPTER *ioc = hd->ioc;
524 struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
525 dma_addr_t spi_dev_pg0_dma;
526 int size;
527 struct _x_config_parms cfg;
528 struct _CONFIG_PAGE_HEADER hdr;
529 int err = -EBUSY;
530
531 /* No SPI parameters for RAID devices */
532 if (starget->channel == 0 &&
533 mptspi_is_raid(hd, starget->id))
534 return -1;
535
536 size = ioc->spi_data.sdp0length * 4;
537 /*
538 if (ioc->spi_data.sdp0length & 1)
539 size += size + 4;
540 size += 2048;
541 */
542
543 spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
544 if (spi_dev_pg0 == NULL) {
545 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
546 "dma_alloc_coherent for parameters failed\n", ioc->name);
547 return -EINVAL;
548 }
549
550 memset(&hdr, 0, sizeof(hdr));
551
552 hdr.PageVersion = ioc->spi_data.sdp0version;
553 hdr.PageLength = ioc->spi_data.sdp0length;
554 hdr.PageNumber = 0;
555 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
556
557 memset(&cfg, 0, sizeof(cfg));
558
559 cfg.cfghdr.hdr = &hdr;
560 cfg.physAddr = spi_dev_pg0_dma;
561 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
562 cfg.dir = 0;
563 cfg.pageAddr = starget->id;
564 cfg.timeout = 60;
565
566 if (mpt_config(ioc, &cfg)) {
567 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
568 goto out_free;
569 }
570 err = 0;
571 memcpy(pass_pg0, spi_dev_pg0, size);
572
573 mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
574
575 out_free:
576 dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
577 return err;
578}
579
580static u32 mptspi_getRP(struct scsi_target *starget)
581{
582 u32 nego = 0;
583
584 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
585 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
586 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
587 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
588 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
589 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
590 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
591 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
592
593 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
594 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
595 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
596
597 return nego;
598}
599
600static void mptspi_read_parameters(struct scsi_target *starget)
601{
602 int nego;
603 struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
604
605 mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
606
607 nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
608
609 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
610 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
611 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
612 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
613 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
614 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
615 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
616 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
617 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
618 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
619 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
620}
621
622static int
623mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
624{
625 MPT_ADAPTER *ioc = hd->ioc;
626 MpiRaidActionRequest_t *pReq;
627 MPT_FRAME_HDR *mf;
628 int ret;
629 unsigned long timeleft;
630
631 mutex_lock(&ioc->internal_cmds.mutex);
632
633 /* Get and Populate a free Frame
634 */
635 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
636 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
637 "%s: no msg frames!\n", ioc->name, __func__));
638 ret = -EAGAIN;
639 goto out;
640 }
641 pReq = (MpiRaidActionRequest_t *)mf;
642 if (quiesce)
643 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
644 else
645 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
646 pReq->Reserved1 = 0;
647 pReq->ChainOffset = 0;
648 pReq->Function = MPI_FUNCTION_RAID_ACTION;
649 pReq->VolumeID = id;
650 pReq->VolumeBus = channel;
651 pReq->PhysDiskNum = 0;
652 pReq->MsgFlags = 0;
653 pReq->Reserved2 = 0;
654 pReq->ActionDataWord = 0; /* Reserved for this action */
655
656 ioc->add_sge((char *)&pReq->ActionDataSGE,
657 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
658
659 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
660 ioc->name, pReq->Action, channel, id));
661
662 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
663 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
664 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
665 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
666 ret = -ETIME;
667 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
668 ioc->name, __func__));
669 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
670 goto out;
671 if (!timeleft) {
672 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
673 ioc->name, __func__);
674 mpt_HardResetHandler(ioc, CAN_SLEEP);
675 mpt_free_msg_frame(ioc, mf);
676 }
677 goto out;
678 }
679
680 ret = ioc->internal_cmds.completion_code;
681
682 out:
683 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
684 mutex_unlock(&ioc->internal_cmds.mutex);
685 return ret;
686}
687
688static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
689 struct scsi_device *sdev)
690{
691 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
692 MPT_ADAPTER *ioc = hd->ioc;
693
694 /* no DV on RAID devices */
695 if (sdev->channel == 0 &&
696 mptspi_is_raid(hd, sdev->id))
697 return;
698
699 /* If this is a piece of a RAID, then quiesce first */
700 if (sdev->channel == 1 &&
701 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
702 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
703 "Integrated RAID quiesce failed\n", ioc->name);
704 return;
705 }
706
707 hd->spi_pending |= (1 << sdev->id);
708 spi_dv_device(sdev);
709 hd->spi_pending &= ~(1 << sdev->id);
710
711 if (sdev->channel == 1 &&
712 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
713 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
714 "Integrated RAID resume failed\n", ioc->name);
715
716 mptspi_read_parameters(sdev->sdev_target);
717 spi_display_xfer_agreement(sdev->sdev_target);
718 mptspi_read_parameters(sdev->sdev_target);
719}
720
721static int mptspi_slave_alloc(struct scsi_device *sdev)
722{
723 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
724 VirtTarget *vtarget;
725 VirtDevice *vdevice;
726 struct scsi_target *starget;
727 MPT_ADAPTER *ioc = hd->ioc;
728
729 if (sdev->channel == 1 &&
730 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
731 return -ENXIO;
732
733 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
734 if (!vdevice) {
735 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
736 ioc->name, sizeof(VirtDevice));
737 return -ENOMEM;
738 }
739
740 vdevice->lun = sdev->lun;
741 sdev->hostdata = vdevice;
742
743 starget = scsi_target(sdev);
744 vtarget = starget->hostdata;
745 vdevice->vtarget = vtarget;
746 vtarget->num_luns++;
747
748 if (sdev->channel == 1)
749 sdev->no_uld_attach = 1;
750
751 return 0;
752}
753
754static int mptspi_slave_configure(struct scsi_device *sdev)
755{
756 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
757 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
758 int ret;
759
760 mptspi_initTarget(hd, vtarget, sdev);
761
762 ret = mptscsih_slave_configure(sdev);
763
764 if (ret)
765 return ret;
766
767 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
768 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
769 sdev->id, spi_min_period(scsi_target(sdev)),
770 spi_max_offset(scsi_target(sdev)),
771 spi_max_width(scsi_target(sdev))));
772
773 if ((sdev->channel == 1 ||
774 !(mptspi_is_raid(hd, sdev->id))) &&
775 !spi_initial_dv(sdev->sdev_target))
776 mptspi_dv_device(hd, sdev);
777
778 return 0;
779}
780
781static int
782mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
783{
784 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
785 VirtDevice *vdevice = SCpnt->device->hostdata;
786 MPT_ADAPTER *ioc = hd->ioc;
787
788 if (!vdevice || !vdevice->vtarget) {
789 SCpnt->result = DID_NO_CONNECT << 16;
790 SCpnt->scsi_done(SCpnt);
791 return 0;
792 }
793
794 if (SCpnt->device->channel == 1 &&
795 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
796 SCpnt->result = DID_NO_CONNECT << 16;
797 SCpnt->scsi_done(SCpnt);
798 return 0;
799 }
800
801 if (spi_dv_pending(scsi_target(SCpnt->device)))
802 ddvprintk(ioc, scsi_print_command(SCpnt));
803
804 return mptscsih_qcmd(SCpnt);
805}
806
807static void mptspi_slave_destroy(struct scsi_device *sdev)
808{
809 struct scsi_target *starget = scsi_target(sdev);
810 VirtTarget *vtarget = starget->hostdata;
811 VirtDevice *vdevice = sdev->hostdata;
812
813 /* Will this be the last lun on a non-raid device? */
814 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
815 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
816
817 /* Async Narrow */
818 pg1.RequestedParameters = 0;
819 pg1.Reserved = 0;
820 pg1.Configuration = 0;
821
822 mptspi_write_spi_device_pg1(starget, &pg1);
823 }
824
825 mptscsih_slave_destroy(sdev);
826}
827
828static struct scsi_host_template mptspi_driver_template = {
829 .module = THIS_MODULE,
830 .proc_name = "mptspi",
831 .show_info = mptscsih_show_info,
832 .name = "MPT SPI Host",
833 .info = mptscsih_info,
834 .queuecommand = mptspi_qcmd,
835 .target_alloc = mptspi_target_alloc,
836 .slave_alloc = mptspi_slave_alloc,
837 .slave_configure = mptspi_slave_configure,
838 .target_destroy = mptspi_target_destroy,
839 .slave_destroy = mptspi_slave_destroy,
840 .change_queue_depth = mptscsih_change_queue_depth,
841 .eh_abort_handler = mptscsih_abort,
842 .eh_device_reset_handler = mptscsih_dev_reset,
843 .eh_bus_reset_handler = mptscsih_bus_reset,
844 .eh_host_reset_handler = mptscsih_host_reset,
845 .bios_param = mptscsih_bios_param,
846 .can_queue = MPT_SCSI_CAN_QUEUE,
847 .this_id = -1,
848 .sg_tablesize = MPT_SCSI_SG_DEPTH,
849 .max_sectors = 8192,
850 .cmd_per_lun = 7,
851 .use_clustering = ENABLE_CLUSTERING,
852 .shost_attrs = mptscsih_host_attrs,
853};
854
855static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
856 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
857{
858 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
859 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
860 struct _MPT_ADAPTER *ioc = hd->ioc;
861 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
862 dma_addr_t pg1_dma;
863 int size;
864 struct _x_config_parms cfg;
865 struct _CONFIG_PAGE_HEADER hdr;
866 int err = -EBUSY;
867 u32 nego_parms;
868 u32 period;
869 struct scsi_device *sdev;
870 int i;
871
872 /* don't allow updating nego parameters on RAID devices */
873 if (starget->channel == 0 &&
874 mptspi_is_raid(hd, starget->id))
875 return -1;
876
877 size = ioc->spi_data.sdp1length * 4;
878
879 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
880 if (pg1 == NULL) {
881 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
882 "dma_alloc_coherent for parameters failed\n", ioc->name);
883 return -EINVAL;
884 }
885
886 memset(&hdr, 0, sizeof(hdr));
887
888 hdr.PageVersion = ioc->spi_data.sdp1version;
889 hdr.PageLength = ioc->spi_data.sdp1length;
890 hdr.PageNumber = 1;
891 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
892
893 memset(&cfg, 0, sizeof(cfg));
894
895 cfg.cfghdr.hdr = &hdr;
896 cfg.physAddr = pg1_dma;
897 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
898 cfg.dir = 1;
899 cfg.pageAddr = starget->id;
900
901 memcpy(pg1, pass_pg1, size);
902
903 pg1->Header.PageVersion = hdr.PageVersion;
904 pg1->Header.PageLength = hdr.PageLength;
905 pg1->Header.PageNumber = hdr.PageNumber;
906 pg1->Header.PageType = hdr.PageType;
907
908 nego_parms = le32_to_cpu(pg1->RequestedParameters);
909 period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
910 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
911 if (period == 8) {
912 /* Turn on inline data padding for TAPE when running U320 */
913 for (i = 0 ; i < 16; i++) {
914 sdev = scsi_device_lookup_by_target(starget, i);
915 if (sdev && sdev->type == TYPE_TAPE) {
916 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
917 "IDP:ON\n", ioc->name);
918 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
919 pg1->RequestedParameters =
920 cpu_to_le32(nego_parms);
921 break;
922 }
923 }
924 }
925
926 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
927
928 if (mpt_config(ioc, &cfg)) {
929 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
930 "mpt_config failed\n", ioc->name);
931 goto out_free;
932 }
933 err = 0;
934
935 out_free:
936 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
937 return err;
938}
939
940static void mptspi_write_offset(struct scsi_target *starget, int offset)
941{
942 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
943 u32 nego;
944
945 if (offset < 0)
946 offset = 0;
947
948 if (offset > 255)
949 offset = 255;
950
951 if (spi_offset(starget) == -1)
952 mptspi_read_parameters(starget);
953
954 spi_offset(starget) = offset;
955
956 nego = mptspi_getRP(starget);
957
958 pg1.RequestedParameters = cpu_to_le32(nego);
959 pg1.Reserved = 0;
960 pg1.Configuration = 0;
961
962 mptspi_write_spi_device_pg1(starget, &pg1);
963}
964
965static void mptspi_write_period(struct scsi_target *starget, int period)
966{
967 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
968 u32 nego;
969
970 if (period < 8)
971 period = 8;
972
973 if (period > 255)
974 period = 255;
975
976 if (spi_period(starget) == -1)
977 mptspi_read_parameters(starget);
978
979 if (period == 8) {
980 spi_iu(starget) = 1;
981 spi_dt(starget) = 1;
982 } else if (period == 9) {
983 spi_dt(starget) = 1;
984 }
985
986 spi_period(starget) = period;
987
988 nego = mptspi_getRP(starget);
989
990 pg1.RequestedParameters = cpu_to_le32(nego);
991 pg1.Reserved = 0;
992 pg1.Configuration = 0;
993
994 mptspi_write_spi_device_pg1(starget, &pg1);
995}
996
997static void mptspi_write_dt(struct scsi_target *starget, int dt)
998{
999 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1000 u32 nego;
1001
1002 if (spi_period(starget) == -1)
1003 mptspi_read_parameters(starget);
1004
1005 if (!dt && spi_period(starget) < 10)
1006 spi_period(starget) = 10;
1007
1008 spi_dt(starget) = dt;
1009
1010 nego = mptspi_getRP(starget);
1011
1012
1013 pg1.RequestedParameters = cpu_to_le32(nego);
1014 pg1.Reserved = 0;
1015 pg1.Configuration = 0;
1016
1017 mptspi_write_spi_device_pg1(starget, &pg1);
1018}
1019
1020static void mptspi_write_iu(struct scsi_target *starget, int iu)
1021{
1022 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1023 u32 nego;
1024
1025 if (spi_period(starget) == -1)
1026 mptspi_read_parameters(starget);
1027
1028 if (!iu && spi_period(starget) < 9)
1029 spi_period(starget) = 9;
1030
1031 spi_iu(starget) = iu;
1032
1033 nego = mptspi_getRP(starget);
1034
1035 pg1.RequestedParameters = cpu_to_le32(nego);
1036 pg1.Reserved = 0;
1037 pg1.Configuration = 0;
1038
1039 mptspi_write_spi_device_pg1(starget, &pg1);
1040}
1041
1042#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1043static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1044{ \
1045 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1046 u32 nego; \
1047 \
1048 spi_##parm(starget) = parm; \
1049 \
1050 nego = mptspi_getRP(starget); \
1051 \
1052 pg1.RequestedParameters = cpu_to_le32(nego); \
1053 pg1.Reserved = 0; \
1054 pg1.Configuration = 0; \
1055 \
1056 mptspi_write_spi_device_pg1(starget, &pg1); \
1057}
1058
1059MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1060MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1061MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1062MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1063MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1064
1065static void mptspi_write_qas(struct scsi_target *starget, int qas)
1066{
1067 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1068 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1069 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1070 VirtTarget *vtarget = starget->hostdata;
1071 u32 nego;
1072
1073 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1074 hd->ioc->spi_data.noQas)
1075 spi_qas(starget) = 0;
1076 else
1077 spi_qas(starget) = qas;
1078
1079 nego = mptspi_getRP(starget);
1080
1081 pg1.RequestedParameters = cpu_to_le32(nego);
1082 pg1.Reserved = 0;
1083 pg1.Configuration = 0;
1084
1085 mptspi_write_spi_device_pg1(starget, &pg1);
1086}
1087
1088static void mptspi_write_width(struct scsi_target *starget, int width)
1089{
1090 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1091 u32 nego;
1092
1093 if (!width) {
1094 spi_dt(starget) = 0;
1095 if (spi_period(starget) < 10)
1096 spi_period(starget) = 10;
1097 }
1098
1099 spi_width(starget) = width;
1100
1101 nego = mptspi_getRP(starget);
1102
1103 pg1.RequestedParameters = cpu_to_le32(nego);
1104 pg1.Reserved = 0;
1105 pg1.Configuration = 0;
1106
1107 mptspi_write_spi_device_pg1(starget, &pg1);
1108}
1109
1110struct work_queue_wrapper {
1111 struct work_struct work;
1112 struct _MPT_SCSI_HOST *hd;
1113 int disk;
1114};
1115
1116static void mpt_work_wrapper(struct work_struct *work)
1117{
1118 struct work_queue_wrapper *wqw =
1119 container_of(work, struct work_queue_wrapper, work);
1120 struct _MPT_SCSI_HOST *hd = wqw->hd;
1121 MPT_ADAPTER *ioc = hd->ioc;
1122 struct Scsi_Host *shost = ioc->sh;
1123 struct scsi_device *sdev;
1124 int disk = wqw->disk;
1125 struct _CONFIG_PAGE_IOC_3 *pg3;
1126
1127 kfree(wqw);
1128
1129 mpt_findImVolumes(ioc);
1130 pg3 = ioc->raid_data.pIocPg3;
1131 if (!pg3)
1132 return;
1133
1134 shost_for_each_device(sdev,shost) {
1135 struct scsi_target *starget = scsi_target(sdev);
1136 VirtTarget *vtarget = starget->hostdata;
1137
1138 /* only want to search RAID components */
1139 if (sdev->channel != 1)
1140 continue;
1141
1142 /* The id is the raid PhysDiskNum, even if
1143 * starget->id is the actual target address */
1144 if(vtarget->id != disk)
1145 continue;
1146
1147 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1148 "Integrated RAID requests DV of new device\n", ioc->name);
1149 mptspi_dv_device(hd, sdev);
1150 }
1151 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1152 "Integrated RAID detects new device %d\n", ioc->name, disk);
1153 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1154}
1155
1156
1157static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1158{
1159 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1160 MPT_ADAPTER *ioc = hd->ioc;
1161
1162 if (!wqw) {
1163 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1164 "Failed to act on RAID event for physical disk %d\n",
1165 ioc->name, disk);
1166 return;
1167 }
1168 INIT_WORK(&wqw->work, mpt_work_wrapper);
1169 wqw->hd = hd;
1170 wqw->disk = disk;
1171
1172 schedule_work(&wqw->work);
1173}
1174
1175static int
1176mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1177{
1178 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1179 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1180
1181 if (ioc->bus_type != SPI)
1182 return 0;
1183
1184 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1185 int reason
1186 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1187
1188 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1189 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1190 mpt_dv_raid(hd, disk);
1191 }
1192 }
1193 return mptscsih_event_process(ioc, pEvReply);
1194}
1195
1196static int
1197mptspi_deny_binding(struct scsi_target *starget)
1198{
1199 struct _MPT_SCSI_HOST *hd =
1200 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1201 return ((mptspi_is_raid(hd, starget->id)) &&
1202 starget->channel == 0) ? 1 : 0;
1203}
1204
1205static struct spi_function_template mptspi_transport_functions = {
1206 .get_offset = mptspi_read_parameters,
1207 .set_offset = mptspi_write_offset,
1208 .show_offset = 1,
1209 .get_period = mptspi_read_parameters,
1210 .set_period = mptspi_write_period,
1211 .show_period = 1,
1212 .get_width = mptspi_read_parameters,
1213 .set_width = mptspi_write_width,
1214 .show_width = 1,
1215 .get_iu = mptspi_read_parameters,
1216 .set_iu = mptspi_write_iu,
1217 .show_iu = 1,
1218 .get_dt = mptspi_read_parameters,
1219 .set_dt = mptspi_write_dt,
1220 .show_dt = 1,
1221 .get_qas = mptspi_read_parameters,
1222 .set_qas = mptspi_write_qas,
1223 .show_qas = 1,
1224 .get_wr_flow = mptspi_read_parameters,
1225 .set_wr_flow = mptspi_write_wr_flow,
1226 .show_wr_flow = 1,
1227 .get_rd_strm = mptspi_read_parameters,
1228 .set_rd_strm = mptspi_write_rd_strm,
1229 .show_rd_strm = 1,
1230 .get_rti = mptspi_read_parameters,
1231 .set_rti = mptspi_write_rti,
1232 .show_rti = 1,
1233 .get_pcomp_en = mptspi_read_parameters,
1234 .set_pcomp_en = mptspi_write_pcomp_en,
1235 .show_pcomp_en = 1,
1236 .get_hold_mcs = mptspi_read_parameters,
1237 .set_hold_mcs = mptspi_write_hold_mcs,
1238 .show_hold_mcs = 1,
1239 .deny_binding = mptspi_deny_binding,
1240};
1241
1242/****************************************************************************
1243 * Supported hardware
1244 */
1245
1246static struct pci_device_id mptspi_pci_table[] = {
1247 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1248 PCI_ANY_ID, PCI_ANY_ID },
1249 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1250 PCI_ANY_ID, PCI_ANY_ID },
1251 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1252 PCI_ANY_ID, PCI_ANY_ID },
1253 {0} /* Terminating entry */
1254};
1255MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1256
1257
1258/*
1259 * renegotiate for a given target
1260 */
1261static void
1262mptspi_dv_renegotiate_work(struct work_struct *work)
1263{
1264 struct work_queue_wrapper *wqw =
1265 container_of(work, struct work_queue_wrapper, work);
1266 struct _MPT_SCSI_HOST *hd = wqw->hd;
1267 struct scsi_device *sdev;
1268 struct scsi_target *starget;
1269 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1270 u32 nego;
1271 MPT_ADAPTER *ioc = hd->ioc;
1272
1273 kfree(wqw);
1274
1275 if (hd->spi_pending) {
1276 shost_for_each_device(sdev, ioc->sh) {
1277 if (hd->spi_pending & (1 << sdev->id))
1278 continue;
1279 starget = scsi_target(sdev);
1280 nego = mptspi_getRP(starget);
1281 pg1.RequestedParameters = cpu_to_le32(nego);
1282 pg1.Reserved = 0;
1283 pg1.Configuration = 0;
1284 mptspi_write_spi_device_pg1(starget, &pg1);
1285 }
1286 } else {
1287 shost_for_each_device(sdev, ioc->sh)
1288 mptspi_dv_device(hd, sdev);
1289 }
1290}
1291
1292static void
1293mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1294{
1295 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1296
1297 if (!wqw)
1298 return;
1299
1300 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1301 wqw->hd = hd;
1302
1303 schedule_work(&wqw->work);
1304}
1305
1306/*
1307 * spi module reset handler
1308 */
1309static int
1310mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1311{
1312 int rc;
1313
1314 rc = mptscsih_ioc_reset(ioc, reset_phase);
1315 if ((ioc->bus_type != SPI) || (!rc))
1316 return rc;
1317
1318 /* only try to do a renegotiation if we're properly set up
1319 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1320 if (reset_phase == MPT_IOC_POST_RESET &&
1321 ioc->sh) {
1322 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1323
1324 mptspi_dv_renegotiate(hd);
1325 }
1326
1327 return rc;
1328}
1329
1330#ifdef CONFIG_PM
1331/*
1332 * spi module resume handler
1333 */
1334static int
1335mptspi_resume(struct pci_dev *pdev)
1336{
1337 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1338 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1339 int rc;
1340
1341 rc = mptscsih_resume(pdev);
1342 mptspi_dv_renegotiate(hd);
1343
1344 return rc;
1345}
1346#endif
1347
1348/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1349/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1350/*
1351 * mptspi_probe - Installs scsi devices per bus.
1352 * @pdev: Pointer to pci_dev structure
1353 *
1354 * Returns 0 for success, non-zero for failure.
1355 *
1356 */
1357static int
1358mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1359{
1360 struct Scsi_Host *sh;
1361 MPT_SCSI_HOST *hd;
1362 MPT_ADAPTER *ioc;
1363 unsigned long flags;
1364 int ii;
1365 int numSGE = 0;
1366 int scale;
1367 int ioc_cap;
1368 int error=0;
1369 int r;
1370
1371 if ((r = mpt_attach(pdev,id)) != 0)
1372 return r;
1373
1374 ioc = pci_get_drvdata(pdev);
1375 ioc->DoneCtx = mptspiDoneCtx;
1376 ioc->TaskCtx = mptspiTaskCtx;
1377 ioc->InternalCtx = mptspiInternalCtx;
1378
1379 /* Added sanity check on readiness of the MPT adapter.
1380 */
1381 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1382 printk(MYIOC_s_WARN_FMT
1383 "Skipping because it's not operational!\n",
1384 ioc->name);
1385 error = -ENODEV;
1386 goto out_mptspi_probe;
1387 }
1388
1389 if (!ioc->active) {
1390 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1391 ioc->name);
1392 error = -ENODEV;
1393 goto out_mptspi_probe;
1394 }
1395
1396 /* Sanity check - ensure at least 1 port is INITIATOR capable
1397 */
1398 ioc_cap = 0;
1399 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1400 if (ioc->pfacts[ii].ProtocolFlags &
1401 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1402 ioc_cap ++;
1403 }
1404
1405 if (!ioc_cap) {
1406 printk(MYIOC_s_WARN_FMT
1407 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1408 ioc->name, ioc);
1409 return 0;
1410 }
1411
1412 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1413
1414 if (!sh) {
1415 printk(MYIOC_s_WARN_FMT
1416 "Unable to register controller with SCSI subsystem\n",
1417 ioc->name);
1418 error = -1;
1419 goto out_mptspi_probe;
1420 }
1421
1422 /* VMWare emulation doesn't properly implement WRITE_SAME
1423 */
1424 if (pdev->subsystem_vendor == 0x15AD)
1425 sh->no_write_same = 1;
1426
1427 spin_lock_irqsave(&ioc->FreeQlock, flags);
1428
1429 /* Attach the SCSI Host to the IOC structure
1430 */
1431 ioc->sh = sh;
1432
1433 sh->io_port = 0;
1434 sh->n_io_port = 0;
1435 sh->irq = 0;
1436
1437 /* set 16 byte cdb's */
1438 sh->max_cmd_len = 16;
1439
1440 /* Yikes! This is important!
1441 * Otherwise, by default, linux
1442 * only scans target IDs 0-7!
1443 * pfactsN->MaxDevices unreliable
1444 * (not supported in early
1445 * versions of the FW).
1446 * max_id = 1 + actual max id,
1447 * max_lun = 1 + actual last lun,
1448 * see hosts.h :o(
1449 */
1450 sh->max_id = ioc->devices_per_bus;
1451
1452 sh->max_lun = MPT_LAST_LUN + 1;
1453 /*
1454 * If RAID Firmware Detected, setup virtual channel
1455 */
1456 if (ioc->ir_firmware)
1457 sh->max_channel = 1;
1458 else
1459 sh->max_channel = 0;
1460 sh->this_id = ioc->pfacts[0].PortSCSIID;
1461
1462 /* Required entry.
1463 */
1464 sh->unique_id = ioc->id;
1465
1466 /* Verify that we won't exceed the maximum
1467 * number of chain buffers
1468 * We can optimize: ZZ = req_sz/sizeof(SGE)
1469 * For 32bit SGE's:
1470 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1471 * + (req_sz - 64)/sizeof(SGE)
1472 * A slightly different algorithm is required for
1473 * 64bit SGEs.
1474 */
1475 scale = ioc->req_sz/ioc->SGE_size;
1476 if (ioc->sg_addr_size == sizeof(u64)) {
1477 numSGE = (scale - 1) *
1478 (ioc->facts.MaxChainDepth-1) + scale +
1479 (ioc->req_sz - 60) / ioc->SGE_size;
1480 } else {
1481 numSGE = 1 + (scale - 1) *
1482 (ioc->facts.MaxChainDepth-1) + scale +
1483 (ioc->req_sz - 64) / ioc->SGE_size;
1484 }
1485
1486 if (numSGE < sh->sg_tablesize) {
1487 /* Reset this value */
1488 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1489 "Resetting sg_tablesize to %d from %d\n",
1490 ioc->name, numSGE, sh->sg_tablesize));
1491 sh->sg_tablesize = numSGE;
1492 }
1493
1494 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1495
1496 hd = shost_priv(sh);
1497 hd->ioc = ioc;
1498
1499 /* SCSI needs scsi_cmnd lookup table!
1500 * (with size equal to req_depth*PtrSz!)
1501 */
1502 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1503 if (!ioc->ScsiLookup) {
1504 error = -ENOMEM;
1505 goto out_mptspi_probe;
1506 }
1507 spin_lock_init(&ioc->scsi_lookup_lock);
1508
1509 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1510 ioc->name, ioc->ScsiLookup));
1511
1512 ioc->spi_data.Saf_Te = mpt_saf_te;
1513 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1514 "saf_te %x\n",
1515 ioc->name,
1516 mpt_saf_te));
1517 ioc->spi_data.noQas = 0;
1518
1519 hd->last_queue_full = 0;
1520 hd->spi_pending = 0;
1521
1522 /* Some versions of the firmware don't support page 0; without
1523 * that we can't get the parameters */
1524 if (ioc->spi_data.sdp0length != 0)
1525 sh->transportt = mptspi_transport_template;
1526
1527 error = scsi_add_host (sh, &ioc->pcidev->dev);
1528 if(error) {
1529 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1530 "scsi_add_host failed\n", ioc->name));
1531 goto out_mptspi_probe;
1532 }
1533
1534 /*
1535 * issue internal bus reset
1536 */
1537 if (ioc->spi_data.bus_reset)
1538 mptscsih_IssueTaskMgmt(hd,
1539 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1540 0, 0, 0, 0, 5);
1541
1542 scsi_scan_host(sh);
1543 return 0;
1544
1545out_mptspi_probe:
1546
1547 mptscsih_remove(pdev);
1548 return error;
1549}
1550
1551static struct pci_driver mptspi_driver = {
1552 .name = "mptspi",
1553 .id_table = mptspi_pci_table,
1554 .probe = mptspi_probe,
1555 .remove = mptscsih_remove,
1556 .shutdown = mptscsih_shutdown,
1557#ifdef CONFIG_PM
1558 .suspend = mptscsih_suspend,
1559 .resume = mptspi_resume,
1560#endif
1561};
1562
1563/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1564/**
1565 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1566 *
1567 * Returns 0 for success, non-zero for failure.
1568 */
1569static int __init
1570mptspi_init(void)
1571{
1572 int error;
1573
1574 show_mptmod_ver(my_NAME, my_VERSION);
1575
1576 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1577 if (!mptspi_transport_template)
1578 return -ENODEV;
1579
1580 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1581 "mptscsih_io_done");
1582 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1583 "mptscsih_taskmgmt_complete");
1584 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1585 MPTSPI_DRIVER, "mptscsih_scandv_complete");
1586
1587 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1588 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1589
1590 error = pci_register_driver(&mptspi_driver);
1591 if (error)
1592 spi_release_transport(mptspi_transport_template);
1593
1594 return error;
1595}
1596
1597/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1598/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1599/**
1600 * mptspi_exit - Unregisters MPT adapter(s)
1601 */
1602static void __exit
1603mptspi_exit(void)
1604{
1605 pci_unregister_driver(&mptspi_driver);
1606
1607 mpt_reset_deregister(mptspiDoneCtx);
1608 mpt_event_deregister(mptspiDoneCtx);
1609
1610 mpt_deregister(mptspiInternalCtx);
1611 mpt_deregister(mptspiTaskCtx);
1612 mpt_deregister(mptspiDoneCtx);
1613 spi_release_transport(mptspi_transport_template);
1614}
1615
1616module_init(mptspi_init);
1617module_exit(mptspi_exit);