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