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