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
77 MODULE_AUTHOR(MODULEAUTHOR);
78 MODULE_DESCRIPTION(my_NAME);
79 MODULE_LICENSE("GPL");
80 MODULE_VERSION(my_VERSION);
81
82 /* Command line args */
83 static int mpt_saf_te = MPTSCSIH_SAF_TE;
84 module_param(mpt_saf_te, int, 0);
85 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
86
87 static void mptspi_write_offset(struct scsi_target *, int);
88 static void mptspi_write_width(struct scsi_target *, int);
89 static int mptspi_write_spi_device_pg1(struct scsi_target *,
90 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
91
92 static struct scsi_transport_template *mptspi_transport_template = NULL;
93
94 static u8 mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
95 static u8 mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
96 static 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 **/
107 static void
mptspi_setTargetNegoParms(MPT_SCSI_HOST * hd,VirtTarget * target,struct scsi_device * sdev)108 mptspi_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 **/
253 static int
mptspi_writeIOCPage4(MPT_SCSI_HOST * hd,u8 channel,u8 id)254 mptspi_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 **/
327 static void
mptspi_initTarget(MPT_SCSI_HOST * hd,VirtTarget * vtarget,struct scsi_device * sdev)328 mptspi_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 */
375 static int
mptspi_is_raid(struct _MPT_SCSI_HOST * hd,u32 id)376 mptspi_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
mptspi_target_alloc(struct scsi_target * starget)397 static 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
456 static void
mptspi_target_destroy(struct scsi_target * starget)457 mptspi_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 */
470 static void
mptspi_print_write_nego(struct _MPT_SCSI_HOST * hd,struct scsi_target * starget,u32 ii)471 mptspi_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 */
495 static void
mptspi_print_read_nego(struct _MPT_SCSI_HOST * hd,struct scsi_target * starget,u32 ii)496 mptspi_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
mptspi_read_spi_device_pg0(struct scsi_target * starget,struct _CONFIG_PAGE_SCSI_DEVICE_0 * pass_pg0)513 static 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
mptspi_getRP(struct scsi_target * starget)575 static 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
mptspi_read_parameters(struct scsi_target * starget)595 static 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
617 static int
mptscsih_quiesce_raid(MPT_SCSI_HOST * hd,int quiesce,u8 channel,u8 id)618 mptscsih_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
mptspi_dv_device(struct _MPT_SCSI_HOST * hd,struct scsi_device * sdev)683 static 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
mptspi_sdev_init(struct scsi_device * sdev)716 static int mptspi_sdev_init(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 "sdev_init 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
mptspi_sdev_configure(struct scsi_device * sdev,struct queue_limits * lim)749 static int mptspi_sdev_configure(struct scsi_device *sdev,
750 struct queue_limits *lim)
751 {
752 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
753 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
754 int ret;
755
756 mptspi_initTarget(hd, vtarget, sdev);
757
758 ret = mptscsih_sdev_configure(sdev, lim);
759
760 if (ret)
761 return ret;
762
763 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
764 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
765 sdev->id, spi_min_period(scsi_target(sdev)),
766 spi_max_offset(scsi_target(sdev)),
767 spi_max_width(scsi_target(sdev))));
768
769 if ((sdev->channel == 1 ||
770 !(mptspi_is_raid(hd, sdev->id))) &&
771 !spi_initial_dv(sdev->sdev_target))
772 mptspi_dv_device(hd, sdev);
773
774 return 0;
775 }
776
777 static int
mptspi_qcmd(struct Scsi_Host * shost,struct scsi_cmnd * SCpnt)778 mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
779 {
780 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
781 VirtDevice *vdevice = SCpnt->device->hostdata;
782 MPT_ADAPTER *ioc = hd->ioc;
783
784 if (!vdevice || !vdevice->vtarget) {
785 SCpnt->result = DID_NO_CONNECT << 16;
786 scsi_done(SCpnt);
787 return 0;
788 }
789
790 if (SCpnt->device->channel == 1 &&
791 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
792 SCpnt->result = DID_NO_CONNECT << 16;
793 scsi_done(SCpnt);
794 return 0;
795 }
796
797 if (spi_dv_pending(scsi_target(SCpnt->device)))
798 ddvprintk(ioc, scsi_print_command(SCpnt));
799
800 return mptscsih_qcmd(SCpnt);
801 }
802
mptspi_sdev_destroy(struct scsi_device * sdev)803 static void mptspi_sdev_destroy(struct scsi_device *sdev)
804 {
805 struct scsi_target *starget = scsi_target(sdev);
806 VirtTarget *vtarget = starget->hostdata;
807 VirtDevice *vdevice = sdev->hostdata;
808
809 /* Will this be the last lun on a non-raid device? */
810 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
811 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
812
813 /* Async Narrow */
814 pg1.RequestedParameters = 0;
815 pg1.Reserved = 0;
816 pg1.Configuration = 0;
817
818 mptspi_write_spi_device_pg1(starget, &pg1);
819 }
820
821 mptscsih_sdev_destroy(sdev);
822 }
823
824 static const struct scsi_host_template mptspi_driver_template = {
825 .module = THIS_MODULE,
826 .proc_name = "mptspi",
827 .show_info = mptscsih_show_info,
828 .name = "MPT SPI Host",
829 .info = mptscsih_info,
830 .queuecommand = mptspi_qcmd,
831 .target_alloc = mptspi_target_alloc,
832 .sdev_init = mptspi_sdev_init,
833 .sdev_configure = mptspi_sdev_configure,
834 .target_destroy = mptspi_target_destroy,
835 .sdev_destroy = mptspi_sdev_destroy,
836 .change_queue_depth = mptscsih_change_queue_depth,
837 .eh_abort_handler = mptscsih_abort,
838 .eh_device_reset_handler = mptscsih_dev_reset,
839 .eh_bus_reset_handler = mptscsih_bus_reset,
840 .eh_host_reset_handler = mptscsih_host_reset,
841 .bios_param = mptscsih_bios_param,
842 .can_queue = MPT_SCSI_CAN_QUEUE,
843 .this_id = -1,
844 .sg_tablesize = MPT_SCSI_SG_DEPTH,
845 .max_sectors = 8192,
846 .cmd_per_lun = 7,
847 .dma_alignment = 511,
848 .shost_groups = mptscsih_host_attr_groups,
849 };
850
mptspi_write_spi_device_pg1(struct scsi_target * starget,struct _CONFIG_PAGE_SCSI_DEVICE_1 * pass_pg1)851 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
852 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
853 {
854 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
855 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
856 struct _MPT_ADAPTER *ioc = hd->ioc;
857 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
858 dma_addr_t pg1_dma;
859 int size;
860 struct _x_config_parms cfg;
861 struct _CONFIG_PAGE_HEADER hdr;
862 int err = -EBUSY;
863 u32 nego_parms;
864 u32 period;
865 struct scsi_device *sdev;
866 int i;
867
868 /* don't allow updating nego parameters on RAID devices */
869 if (starget->channel == 0 &&
870 mptspi_is_raid(hd, starget->id))
871 return -1;
872
873 size = ioc->spi_data.sdp1length * 4;
874
875 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
876 if (pg1 == NULL) {
877 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
878 "dma_alloc_coherent for parameters failed\n", ioc->name);
879 return -EINVAL;
880 }
881
882 memset(&hdr, 0, sizeof(hdr));
883
884 hdr.PageVersion = ioc->spi_data.sdp1version;
885 hdr.PageLength = ioc->spi_data.sdp1length;
886 hdr.PageNumber = 1;
887 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
888
889 memset(&cfg, 0, sizeof(cfg));
890
891 cfg.cfghdr.hdr = &hdr;
892 cfg.physAddr = pg1_dma;
893 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
894 cfg.dir = 1;
895 cfg.pageAddr = starget->id;
896
897 memcpy(pg1, pass_pg1, size);
898
899 pg1->Header.PageVersion = hdr.PageVersion;
900 pg1->Header.PageLength = hdr.PageLength;
901 pg1->Header.PageNumber = hdr.PageNumber;
902 pg1->Header.PageType = hdr.PageType;
903
904 nego_parms = le32_to_cpu(pg1->RequestedParameters);
905 period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
906 MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
907 if (period == 8) {
908 /* Turn on inline data padding for TAPE when running U320 */
909 for (i = 0 ; i < 16; i++) {
910 sdev = scsi_device_lookup_by_target(starget, i);
911 if (sdev && sdev->type == TYPE_TAPE) {
912 sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
913 "IDP:ON\n", ioc->name);
914 nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
915 pg1->RequestedParameters =
916 cpu_to_le32(nego_parms);
917 break;
918 }
919 }
920 }
921
922 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
923
924 if (mpt_config(ioc, &cfg)) {
925 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
926 "mpt_config failed\n", ioc->name);
927 goto out_free;
928 }
929 err = 0;
930
931 out_free:
932 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
933 return err;
934 }
935
mptspi_write_offset(struct scsi_target * starget,int offset)936 static void mptspi_write_offset(struct scsi_target *starget, int offset)
937 {
938 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
939 u32 nego;
940
941 if (offset < 0)
942 offset = 0;
943
944 if (offset > 255)
945 offset = 255;
946
947 if (spi_offset(starget) == -1)
948 mptspi_read_parameters(starget);
949
950 spi_offset(starget) = offset;
951
952 nego = mptspi_getRP(starget);
953
954 pg1.RequestedParameters = cpu_to_le32(nego);
955 pg1.Reserved = 0;
956 pg1.Configuration = 0;
957
958 mptspi_write_spi_device_pg1(starget, &pg1);
959 }
960
mptspi_write_period(struct scsi_target * starget,int period)961 static void mptspi_write_period(struct scsi_target *starget, int period)
962 {
963 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
964 u32 nego;
965
966 if (period < 8)
967 period = 8;
968
969 if (period > 255)
970 period = 255;
971
972 if (spi_period(starget) == -1)
973 mptspi_read_parameters(starget);
974
975 if (period == 8) {
976 spi_iu(starget) = 1;
977 spi_dt(starget) = 1;
978 } else if (period == 9) {
979 spi_dt(starget) = 1;
980 }
981
982 spi_period(starget) = period;
983
984 nego = mptspi_getRP(starget);
985
986 pg1.RequestedParameters = cpu_to_le32(nego);
987 pg1.Reserved = 0;
988 pg1.Configuration = 0;
989
990 mptspi_write_spi_device_pg1(starget, &pg1);
991 }
992
mptspi_write_dt(struct scsi_target * starget,int dt)993 static void mptspi_write_dt(struct scsi_target *starget, int dt)
994 {
995 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
996 u32 nego;
997
998 if (spi_period(starget) == -1)
999 mptspi_read_parameters(starget);
1000
1001 if (!dt && spi_period(starget) < 10)
1002 spi_period(starget) = 10;
1003
1004 spi_dt(starget) = dt;
1005
1006 nego = mptspi_getRP(starget);
1007
1008
1009 pg1.RequestedParameters = cpu_to_le32(nego);
1010 pg1.Reserved = 0;
1011 pg1.Configuration = 0;
1012
1013 mptspi_write_spi_device_pg1(starget, &pg1);
1014 }
1015
mptspi_write_iu(struct scsi_target * starget,int iu)1016 static void mptspi_write_iu(struct scsi_target *starget, int iu)
1017 {
1018 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1019 u32 nego;
1020
1021 if (spi_period(starget) == -1)
1022 mptspi_read_parameters(starget);
1023
1024 if (!iu && spi_period(starget) < 9)
1025 spi_period(starget) = 9;
1026
1027 spi_iu(starget) = iu;
1028
1029 nego = mptspi_getRP(starget);
1030
1031 pg1.RequestedParameters = cpu_to_le32(nego);
1032 pg1.Reserved = 0;
1033 pg1.Configuration = 0;
1034
1035 mptspi_write_spi_device_pg1(starget, &pg1);
1036 }
1037
1038 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1039 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1040 { \
1041 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1042 u32 nego; \
1043 \
1044 spi_##parm(starget) = parm; \
1045 \
1046 nego = mptspi_getRP(starget); \
1047 \
1048 pg1.RequestedParameters = cpu_to_le32(nego); \
1049 pg1.Reserved = 0; \
1050 pg1.Configuration = 0; \
1051 \
1052 mptspi_write_spi_device_pg1(starget, &pg1); \
1053 }
1054
1055 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)1056 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1057 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1058 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1059 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1060
1061 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1062 {
1063 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1064 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1065 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1066 VirtTarget *vtarget = starget->hostdata;
1067 u32 nego;
1068
1069 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1070 hd->ioc->spi_data.noQas)
1071 spi_qas(starget) = 0;
1072 else
1073 spi_qas(starget) = qas;
1074
1075 nego = mptspi_getRP(starget);
1076
1077 pg1.RequestedParameters = cpu_to_le32(nego);
1078 pg1.Reserved = 0;
1079 pg1.Configuration = 0;
1080
1081 mptspi_write_spi_device_pg1(starget, &pg1);
1082 }
1083
mptspi_write_width(struct scsi_target * starget,int width)1084 static void mptspi_write_width(struct scsi_target *starget, int width)
1085 {
1086 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1087 u32 nego;
1088
1089 if (!width) {
1090 spi_dt(starget) = 0;
1091 if (spi_period(starget) < 10)
1092 spi_period(starget) = 10;
1093 }
1094
1095 spi_width(starget) = width;
1096
1097 nego = mptspi_getRP(starget);
1098
1099 pg1.RequestedParameters = cpu_to_le32(nego);
1100 pg1.Reserved = 0;
1101 pg1.Configuration = 0;
1102
1103 mptspi_write_spi_device_pg1(starget, &pg1);
1104 }
1105
1106 struct work_queue_wrapper {
1107 struct work_struct work;
1108 struct _MPT_SCSI_HOST *hd;
1109 int disk;
1110 };
1111
mpt_work_wrapper(struct work_struct * work)1112 static void mpt_work_wrapper(struct work_struct *work)
1113 {
1114 struct work_queue_wrapper *wqw =
1115 container_of(work, struct work_queue_wrapper, work);
1116 struct _MPT_SCSI_HOST *hd = wqw->hd;
1117 MPT_ADAPTER *ioc = hd->ioc;
1118 struct Scsi_Host *shost = ioc->sh;
1119 struct scsi_device *sdev;
1120 int disk = wqw->disk;
1121 struct _CONFIG_PAGE_IOC_3 *pg3;
1122
1123 kfree(wqw);
1124
1125 mpt_findImVolumes(ioc);
1126 pg3 = ioc->raid_data.pIocPg3;
1127 if (!pg3)
1128 return;
1129
1130 shost_for_each_device(sdev,shost) {
1131 struct scsi_target *starget = scsi_target(sdev);
1132 VirtTarget *vtarget = starget->hostdata;
1133
1134 /* only want to search RAID components */
1135 if (sdev->channel != 1)
1136 continue;
1137
1138 /* The id is the raid PhysDiskNum, even if
1139 * starget->id is the actual target address */
1140 if(vtarget->id != disk)
1141 continue;
1142
1143 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1144 "Integrated RAID requests DV of new device\n", ioc->name);
1145 mptspi_dv_device(hd, sdev);
1146 }
1147 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1148 "Integrated RAID detects new device %d\n", ioc->name, disk);
1149 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN);
1150 }
1151
1152
mpt_dv_raid(struct _MPT_SCSI_HOST * hd,int disk)1153 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1154 {
1155 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1156 MPT_ADAPTER *ioc = hd->ioc;
1157
1158 if (!wqw) {
1159 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1160 "Failed to act on RAID event for physical disk %d\n",
1161 ioc->name, disk);
1162 return;
1163 }
1164 INIT_WORK(&wqw->work, mpt_work_wrapper);
1165 wqw->hd = hd;
1166 wqw->disk = disk;
1167
1168 schedule_work(&wqw->work);
1169 }
1170
1171 static int
mptspi_event_process(MPT_ADAPTER * ioc,EventNotificationReply_t * pEvReply)1172 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1173 {
1174 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1175 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1176
1177 if (ioc->bus_type != SPI)
1178 return 0;
1179
1180 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1181 int reason
1182 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1183
1184 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1185 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1186 mpt_dv_raid(hd, disk);
1187 }
1188 }
1189 return mptscsih_event_process(ioc, pEvReply);
1190 }
1191
1192 static int
mptspi_deny_binding(struct scsi_target * starget)1193 mptspi_deny_binding(struct scsi_target *starget)
1194 {
1195 struct _MPT_SCSI_HOST *hd =
1196 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1197 return ((mptspi_is_raid(hd, starget->id)) &&
1198 starget->channel == 0) ? 1 : 0;
1199 }
1200
1201 static struct spi_function_template mptspi_transport_functions = {
1202 .get_offset = mptspi_read_parameters,
1203 .set_offset = mptspi_write_offset,
1204 .show_offset = 1,
1205 .get_period = mptspi_read_parameters,
1206 .set_period = mptspi_write_period,
1207 .show_period = 1,
1208 .get_width = mptspi_read_parameters,
1209 .set_width = mptspi_write_width,
1210 .show_width = 1,
1211 .get_iu = mptspi_read_parameters,
1212 .set_iu = mptspi_write_iu,
1213 .show_iu = 1,
1214 .get_dt = mptspi_read_parameters,
1215 .set_dt = mptspi_write_dt,
1216 .show_dt = 1,
1217 .get_qas = mptspi_read_parameters,
1218 .set_qas = mptspi_write_qas,
1219 .show_qas = 1,
1220 .get_wr_flow = mptspi_read_parameters,
1221 .set_wr_flow = mptspi_write_wr_flow,
1222 .show_wr_flow = 1,
1223 .get_rd_strm = mptspi_read_parameters,
1224 .set_rd_strm = mptspi_write_rd_strm,
1225 .show_rd_strm = 1,
1226 .get_rti = mptspi_read_parameters,
1227 .set_rti = mptspi_write_rti,
1228 .show_rti = 1,
1229 .get_pcomp_en = mptspi_read_parameters,
1230 .set_pcomp_en = mptspi_write_pcomp_en,
1231 .show_pcomp_en = 1,
1232 .get_hold_mcs = mptspi_read_parameters,
1233 .set_hold_mcs = mptspi_write_hold_mcs,
1234 .show_hold_mcs = 1,
1235 .deny_binding = mptspi_deny_binding,
1236 };
1237
1238 /****************************************************************************
1239 * Supported hardware
1240 */
1241
1242 static const struct pci_device_id mptspi_pci_table[] = {
1243 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1244 PCI_ANY_ID, PCI_ANY_ID },
1245 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1246 PCI_ANY_ID, PCI_ANY_ID },
1247 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1248 PCI_ANY_ID, PCI_ANY_ID },
1249 {0} /* Terminating entry */
1250 };
1251 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1252
1253
1254 /*
1255 * renegotiate for a given target
1256 */
1257 static void
mptspi_dv_renegotiate_work(struct work_struct * work)1258 mptspi_dv_renegotiate_work(struct work_struct *work)
1259 {
1260 struct work_queue_wrapper *wqw =
1261 container_of(work, struct work_queue_wrapper, work);
1262 struct _MPT_SCSI_HOST *hd = wqw->hd;
1263 struct scsi_device *sdev;
1264 struct scsi_target *starget;
1265 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1266 u32 nego;
1267 MPT_ADAPTER *ioc = hd->ioc;
1268
1269 kfree(wqw);
1270
1271 if (hd->spi_pending) {
1272 shost_for_each_device(sdev, ioc->sh) {
1273 if (hd->spi_pending & (1 << sdev->id))
1274 continue;
1275 starget = scsi_target(sdev);
1276 nego = mptspi_getRP(starget);
1277 pg1.RequestedParameters = cpu_to_le32(nego);
1278 pg1.Reserved = 0;
1279 pg1.Configuration = 0;
1280 mptspi_write_spi_device_pg1(starget, &pg1);
1281 }
1282 } else {
1283 shost_for_each_device(sdev, ioc->sh)
1284 mptspi_dv_device(hd, sdev);
1285 }
1286 }
1287
1288 static void
mptspi_dv_renegotiate(struct _MPT_SCSI_HOST * hd)1289 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1290 {
1291 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1292
1293 if (!wqw)
1294 return;
1295
1296 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1297 wqw->hd = hd;
1298
1299 schedule_work(&wqw->work);
1300 }
1301
1302 /*
1303 * spi module reset handler
1304 */
1305 static int
mptspi_ioc_reset(MPT_ADAPTER * ioc,int reset_phase)1306 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1307 {
1308 int rc;
1309
1310 rc = mptscsih_ioc_reset(ioc, reset_phase);
1311 if ((ioc->bus_type != SPI) || (!rc))
1312 return rc;
1313
1314 /* only try to do a renegotiation if we're properly set up
1315 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1316 if (reset_phase == MPT_IOC_POST_RESET &&
1317 ioc->sh) {
1318 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1319
1320 mptspi_dv_renegotiate(hd);
1321 }
1322
1323 return rc;
1324 }
1325
1326 #ifdef CONFIG_PM
1327 /*
1328 * spi module resume handler
1329 */
1330 static int
mptspi_resume(struct pci_dev * pdev)1331 mptspi_resume(struct pci_dev *pdev)
1332 {
1333 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1334 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1335 int rc;
1336
1337 rc = mptscsih_resume(pdev);
1338 mptspi_dv_renegotiate(hd);
1339
1340 return rc;
1341 }
1342 #endif
1343
1344 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1345 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1346 /*
1347 * mptspi_probe - Installs scsi devices per bus.
1348 * @pdev: Pointer to pci_dev structure
1349 *
1350 * Returns 0 for success, non-zero for failure.
1351 *
1352 */
1353 static int
mptspi_probe(struct pci_dev * pdev,const struct pci_device_id * id)1354 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1355 {
1356 struct Scsi_Host *sh;
1357 MPT_SCSI_HOST *hd;
1358 MPT_ADAPTER *ioc;
1359 unsigned long flags;
1360 int ii;
1361 int numSGE = 0;
1362 int scale;
1363 int ioc_cap;
1364 int error=0;
1365 int r;
1366
1367 if ((r = mpt_attach(pdev,id)) != 0)
1368 return r;
1369
1370 ioc = pci_get_drvdata(pdev);
1371 ioc->DoneCtx = mptspiDoneCtx;
1372 ioc->TaskCtx = mptspiTaskCtx;
1373 ioc->InternalCtx = mptspiInternalCtx;
1374
1375 /* Added sanity check on readiness of the MPT adapter.
1376 */
1377 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1378 printk(MYIOC_s_WARN_FMT
1379 "Skipping because it's not operational!\n",
1380 ioc->name);
1381 error = -ENODEV;
1382 goto out_mptspi_probe;
1383 }
1384
1385 if (!ioc->active) {
1386 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1387 ioc->name);
1388 error = -ENODEV;
1389 goto out_mptspi_probe;
1390 }
1391
1392 /* Sanity check - ensure at least 1 port is INITIATOR capable
1393 */
1394 ioc_cap = 0;
1395 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1396 if (ioc->pfacts[ii].ProtocolFlags &
1397 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1398 ioc_cap ++;
1399 }
1400
1401 if (!ioc_cap) {
1402 printk(MYIOC_s_WARN_FMT
1403 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1404 ioc->name, ioc);
1405 return 0;
1406 }
1407
1408 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1409
1410 if (!sh) {
1411 printk(MYIOC_s_WARN_FMT
1412 "Unable to register controller with SCSI subsystem\n",
1413 ioc->name);
1414 error = -1;
1415 goto out_mptspi_probe;
1416 }
1417
1418 /* VMWare emulation doesn't properly implement WRITE_SAME
1419 */
1420 if (pdev->subsystem_vendor == 0x15AD)
1421 sh->no_write_same = 1;
1422
1423 spin_lock_irqsave(&ioc->FreeQlock, flags);
1424
1425 /* Attach the SCSI Host to the IOC structure
1426 */
1427 ioc->sh = sh;
1428
1429 sh->io_port = 0;
1430 sh->n_io_port = 0;
1431 sh->irq = 0;
1432
1433 /* set 16 byte cdb's */
1434 sh->max_cmd_len = 16;
1435
1436 /* Yikes! This is important!
1437 * Otherwise, by default, linux
1438 * only scans target IDs 0-7!
1439 * pfactsN->MaxDevices unreliable
1440 * (not supported in early
1441 * versions of the FW).
1442 * max_id = 1 + actual max id,
1443 * max_lun = 1 + actual last lun,
1444 * see hosts.h :o(
1445 */
1446 sh->max_id = ioc->devices_per_bus;
1447
1448 sh->max_lun = MPT_LAST_LUN + 1;
1449 /*
1450 * If RAID Firmware Detected, setup virtual channel
1451 */
1452 if (ioc->ir_firmware)
1453 sh->max_channel = 1;
1454 else
1455 sh->max_channel = 0;
1456 sh->this_id = ioc->pfacts[0].PortSCSIID;
1457
1458 /* Required entry.
1459 */
1460 sh->unique_id = ioc->id;
1461
1462 /* Verify that we won't exceed the maximum
1463 * number of chain buffers
1464 * We can optimize: ZZ = req_sz/sizeof(SGE)
1465 * For 32bit SGE's:
1466 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1467 * + (req_sz - 64)/sizeof(SGE)
1468 * A slightly different algorithm is required for
1469 * 64bit SGEs.
1470 */
1471 scale = ioc->req_sz/ioc->SGE_size;
1472 if (ioc->sg_addr_size == sizeof(u64)) {
1473 numSGE = (scale - 1) *
1474 (ioc->facts.MaxChainDepth-1) + scale +
1475 (ioc->req_sz - 60) / ioc->SGE_size;
1476 } else {
1477 numSGE = 1 + (scale - 1) *
1478 (ioc->facts.MaxChainDepth-1) + scale +
1479 (ioc->req_sz - 64) / ioc->SGE_size;
1480 }
1481
1482 if (numSGE < sh->sg_tablesize) {
1483 /* Reset this value */
1484 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1485 "Resetting sg_tablesize to %d from %d\n",
1486 ioc->name, numSGE, sh->sg_tablesize));
1487 sh->sg_tablesize = numSGE;
1488 }
1489
1490 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1491
1492 hd = shost_priv(sh);
1493 hd->ioc = ioc;
1494
1495 /* SCSI needs scsi_cmnd lookup table!
1496 * (with size equal to req_depth*PtrSz!)
1497 */
1498 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_KERNEL);
1499 if (!ioc->ScsiLookup) {
1500 error = -ENOMEM;
1501 goto out_mptspi_probe;
1502 }
1503 spin_lock_init(&ioc->scsi_lookup_lock);
1504
1505 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1506 ioc->name, ioc->ScsiLookup));
1507
1508 ioc->spi_data.Saf_Te = mpt_saf_te;
1509 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1510 "saf_te %x\n",
1511 ioc->name,
1512 mpt_saf_te));
1513 ioc->spi_data.noQas = 0;
1514
1515 hd->last_queue_full = 0;
1516 hd->spi_pending = 0;
1517
1518 /* Some versions of the firmware don't support page 0; without
1519 * that we can't get the parameters */
1520 if (ioc->spi_data.sdp0length != 0)
1521 sh->transportt = mptspi_transport_template;
1522
1523 error = scsi_add_host (sh, &ioc->pcidev->dev);
1524 if(error) {
1525 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1526 "scsi_add_host failed\n", ioc->name));
1527 goto out_mptspi_probe;
1528 }
1529
1530 /*
1531 * issue internal bus reset
1532 */
1533 if (ioc->spi_data.bus_reset)
1534 mptscsih_IssueTaskMgmt(hd,
1535 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1536 0, 0, 0, 0, 5);
1537
1538 scsi_scan_host(sh);
1539 return 0;
1540
1541 out_mptspi_probe:
1542
1543 mptscsih_remove(pdev);
1544 return error;
1545 }
1546
mptspi_remove(struct pci_dev * pdev)1547 static void mptspi_remove(struct pci_dev *pdev)
1548 {
1549 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1550
1551 scsi_remove_host(ioc->sh);
1552 mptscsih_remove(pdev);
1553 }
1554
1555 static struct pci_driver mptspi_driver = {
1556 .name = "mptspi",
1557 .id_table = mptspi_pci_table,
1558 .probe = mptspi_probe,
1559 .remove = mptspi_remove,
1560 .shutdown = mptscsih_shutdown,
1561 #ifdef CONFIG_PM
1562 .suspend = mptscsih_suspend,
1563 .resume = mptspi_resume,
1564 #endif
1565 };
1566
1567 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1568 /**
1569 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1570 *
1571 * Returns 0 for success, non-zero for failure.
1572 */
1573 static int __init
mptspi_init(void)1574 mptspi_init(void)
1575 {
1576 int error;
1577
1578 show_mptmod_ver(my_NAME, my_VERSION);
1579
1580 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1581 if (!mptspi_transport_template)
1582 return -ENODEV;
1583
1584 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1585 "mptscsih_io_done");
1586 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1587 "mptscsih_taskmgmt_complete");
1588 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1589 MPTSPI_DRIVER, "mptscsih_scandv_complete");
1590
1591 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1592 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1593
1594 error = pci_register_driver(&mptspi_driver);
1595 if (error)
1596 spi_release_transport(mptspi_transport_template);
1597
1598 return error;
1599 }
1600
1601 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1602 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1603 /**
1604 * mptspi_exit - Unregisters MPT adapter(s)
1605 */
1606 static void __exit
mptspi_exit(void)1607 mptspi_exit(void)
1608 {
1609 pci_unregister_driver(&mptspi_driver);
1610
1611 mpt_reset_deregister(mptspiDoneCtx);
1612 mpt_event_deregister(mptspiDoneCtx);
1613
1614 mpt_deregister(mptspiInternalCtx);
1615 mpt_deregister(mptspiTaskCtx);
1616 mpt_deregister(mptspiDoneCtx);
1617 spi_release_transport(mptspi_transport_template);
1618 }
1619
1620 module_init(mptspi_init);
1621 module_exit(mptspi_exit);
1622