blob: 5398aeab191d44776a9345a5b46216b08227bb40 [file] [log] [blame]
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001/*
2 * linux/drivers/message/fusion/mptspi.c
3 * For use with LSI Logic PCI chip/adapter(s)
4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware.
5 *
Eric Moore9f4203b2007-01-04 20:47:47 -07006 * Copyright (c) 1999-2007 LSI Logic Corporation
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04007 * (mailto:mpt_linux_developer@lsil.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_compat.h" /* linux-2.6 tweaks */
48#include <linux/module.h>
49#include <linux/kernel.h>
50#include <linux/init.h>
51#include <linux/errno.h>
52#include <linux/kdev_t.h>
53#include <linux/blkdev.h>
54#include <linux/delay.h> /* for mdelay */
55#include <linux/interrupt.h> /* needed for in_interrupt() proto */
56#include <linux/reboot.h> /* notifier code */
57#include <linux/sched.h>
58#include <linux/workqueue.h>
James Bottomleyc92f2222006-03-01 09:02:49 -060059#include <linux/raid_class.h>
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -040060
61#include <scsi/scsi.h>
62#include <scsi/scsi_cmnd.h>
63#include <scsi/scsi_device.h>
64#include <scsi/scsi_host.h>
65#include <scsi/scsi_tcq.h>
James Bottomleyc92f2222006-03-01 09:02:49 -060066#include <scsi/scsi_transport.h>
67#include <scsi/scsi_transport_spi.h>
Eric Moore873c82e2007-01-29 09:44:06 -070068#include <scsi/scsi_dbg.h>
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -040069
70#include "mptbase.h"
71#include "mptscsih.h"
72
73/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
74#define my_NAME "Fusion MPT SPI Host driver"
75#define my_VERSION MPT_LINUX_VERSION_COMMON
76#define MYNAM "mptspi"
77
78MODULE_AUTHOR(MODULEAUTHOR);
79MODULE_DESCRIPTION(my_NAME);
80MODULE_LICENSE("GPL");
Eric Moore9f4203b2007-01-04 20:47:47 -070081MODULE_VERSION(my_VERSION);
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -040082
83/* Command line args */
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -040084static int mpt_saf_te = MPTSCSIH_SAF_TE;
85module_param(mpt_saf_te, int, 0);
86MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
87
James Bottomleyc92f2222006-03-01 09:02:49 -060088static void mptspi_write_offset(struct scsi_target *, int);
89static void mptspi_write_width(struct scsi_target *, int);
90static int mptspi_write_spi_device_pg1(struct scsi_target *,
91 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
92
93static struct scsi_transport_template *mptspi_transport_template = NULL;
94
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -040095static int mptspiDoneCtx = -1;
96static int mptspiTaskCtx = -1;
97static int mptspiInternalCtx = -1; /* Used only for internal commands */
98
Eric Moore5a9c47b2007-01-29 09:43:17 -070099/**
100 * mptspi_setTargetNegoParms - Update the target negotiation
101 * parameters based on the the Inquiry data, adapter capabilities,
102 * and NVRAM settings
103 *
104 * @hd: Pointer to a SCSI Host Structure
105 * @vtarget: per target private data
106 * @sdev: SCSI device
107 *
108 **/
109static void
110mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
111 struct scsi_device *sdev)
112{
113 SpiCfgData *pspi_data = &hd->ioc->spi_data;
114 int id = (int) target->id;
115 int nvram;
116 u8 width = MPT_NARROW;
117 u8 factor = MPT_ASYNC;
118 u8 offset = 0;
119 u8 nfactor;
120 u8 noQas = 1;
121
122 target->negoFlags = pspi_data->noQas;
123
124 if (sdev->scsi_level < SCSI_2) {
125 width = 0;
126 factor = MPT_ULTRA2;
127 offset = pspi_data->maxSyncOffset;
128 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
129 } else {
130 if (scsi_device_wide(sdev))
131 width = 1;
132
133 if (scsi_device_sync(sdev)) {
134 factor = pspi_data->minSyncFactor;
135 if (!scsi_device_dt(sdev))
136 factor = MPT_ULTRA2;
137 else {
138 if (!scsi_device_ius(sdev) &&
139 !scsi_device_qas(sdev))
140 factor = MPT_ULTRA160;
141 else {
142 factor = MPT_ULTRA320;
143 if (scsi_device_qas(sdev)) {
144 ddvprintk((KERN_INFO "Enabling QAS due to byte56=%02x on id=%d!\n", scsi_device_qas(sdev), id));
145 noQas = 0;
146 }
147 if (sdev->type == TYPE_TAPE &&
148 scsi_device_ius(sdev))
149 target->negoFlags |= MPT_TAPE_NEGO_IDP;
150 }
151 }
152 offset = pspi_data->maxSyncOffset;
153
154 /* If RAID, never disable QAS
155 * else if non RAID, do not disable
156 * QAS if bit 1 is set
157 * bit 1 QAS support, non-raid only
158 * bit 0 IU support
159 */
160 if (target->raidVolume == 1)
161 noQas = 0;
162 } else {
163 factor = MPT_ASYNC;
164 offset = 0;
165 }
166 }
167
168 if (!sdev->tagged_supported)
169 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
170
171 /* Update tflags based on NVRAM settings. (SCSI only)
172 */
173 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
174 nvram = pspi_data->nvram[id];
175 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
176
177 if (width)
178 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
179
180 if (offset > 0) {
181 /* Ensure factor is set to the
182 * maximum of: adapter, nvram, inquiry
183 */
184 if (nfactor) {
185 if (nfactor < pspi_data->minSyncFactor )
186 nfactor = pspi_data->minSyncFactor;
187
188 factor = max(factor, nfactor);
189 if (factor == MPT_ASYNC)
190 offset = 0;
191 } else {
192 offset = 0;
193 factor = MPT_ASYNC;
194 }
195 } else {
196 factor = MPT_ASYNC;
197 }
198 }
199
200 /* Make sure data is consistent
201 */
202 if ((!width) && (factor < MPT_ULTRA2))
203 factor = MPT_ULTRA2;
204
205 /* Save the data to the target structure.
206 */
207 target->minSyncFactor = factor;
208 target->maxOffset = offset;
209 target->maxWidth = width;
210
211 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
212
213 /* Disable unused features.
214 */
215 if (!width)
216 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
217
218 if (!offset)
219 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
220
221 if ( factor > MPT_ULTRA320 )
222 noQas = 0;
223
224 if (noQas && (pspi_data->noQas == 0)) {
225 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
226 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
227
228 /* Disable QAS in a mixed configuration case
229 */
230
231 ddvprintk((KERN_INFO "Disabling QAS due to noQas=%02x on id=%d!\n", noQas, id));
232 }
233}
234
235/**
236 * mptspi_writeIOCPage4 - write IOC Page 4
237 * @hd: Pointer to a SCSI Host Structure
238 * @channel:
239 * @id: write IOC Page4 for this ID & Bus
240 *
241 * Return: -EAGAIN if unable to obtain a Message Frame
242 * or 0 if success.
243 *
244 * Remark: We do not wait for a return, write pages sequentially.
245 **/
246static int
247mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
248{
249 MPT_ADAPTER *ioc = hd->ioc;
250 Config_t *pReq;
251 IOCPage4_t *IOCPage4Ptr;
252 MPT_FRAME_HDR *mf;
253 dma_addr_t dataDma;
254 u16 req_idx;
255 u32 frameOffset;
256 u32 flagsLength;
257 int ii;
258
259 /* Get a MF for this command.
260 */
261 if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
262 dfailprintk((MYIOC_s_WARN_FMT "writeIOCPage4 : no msg frames!\n",
263 ioc->name));
264 return -EAGAIN;
265 }
266
267 /* Set the request and the data pointers.
268 * Place data at end of MF.
269 */
270 pReq = (Config_t *)mf;
271
272 req_idx = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
273 frameOffset = ioc->req_sz - sizeof(IOCPage4_t);
274
275 /* Complete the request frame (same for all requests).
276 */
277 pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
278 pReq->Reserved = 0;
279 pReq->ChainOffset = 0;
280 pReq->Function = MPI_FUNCTION_CONFIG;
281 pReq->ExtPageLength = 0;
282 pReq->ExtPageType = 0;
283 pReq->MsgFlags = 0;
284 for (ii=0; ii < 8; ii++) {
285 pReq->Reserved2[ii] = 0;
286 }
287
288 IOCPage4Ptr = ioc->spi_data.pIocPg4;
289 dataDma = ioc->spi_data.IocPg4_dma;
290 ii = IOCPage4Ptr->ActiveSEP++;
291 IOCPage4Ptr->SEP[ii].SEPTargetID = id;
292 IOCPage4Ptr->SEP[ii].SEPBus = channel;
293 pReq->Header = IOCPage4Ptr->Header;
294 pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
295
296 /* Add a SGE to the config request.
297 */
298 flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
299 (IOCPage4Ptr->Header.PageLength + ii) * 4;
300
301 mpt_add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
302
303 ddvprintk((MYIOC_s_INFO_FMT
304 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
305 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
306
307 mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
308
309 return 0;
310}
311
312/**
313 * mptspi_initTarget - Target, LUN alloc/free functionality.
314 * @hd: Pointer to MPT_SCSI_HOST structure
315 * @vtarget: per target private data
316 * @sdev: SCSI device
317 *
318 * NOTE: It's only SAFE to call this routine if data points to
319 * sane & valid STANDARD INQUIRY data!
320 *
321 * Allocate and initialize memory for this target.
322 * Save inquiry data.
323 *
324 **/
325static void
326mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
327 struct scsi_device *sdev)
328{
329
330 /* Is LUN supported? If so, upper 2 bits will be 0
331 * in first byte of inquiry data.
332 */
333 if (sdev->inq_periph_qual != 0)
334 return;
335
336 if (vtarget == NULL)
337 return;
338
339 vtarget->type = sdev->type;
340
341 if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
342 /* Treat all Processors as SAF-TE if
343 * command line option is set */
344 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
345 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
346 }else if ((sdev->type == TYPE_PROCESSOR) &&
347 !(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
348 if (sdev->inquiry_len > 49 ) {
349 if (sdev->inquiry[44] == 'S' &&
350 sdev->inquiry[45] == 'A' &&
351 sdev->inquiry[46] == 'F' &&
352 sdev->inquiry[47] == '-' &&
353 sdev->inquiry[48] == 'T' &&
354 sdev->inquiry[49] == 'E' ) {
355 vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
356 mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
357 }
358 }
359 }
360 mptspi_setTargetNegoParms(hd, vtarget, sdev);
361}
Eric Moore793955f2007-01-29 09:42:20 -0700362
363/**
364 * mptspi_is_raid - Determines whether target is belonging to volume
365 * @hd: Pointer to a SCSI HOST structure
366 * @id: target device id
367 *
368 * Return:
369 * non-zero = true
370 * zero = false
371 *
372 */
373static int
374mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
375{
376 int i, rc = 0;
377
378 if (!hd->ioc->raid_data.pIocPg2)
379 goto out;
380
381 if (!hd->ioc->raid_data.pIocPg2->NumActiveVolumes)
382 goto out;
383 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
384 if (hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
385 rc = 1;
386 goto out;
387 }
388 }
389
390 out:
391 return rc;
392}
393
James Bottomleyc92f2222006-03-01 09:02:49 -0600394static int mptspi_target_alloc(struct scsi_target *starget)
395{
396 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
397 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
Eric Moore793955f2007-01-29 09:42:20 -0700398 VirtTarget *vtarget;
James Bottomleyc92f2222006-03-01 09:02:49 -0600399
400 if (hd == NULL)
401 return -ENODEV;
402
Eric Moore793955f2007-01-29 09:42:20 -0700403 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
404 if (!vtarget)
405 return -ENOMEM;
James Bottomleyc92f2222006-03-01 09:02:49 -0600406
Eric Moore793955f2007-01-29 09:42:20 -0700407 vtarget->ioc_id = hd->ioc->id;
408 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
409 vtarget->id = (u8)starget->id;
410 vtarget->channel = (u8)starget->channel;
411 vtarget->starget = starget;
412 starget->hostdata = vtarget;
413
414 if (starget->channel == 1) {
415 if (mptscsih_is_phys_disk(hd->ioc, 0, starget->id) == 0)
416 return 0;
417 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
418 /* The real channel for this device is zero */
419 vtarget->channel = 0;
420 /* The actual physdisknum (for RAID passthrough) */
421 vtarget->id = mptscsih_raid_id_to_num(hd->ioc, 0,
422 starget->id);
423 }
424
425 if (starget->channel == 0 &&
426 mptspi_is_raid(hd, starget->id)) {
427 vtarget->raidVolume = 1;
428 ddvprintk((KERN_INFO
429 "RAID Volume @ channel=%d id=%d\n", starget->channel,
430 starget->id));
431 }
James Bottomleyc92f2222006-03-01 09:02:49 -0600432
433 if (hd->ioc->spi_data.nvram &&
434 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
435 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
436 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
437 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
438 } else {
439 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
440 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
441 }
442 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
443
444 spi_offset(starget) = 0;
445 mptspi_write_width(starget, 0);
446
447 return 0;
448}
449
Eric Moore793955f2007-01-29 09:42:20 -0700450void
451mptspi_target_destroy(struct scsi_target *starget)
452{
453 if (starget->hostdata)
454 kfree(starget->hostdata);
455 starget->hostdata = NULL;
456}
457
Eric Moore873c82e2007-01-29 09:44:06 -0700458/**
459 * mptspi_print_write_nego - negotiation parameters debug info that is being sent
460 * @hd: Pointer to a SCSI HOST structure
461 * @starget: SCSI target
462 * @ii: negotiation parameters
463 *
464 */
465static void
466mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
467{
468 ddvprintk((MYIOC_s_INFO_FMT "id=%d Requested = 0x%08x"
469 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
470 hd->ioc->name, starget->id, ii,
471 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
472 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
473 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
474 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
475 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
476 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
477 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
478 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
479 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
480 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
481}
482
483/**
484 * mptspi_print_read_nego - negotiation parameters debug info that is being read
485 * @hd: Pointer to a SCSI HOST structure
486 * @starget: SCSI target
487 * @ii: negotiation parameters
488 *
489 */
490static void
491mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
492{
493 ddvprintk((MYIOC_s_INFO_FMT "id=%d Read = 0x%08x"
494 " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
495 hd->ioc->name, starget->id, ii,
496 ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
497 ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
498 ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
499 ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
500 ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
501 ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
502 ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
503 ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
504 ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
505 ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
506}
507
James Bottomleyc92f2222006-03-01 09:02:49 -0600508static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
509 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
510{
511 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
512 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
513 struct _MPT_ADAPTER *ioc = hd->ioc;
514 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
515 dma_addr_t pg0_dma;
516 int size;
517 struct _x_config_parms cfg;
518 struct _CONFIG_PAGE_HEADER hdr;
519 int err = -EBUSY;
520
521 /* No SPI parameters for RAID devices */
522 if (starget->channel == 0 &&
Eric Moore793955f2007-01-29 09:42:20 -0700523 mptspi_is_raid(hd, starget->id))
James Bottomleyc92f2222006-03-01 09:02:49 -0600524 return -1;
525
526 size = ioc->spi_data.sdp0length * 4;
527 /*
528 if (ioc->spi_data.sdp0length & 1)
529 size += size + 4;
530 size += 2048;
531 */
532
533 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
534 if (pg0 == NULL) {
535 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
536 return -EINVAL;
537 }
538
539 memset(&hdr, 0, sizeof(hdr));
540
541 hdr.PageVersion = ioc->spi_data.sdp0version;
542 hdr.PageLength = ioc->spi_data.sdp0length;
543 hdr.PageNumber = 0;
544 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
545
546 memset(&cfg, 0, sizeof(cfg));
547
548 cfg.cfghdr.hdr = &hdr;
549 cfg.physAddr = pg0_dma;
550 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
551 cfg.dir = 0;
552 cfg.pageAddr = starget->id;
553
554 if (mpt_config(ioc, &cfg)) {
555 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
556 goto out_free;
557 }
558 err = 0;
559 memcpy(pass_pg0, pg0, size);
560
Eric Moore873c82e2007-01-29 09:44:06 -0700561 mptspi_print_read_nego(hd, starget, le32_to_cpu(pg0->NegotiatedParameters));
562
James Bottomleyc92f2222006-03-01 09:02:49 -0600563 out_free:
564 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
565 return err;
566}
567
568static u32 mptspi_getRP(struct scsi_target *starget)
569{
570 u32 nego = 0;
571
572 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
573 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
574 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
575 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
576 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
577 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
578 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
579 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
580
581 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
582 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
583 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
584
585 return nego;
586}
587
588static void mptspi_read_parameters(struct scsi_target *starget)
589{
590 int nego;
591 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
592
593 mptspi_read_spi_device_pg0(starget, &pg0);
594
595 nego = le32_to_cpu(pg0.NegotiatedParameters);
596
597 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
598 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
599 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
600 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
601 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
602 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
603 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
604 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
605 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
606 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
607 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
608}
609
610static int
Eric Moore793955f2007-01-29 09:42:20 -0700611mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
James Bottomleyc92f2222006-03-01 09:02:49 -0600612{
613 MpiRaidActionRequest_t *pReq;
614 MPT_FRAME_HDR *mf;
615
616 /* Get and Populate a free Frame
617 */
618 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
619 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
620 hd->ioc->name));
621 return -EAGAIN;
622 }
623 pReq = (MpiRaidActionRequest_t *)mf;
624 if (quiesce)
625 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
626 else
627 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
628 pReq->Reserved1 = 0;
629 pReq->ChainOffset = 0;
630 pReq->Function = MPI_FUNCTION_RAID_ACTION;
Eric Moore793955f2007-01-29 09:42:20 -0700631 pReq->VolumeID = id;
632 pReq->VolumeBus = channel;
James Bottomleyc92f2222006-03-01 09:02:49 -0600633 pReq->PhysDiskNum = 0;
634 pReq->MsgFlags = 0;
635 pReq->Reserved2 = 0;
636 pReq->ActionDataWord = 0; /* Reserved for this action */
637
638 mpt_add_sge((char *)&pReq->ActionDataSGE,
639 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
640
Eric Moore793955f2007-01-29 09:42:20 -0700641 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action=%x channel=%d id=%d\n",
642 hd->ioc->name, pReq->Action, channel, id));
James Bottomleyc92f2222006-03-01 09:02:49 -0600643
644 hd->pLocal = NULL;
645 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
646 hd->scandv_wait_done = 0;
647
648 /* Save cmd pointer, for resource free if timeout or
649 * FW reload occurs
650 */
651 hd->cmdPtr = mf;
652
653 add_timer(&hd->timer);
654 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
655 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
656
657 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
658 return -1;
659
660 return 0;
661}
662
663static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
664 struct scsi_device *sdev)
665{
666 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
667
668 /* no DV on RAID devices */
669 if (sdev->channel == 0 &&
Eric Moore793955f2007-01-29 09:42:20 -0700670 mptspi_is_raid(hd, sdev->id))
James Bottomleyc92f2222006-03-01 09:02:49 -0600671 return;
672
673 /* If this is a piece of a RAID, then quiesce first */
674 if (sdev->channel == 1 &&
Eric Moore793955f2007-01-29 09:42:20 -0700675 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
James Bottomleyc92f2222006-03-01 09:02:49 -0600676 starget_printk(KERN_ERR, scsi_target(sdev),
677 "Integrated RAID quiesce failed\n");
678 return;
679 }
680
681 spi_dv_device(sdev);
682
683 if (sdev->channel == 1 &&
Eric Moore793955f2007-01-29 09:42:20 -0700684 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
James Bottomleyc92f2222006-03-01 09:02:49 -0600685 starget_printk(KERN_ERR, scsi_target(sdev),
686 "Integrated RAID resume failed\n");
687
688 mptspi_read_parameters(sdev->sdev_target);
689 spi_display_xfer_agreement(sdev->sdev_target);
690 mptspi_read_parameters(sdev->sdev_target);
691}
692
693static int mptspi_slave_alloc(struct scsi_device *sdev)
694{
James Bottomleyc92f2222006-03-01 09:02:49 -0600695 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
Eric Moore793955f2007-01-29 09:42:20 -0700696 VirtTarget *vtarget;
697 VirtDevice *vdev;
698 struct scsi_target *starget;
James Bottomleyc92f2222006-03-01 09:02:49 -0600699
Eric Moore793955f2007-01-29 09:42:20 -0700700 if (sdev->channel == 1 &&
701 mptscsih_is_phys_disk(hd->ioc, 0, sdev->id) == 0)
702 return -ENXIO;
James Bottomleyc92f2222006-03-01 09:02:49 -0600703
Eric Moore793955f2007-01-29 09:42:20 -0700704 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
705 if (!vdev) {
706 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
707 hd->ioc->name, sizeof(VirtDevice));
708 return -ENOMEM;
James Bottomleyc92f2222006-03-01 09:02:49 -0600709 }
710
Eric Moore793955f2007-01-29 09:42:20 -0700711 vdev->lun = sdev->lun;
712 sdev->hostdata = vdev;
James Bottomleyc92f2222006-03-01 09:02:49 -0600713
Eric Moore793955f2007-01-29 09:42:20 -0700714 starget = scsi_target(sdev);
715 vtarget = starget->hostdata;
716 vdev->vtarget = vtarget;
717 vtarget->num_luns++;
James Bottomleyc92f2222006-03-01 09:02:49 -0600718
Eric Moore793955f2007-01-29 09:42:20 -0700719 if (sdev->channel == 1)
James Bottomleyc92f2222006-03-01 09:02:49 -0600720 sdev->no_uld_attach = 1;
James Bottomleyc92f2222006-03-01 09:02:49 -0600721
722 return 0;
723}
724
725static int mptspi_slave_configure(struct scsi_device *sdev)
726{
James Bottomleyc92f2222006-03-01 09:02:49 -0600727 struct _MPT_SCSI_HOST *hd =
728 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
Eric Moore5a9c47b2007-01-29 09:43:17 -0700729 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
730 int ret = mptscsih_slave_configure(sdev);
James Bottomleyc92f2222006-03-01 09:02:49 -0600731
732 if (ret)
733 return ret;
734
Eric Moore5a9c47b2007-01-29 09:43:17 -0700735 mptspi_initTarget(hd, vtarget, sdev);
736
Eric Moore873c82e2007-01-29 09:44:06 -0700737 ddvprintk((MYIOC_s_INFO_FMT "id=%d min_period=0x%02x"
738 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
739 sdev->id, spi_min_period(scsi_target(sdev)),
740 spi_max_offset(scsi_target(sdev)),
741 spi_max_width(scsi_target(sdev))));
742
James Bottomleyc92f2222006-03-01 09:02:49 -0600743 if ((sdev->channel == 1 ||
Eric Moore793955f2007-01-29 09:42:20 -0700744 !(mptspi_is_raid(hd, sdev->id))) &&
James Bottomleyc92f2222006-03-01 09:02:49 -0600745 !spi_initial_dv(sdev->sdev_target))
746 mptspi_dv_device(hd, sdev);
747
748 return 0;
749}
750
Eric Moore793955f2007-01-29 09:42:20 -0700751static int
752mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
753{
754 struct _MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *) SCpnt->device->host->hostdata;
755 VirtDevice *vdev = SCpnt->device->hostdata;
756
757 if (!vdev || !vdev->vtarget) {
758 SCpnt->result = DID_NO_CONNECT << 16;
759 done(SCpnt);
760 return 0;
761 }
762
763 if (SCpnt->device->channel == 1 &&
764 mptscsih_is_phys_disk(hd->ioc, 0, SCpnt->device->id) == 0) {
765 SCpnt->result = DID_NO_CONNECT << 16;
766 done(SCpnt);
767 return 0;
768 }
769
Eric Moore873c82e2007-01-29 09:44:06 -0700770#ifdef MPT_DEBUG_DV
771 if (spi_dv_pending(scsi_target(SCpnt->device)))
772 scsi_print_command(SCpnt);
773#endif
774
Eric Moore793955f2007-01-29 09:42:20 -0700775 return mptscsih_qcmd(SCpnt,done);
776}
777
James Bottomleyc92f2222006-03-01 09:02:49 -0600778static void mptspi_slave_destroy(struct scsi_device *sdev)
779{
780 struct scsi_target *starget = scsi_target(sdev);
781 VirtTarget *vtarget = starget->hostdata;
782 VirtDevice *vdevice = sdev->hostdata;
783
784 /* Will this be the last lun on a non-raid device? */
785 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
786 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
787
788 /* Async Narrow */
789 pg1.RequestedParameters = 0;
790 pg1.Reserved = 0;
791 pg1.Configuration = 0;
792
793 mptspi_write_spi_device_pg1(starget, &pg1);
794 }
795
796 mptscsih_slave_destroy(sdev);
797}
798
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -0400799static struct scsi_host_template mptspi_driver_template = {
Moore, Eric Deanf78496d2005-11-16 18:54:14 -0700800 .module = THIS_MODULE,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -0400801 .proc_name = "mptspi",
802 .proc_info = mptscsih_proc_info,
803 .name = "MPT SPI Host",
804 .info = mptscsih_info,
Eric Moore793955f2007-01-29 09:42:20 -0700805 .queuecommand = mptspi_qcmd,
James Bottomleyc92f2222006-03-01 09:02:49 -0600806 .target_alloc = mptspi_target_alloc,
807 .slave_alloc = mptspi_slave_alloc,
808 .slave_configure = mptspi_slave_configure,
Eric Moore793955f2007-01-29 09:42:20 -0700809 .target_destroy = mptspi_target_destroy,
James Bottomleyc92f2222006-03-01 09:02:49 -0600810 .slave_destroy = mptspi_slave_destroy,
Moore, Eric Dean6e3815b2005-06-24 12:18:57 -0600811 .change_queue_depth = mptscsih_change_queue_depth,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -0400812 .eh_abort_handler = mptscsih_abort,
813 .eh_device_reset_handler = mptscsih_dev_reset,
814 .eh_bus_reset_handler = mptscsih_bus_reset,
815 .eh_host_reset_handler = mptscsih_host_reset,
816 .bios_param = mptscsih_bios_param,
817 .can_queue = MPT_SCSI_CAN_QUEUE,
818 .this_id = -1,
819 .sg_tablesize = MPT_SCSI_SG_DEPTH,
820 .max_sectors = 8192,
821 .cmd_per_lun = 7,
822 .use_clustering = ENABLE_CLUSTERING,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -0400823};
824
James Bottomleyc92f2222006-03-01 09:02:49 -0600825static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
826 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
827{
828 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
829 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
830 struct _MPT_ADAPTER *ioc = hd->ioc;
831 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
832 dma_addr_t pg1_dma;
833 int size;
834 struct _x_config_parms cfg;
835 struct _CONFIG_PAGE_HEADER hdr;
836 int err = -EBUSY;
837
838 /* don't allow updating nego parameters on RAID devices */
839 if (starget->channel == 0 &&
Eric Moore793955f2007-01-29 09:42:20 -0700840 mptspi_is_raid(hd, starget->id))
James Bottomleyc92f2222006-03-01 09:02:49 -0600841 return -1;
842
843 size = ioc->spi_data.sdp1length * 4;
844
845 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
846 if (pg1 == NULL) {
847 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
848 return -EINVAL;
849 }
850
851 memset(&hdr, 0, sizeof(hdr));
852
853 hdr.PageVersion = ioc->spi_data.sdp1version;
854 hdr.PageLength = ioc->spi_data.sdp1length;
855 hdr.PageNumber = 1;
856 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
857
858 memset(&cfg, 0, sizeof(cfg));
859
860 cfg.cfghdr.hdr = &hdr;
861 cfg.physAddr = pg1_dma;
862 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
863 cfg.dir = 1;
864 cfg.pageAddr = starget->id;
865
866 memcpy(pg1, pass_pg1, size);
867
868 pg1->Header.PageVersion = hdr.PageVersion;
869 pg1->Header.PageLength = hdr.PageLength;
870 pg1->Header.PageNumber = hdr.PageNumber;
871 pg1->Header.PageType = hdr.PageType;
872
Eric Moore873c82e2007-01-29 09:44:06 -0700873 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
874
James Bottomleyc92f2222006-03-01 09:02:49 -0600875 if (mpt_config(ioc, &cfg)) {
876 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
877 goto out_free;
878 }
879 err = 0;
880
881 out_free:
882 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
883 return err;
884}
885
886static void mptspi_write_offset(struct scsi_target *starget, int offset)
887{
888 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
889 u32 nego;
890
891 if (offset < 0)
892 offset = 0;
893
894 if (offset > 255)
895 offset = 255;
896
897 if (spi_offset(starget) == -1)
898 mptspi_read_parameters(starget);
899
900 spi_offset(starget) = offset;
901
902 nego = mptspi_getRP(starget);
903
904 pg1.RequestedParameters = cpu_to_le32(nego);
905 pg1.Reserved = 0;
906 pg1.Configuration = 0;
907
908 mptspi_write_spi_device_pg1(starget, &pg1);
909}
910
911static void mptspi_write_period(struct scsi_target *starget, int period)
912{
913 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
914 u32 nego;
915
916 if (period < 8)
917 period = 8;
918
919 if (period > 255)
920 period = 255;
921
922 if (spi_period(starget) == -1)
923 mptspi_read_parameters(starget);
924
925 if (period == 8) {
926 spi_iu(starget) = 1;
927 spi_dt(starget) = 1;
928 } else if (period == 9) {
929 spi_dt(starget) = 1;
930 }
931
932 spi_period(starget) = period;
933
934 nego = mptspi_getRP(starget);
935
936 pg1.RequestedParameters = cpu_to_le32(nego);
937 pg1.Reserved = 0;
938 pg1.Configuration = 0;
939
940 mptspi_write_spi_device_pg1(starget, &pg1);
941}
942
943static void mptspi_write_dt(struct scsi_target *starget, int dt)
944{
945 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
946 u32 nego;
947
948 if (spi_period(starget) == -1)
949 mptspi_read_parameters(starget);
950
951 if (!dt && spi_period(starget) < 10)
952 spi_period(starget) = 10;
953
954 spi_dt(starget) = dt;
955
956 nego = mptspi_getRP(starget);
957
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_iu(struct scsi_target *starget, int iu)
967{
968 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
969 u32 nego;
970
971 if (spi_period(starget) == -1)
972 mptspi_read_parameters(starget);
973
974 if (!iu && spi_period(starget) < 9)
975 spi_period(starget) = 9;
976
977 spi_iu(starget) = iu;
978
979 nego = mptspi_getRP(starget);
980
981 pg1.RequestedParameters = cpu_to_le32(nego);
982 pg1.Reserved = 0;
983 pg1.Configuration = 0;
984
985 mptspi_write_spi_device_pg1(starget, &pg1);
986}
987
988#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
989static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
990{ \
991 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
992 u32 nego; \
993 \
994 spi_##parm(starget) = parm; \
995 \
996 nego = mptspi_getRP(starget); \
997 \
998 pg1.RequestedParameters = cpu_to_le32(nego); \
999 pg1.Reserved = 0; \
1000 pg1.Configuration = 0; \
1001 \
1002 mptspi_write_spi_device_pg1(starget, &pg1); \
1003}
1004
1005MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1006MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1007MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1008MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1009MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1010
1011static void mptspi_write_qas(struct scsi_target *starget, int qas)
1012{
1013 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1014 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1015 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
1016 VirtTarget *vtarget = starget->hostdata;
1017 u32 nego;
1018
1019 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1020 hd->ioc->spi_data.noQas)
1021 spi_qas(starget) = 0;
1022 else
1023 spi_qas(starget) = qas;
1024
1025 nego = mptspi_getRP(starget);
1026
1027 pg1.RequestedParameters = cpu_to_le32(nego);
1028 pg1.Reserved = 0;
1029 pg1.Configuration = 0;
1030
1031 mptspi_write_spi_device_pg1(starget, &pg1);
1032}
1033
1034static void mptspi_write_width(struct scsi_target *starget, int width)
1035{
1036 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1037 u32 nego;
1038
1039 if (!width) {
1040 spi_dt(starget) = 0;
1041 if (spi_period(starget) < 10)
1042 spi_period(starget) = 10;
1043 }
1044
1045 spi_width(starget) = width;
1046
1047 nego = mptspi_getRP(starget);
1048
1049 pg1.RequestedParameters = cpu_to_le32(nego);
1050 pg1.Reserved = 0;
1051 pg1.Configuration = 0;
1052
1053 mptspi_write_spi_device_pg1(starget, &pg1);
1054}
1055
1056struct work_queue_wrapper {
1057 struct work_struct work;
1058 struct _MPT_SCSI_HOST *hd;
1059 int disk;
1060};
1061
David Howellsc4028952006-11-22 14:57:56 +00001062static void mpt_work_wrapper(struct work_struct *work)
James Bottomleyc92f2222006-03-01 09:02:49 -06001063{
David Howellsc4028952006-11-22 14:57:56 +00001064 struct work_queue_wrapper *wqw =
1065 container_of(work, struct work_queue_wrapper, work);
James Bottomleyc92f2222006-03-01 09:02:49 -06001066 struct _MPT_SCSI_HOST *hd = wqw->hd;
1067 struct Scsi_Host *shost = hd->ioc->sh;
1068 struct scsi_device *sdev;
1069 int disk = wqw->disk;
1070 struct _CONFIG_PAGE_IOC_3 *pg3;
1071
1072 kfree(wqw);
1073
1074 mpt_findImVolumes(hd->ioc);
1075 pg3 = hd->ioc->raid_data.pIocPg3;
1076 if (!pg3)
1077 return;
1078
1079 shost_for_each_device(sdev,shost) {
1080 struct scsi_target *starget = scsi_target(sdev);
1081 VirtTarget *vtarget = starget->hostdata;
1082
1083 /* only want to search RAID components */
1084 if (sdev->channel != 1)
1085 continue;
1086
Eric Moore793955f2007-01-29 09:42:20 -07001087 /* The id is the raid PhysDiskNum, even if
James Bottomleyc92f2222006-03-01 09:02:49 -06001088 * starget->id is the actual target address */
Eric Moore793955f2007-01-29 09:42:20 -07001089 if(vtarget->id != disk)
James Bottomleyc92f2222006-03-01 09:02:49 -06001090 continue;
1091
1092 starget_printk(KERN_INFO, vtarget->starget,
1093 "Integrated RAID requests DV of new device\n");
1094 mptspi_dv_device(hd, sdev);
1095 }
1096 shost_printk(KERN_INFO, shost,
1097 "Integrated RAID detects new device %d\n", disk);
1098 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
1099}
1100
1101
1102static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1103{
1104 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1105
1106 if (!wqw) {
1107 shost_printk(KERN_ERR, hd->ioc->sh,
1108 "Failed to act on RAID event for physical disk %d\n",
1109 disk);
1110 return;
1111 }
David Howellsc4028952006-11-22 14:57:56 +00001112 INIT_WORK(&wqw->work, mpt_work_wrapper);
James Bottomleyc92f2222006-03-01 09:02:49 -06001113 wqw->hd = hd;
1114 wqw->disk = disk;
1115
1116 schedule_work(&wqw->work);
1117}
1118
1119static int
1120mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1121{
1122 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1123 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1124
1125 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1126 int reason
1127 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1128
1129 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1130 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1131 mpt_dv_raid(hd, disk);
1132 }
1133 }
1134 return mptscsih_event_process(ioc, pEvReply);
1135}
1136
1137static int
1138mptspi_deny_binding(struct scsi_target *starget)
1139{
1140 struct _MPT_SCSI_HOST *hd =
1141 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
Eric Moore793955f2007-01-29 09:42:20 -07001142 return ((mptspi_is_raid(hd, starget->id)) &&
James Bottomleyc92f2222006-03-01 09:02:49 -06001143 starget->channel == 0) ? 1 : 0;
1144}
1145
1146static struct spi_function_template mptspi_transport_functions = {
1147 .get_offset = mptspi_read_parameters,
1148 .set_offset = mptspi_write_offset,
1149 .show_offset = 1,
1150 .get_period = mptspi_read_parameters,
1151 .set_period = mptspi_write_period,
1152 .show_period = 1,
1153 .get_width = mptspi_read_parameters,
1154 .set_width = mptspi_write_width,
1155 .show_width = 1,
1156 .get_iu = mptspi_read_parameters,
1157 .set_iu = mptspi_write_iu,
1158 .show_iu = 1,
1159 .get_dt = mptspi_read_parameters,
1160 .set_dt = mptspi_write_dt,
1161 .show_dt = 1,
1162 .get_qas = mptspi_read_parameters,
1163 .set_qas = mptspi_write_qas,
1164 .show_qas = 1,
1165 .get_wr_flow = mptspi_read_parameters,
1166 .set_wr_flow = mptspi_write_wr_flow,
1167 .show_wr_flow = 1,
1168 .get_rd_strm = mptspi_read_parameters,
1169 .set_rd_strm = mptspi_write_rd_strm,
1170 .show_rd_strm = 1,
1171 .get_rti = mptspi_read_parameters,
1172 .set_rti = mptspi_write_rti,
1173 .show_rti = 1,
1174 .get_pcomp_en = mptspi_read_parameters,
1175 .set_pcomp_en = mptspi_write_pcomp_en,
1176 .show_pcomp_en = 1,
1177 .get_hold_mcs = mptspi_read_parameters,
1178 .set_hold_mcs = mptspi_write_hold_mcs,
1179 .show_hold_mcs = 1,
1180 .deny_binding = mptspi_deny_binding,
1181};
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001182
1183/****************************************************************************
1184 * Supported hardware
1185 */
1186
1187static struct pci_device_id mptspi_pci_table[] = {
Eric Moore87cf8982006-06-27 16:09:26 -06001188 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001189 PCI_ANY_ID, PCI_ANY_ID },
Eric Moore87cf8982006-06-27 16:09:26 -06001190 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001191 PCI_ANY_ID, PCI_ANY_ID },
1192 {0} /* Terminating entry */
1193};
1194MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1195
Eric Moore6e1cad02006-04-25 17:38:58 -06001196
1197/*
1198 * renegotiate for a given target
1199 */
1200static void
David Howellsc4028952006-11-22 14:57:56 +00001201mptspi_dv_renegotiate_work(struct work_struct *work)
Eric Moore6e1cad02006-04-25 17:38:58 -06001202{
David Howellsc4028952006-11-22 14:57:56 +00001203 struct work_queue_wrapper *wqw =
1204 container_of(work, struct work_queue_wrapper, work);
Eric Moore6e1cad02006-04-25 17:38:58 -06001205 struct _MPT_SCSI_HOST *hd = wqw->hd;
1206 struct scsi_device *sdev;
1207
1208 kfree(wqw);
1209
1210 shost_for_each_device(sdev, hd->ioc->sh)
1211 mptspi_dv_device(hd, sdev);
1212}
1213
1214static void
1215mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1216{
1217 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1218
1219 if (!wqw)
1220 return;
1221
David Howellsc4028952006-11-22 14:57:56 +00001222 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
Eric Moore6e1cad02006-04-25 17:38:58 -06001223 wqw->hd = hd;
1224
1225 schedule_work(&wqw->work);
1226}
1227
1228/*
1229 * spi module reset handler
1230 */
1231static int
1232mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1233{
1234 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1235 int rc;
1236
1237 rc = mptscsih_ioc_reset(ioc, reset_phase);
1238
1239 if (reset_phase == MPT_IOC_POST_RESET)
1240 mptspi_dv_renegotiate(hd);
1241
1242 return rc;
1243}
1244
Tom "spot" Callawayc29ca9d2006-06-09 17:01:48 -07001245#ifdef CONFIG_PM
Eric Moore6e1cad02006-04-25 17:38:58 -06001246/*
1247 * spi module resume handler
1248 */
1249static int
1250mptspi_resume(struct pci_dev *pdev)
1251{
1252 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1253 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
1254 int rc;
1255
1256 rc = mptscsih_resume(pdev);
1257 mptspi_dv_renegotiate(hd);
1258
1259 return rc;
1260}
Tom "spot" Callawayc29ca9d2006-06-09 17:01:48 -07001261#endif
Eric Moore6e1cad02006-04-25 17:38:58 -06001262
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001263/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1264/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1265/*
1266 * mptspi_probe - Installs scsi devices per bus.
1267 * @pdev: Pointer to pci_dev structure
1268 *
1269 * Returns 0 for success, non-zero for failure.
1270 *
1271 */
1272static int
1273mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1274{
1275 struct Scsi_Host *sh;
1276 MPT_SCSI_HOST *hd;
1277 MPT_ADAPTER *ioc;
1278 unsigned long flags;
Christoph Hellwig1ca00bb2006-01-13 18:27:50 +01001279 int ii;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001280 int numSGE = 0;
1281 int scale;
1282 int ioc_cap;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001283 int error=0;
1284 int r;
Christoph Hellwigc6678e02005-08-18 16:24:53 +02001285
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001286 if ((r = mpt_attach(pdev,id)) != 0)
1287 return r;
Christoph Hellwigc6678e02005-08-18 16:24:53 +02001288
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001289 ioc = pci_get_drvdata(pdev);
Moore, Eric Dean d335cc32005-04-30 17:09:38 -05001290 ioc->DoneCtx = mptspiDoneCtx;
1291 ioc->TaskCtx = mptspiTaskCtx;
1292 ioc->InternalCtx = mptspiInternalCtx;
Christoph Hellwigc6678e02005-08-18 16:24:53 +02001293
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001294 /* Added sanity check on readiness of the MPT adapter.
1295 */
1296 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1297 printk(MYIOC_s_WARN_FMT
1298 "Skipping because it's not operational!\n",
1299 ioc->name);
Moore, Eric Dean7acec1e2005-11-16 18:54:17 -07001300 error = -ENODEV;
1301 goto out_mptspi_probe;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001302 }
1303
1304 if (!ioc->active) {
1305 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1306 ioc->name);
Moore, Eric Dean7acec1e2005-11-16 18:54:17 -07001307 error = -ENODEV;
1308 goto out_mptspi_probe;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001309 }
1310
1311 /* Sanity check - ensure at least 1 port is INITIATOR capable
1312 */
1313 ioc_cap = 0;
1314 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1315 if (ioc->pfacts[ii].ProtocolFlags &
1316 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1317 ioc_cap ++;
1318 }
1319
1320 if (!ioc_cap) {
1321 printk(MYIOC_s_WARN_FMT
1322 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1323 ioc->name, ioc);
Moore, Eric Dean466544d2005-09-14 18:09:10 -06001324 return 0;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001325 }
1326
1327 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1328
1329 if (!sh) {
1330 printk(MYIOC_s_WARN_FMT
1331 "Unable to register controller with SCSI subsystem\n",
1332 ioc->name);
Moore, Eric Dean7acec1e2005-11-16 18:54:17 -07001333 error = -1;
1334 goto out_mptspi_probe;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001335 }
1336
1337 spin_lock_irqsave(&ioc->FreeQlock, flags);
1338
1339 /* Attach the SCSI Host to the IOC structure
1340 */
1341 ioc->sh = sh;
1342
1343 sh->io_port = 0;
1344 sh->n_io_port = 0;
1345 sh->irq = 0;
1346
1347 /* set 16 byte cdb's */
1348 sh->max_cmd_len = 16;
1349
1350 /* Yikes! This is important!
1351 * Otherwise, by default, linux
1352 * only scans target IDs 0-7!
1353 * pfactsN->MaxDevices unreliable
1354 * (not supported in early
1355 * versions of the FW).
1356 * max_id = 1 + actual max id,
1357 * max_lun = 1 + actual last lun,
1358 * see hosts.h :o(
1359 */
Eric Moore793955f2007-01-29 09:42:20 -07001360 sh->max_id = ioc->devices_per_bus;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001361
1362 sh->max_lun = MPT_LAST_LUN + 1;
James Bottomleyc92f2222006-03-01 09:02:49 -06001363 /*
1364 * If RAID Firmware Detected, setup virtual channel
1365 */
Eric Mooreb506ade2007-01-29 09:45:37 -07001366 if (ioc->ir_firmware)
James Bottomleyc92f2222006-03-01 09:02:49 -06001367 sh->max_channel = 1;
1368 else
1369 sh->max_channel = 0;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001370 sh->this_id = ioc->pfacts[0].PortSCSIID;
1371
1372 /* Required entry.
1373 */
1374 sh->unique_id = ioc->id;
1375
1376 /* Verify that we won't exceed the maximum
1377 * number of chain buffers
1378 * We can optimize: ZZ = req_sz/sizeof(SGE)
1379 * For 32bit SGE's:
1380 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1381 * + (req_sz - 64)/sizeof(SGE)
1382 * A slightly different algorithm is required for
1383 * 64bit SGEs.
1384 */
1385 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
1386 if (sizeof(dma_addr_t) == sizeof(u64)) {
1387 numSGE = (scale - 1) *
1388 (ioc->facts.MaxChainDepth-1) + scale +
1389 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
1390 sizeof(u32));
1391 } else {
1392 numSGE = 1 + (scale - 1) *
1393 (ioc->facts.MaxChainDepth-1) + scale +
1394 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
1395 sizeof(u32));
1396 }
1397
1398 if (numSGE < sh->sg_tablesize) {
1399 /* Reset this value */
1400 dprintk((MYIOC_s_INFO_FMT
1401 "Resetting sg_tablesize to %d from %d\n",
1402 ioc->name, numSGE, sh->sg_tablesize));
1403 sh->sg_tablesize = numSGE;
1404 }
1405
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001406 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1407
1408 hd = (MPT_SCSI_HOST *) sh->hostdata;
1409 hd->ioc = ioc;
1410
1411 /* SCSI needs scsi_cmnd lookup table!
1412 * (with size equal to req_depth*PtrSz!)
1413 */
Christoph Hellwig1ca00bb2006-01-13 18:27:50 +01001414 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1415 if (!hd->ScsiLookup) {
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001416 error = -ENOMEM;
Moore, Eric Dean7acec1e2005-11-16 18:54:17 -07001417 goto out_mptspi_probe;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001418 }
1419
Christoph Hellwig1ca00bb2006-01-13 18:27:50 +01001420 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1421 ioc->name, hd->ScsiLookup));
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001422
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001423 /* Clear the TM flags
1424 */
1425 hd->tmPending = 0;
1426 hd->tmState = TM_STATE_NONE;
1427 hd->resetPending = 0;
1428 hd->abortSCpnt = NULL;
1429
1430 /* Clear the pointer used to store
1431 * single-threaded commands, i.e., those
1432 * issued during a bus scan, dv and
1433 * configuration pages.
1434 */
1435 hd->cmdPtr = NULL;
1436
1437 /* Initialize this SCSI Hosts' timers
1438 * To use, set the timer expires field
1439 * and add_timer
1440 */
1441 init_timer(&hd->timer);
1442 hd->timer.data = (unsigned long) hd;
1443 hd->timer.function = mptscsih_timer_expired;
1444
1445 ioc->spi_data.Saf_Te = mpt_saf_te;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001446
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001447 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1448 ddvprintk((MYIOC_s_INFO_FMT
Eric Mooreba856d32006-07-11 17:34:01 -06001449 "saf_te %x\n",
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001450 ioc->name,
Eric Mooreba856d32006-07-11 17:34:01 -06001451 mpt_saf_te));
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001452 ioc->spi_data.noQas = 0;
1453
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001454 init_waitqueue_head(&hd->scandv_waitq);
1455 hd->scandv_wait_done = 0;
1456 hd->last_queue_full = 0;
1457
James Bottomleyc92f2222006-03-01 09:02:49 -06001458 /* Some versions of the firmware don't support page 0; without
1459 * that we can't get the parameters */
1460 if (hd->ioc->spi_data.sdp0length != 0)
1461 sh->transportt = mptspi_transport_template;
1462
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001463 error = scsi_add_host (sh, &ioc->pcidev->dev);
1464 if(error) {
1465 dprintk((KERN_ERR MYNAM
1466 "scsi_add_host failed\n"));
Moore, Eric Dean7acec1e2005-11-16 18:54:17 -07001467 goto out_mptspi_probe;
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001468 }
1469
Moore, Ericd8e925d2006-01-16 18:53:06 -07001470 /*
1471 * issue internal bus reset
1472 */
1473 if (ioc->spi_data.bus_reset)
1474 mptscsih_TMHandler(hd,
1475 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1476 0, 0, 0, 0, 5);
1477
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001478 scsi_scan_host(sh);
1479 return 0;
1480
Moore, Eric Dean7acec1e2005-11-16 18:54:17 -07001481out_mptspi_probe:
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001482
1483 mptscsih_remove(pdev);
1484 return error;
1485}
1486
1487static struct pci_driver mptspi_driver = {
1488 .name = "mptspi",
1489 .id_table = mptspi_pci_table,
1490 .probe = mptspi_probe,
1491 .remove = __devexit_p(mptscsih_remove),
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001492 .shutdown = mptscsih_shutdown,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001493#ifdef CONFIG_PM
1494 .suspend = mptscsih_suspend,
Eric Moore6e1cad02006-04-25 17:38:58 -06001495 .resume = mptspi_resume,
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001496#endif
1497};
1498
1499/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1500/**
Randy Dunlapd9489fb2006-12-06 20:38:43 -08001501 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001502 *
1503 * Returns 0 for success, non-zero for failure.
1504 */
1505static int __init
1506mptspi_init(void)
1507{
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001508 show_mptmod_ver(my_NAME, my_VERSION);
1509
James Bottomleyc92f2222006-03-01 09:02:49 -06001510 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1511 if (!mptspi_transport_template)
1512 return -ENODEV;
1513
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001514 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1515 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1516 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1517
James Bottomleyc92f2222006-03-01 09:02:49 -06001518 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
Moore, Eric3a892be2006-03-14 09:14:03 -07001519 devtverboseprintk((KERN_INFO MYNAM
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001520 ": Registered for IOC event notifications\n"));
1521 }
1522
Eric Moore6e1cad02006-04-25 17:38:58 -06001523 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001524 dprintk((KERN_INFO MYNAM
1525 ": Registered for IOC reset notifications\n"));
1526 }
1527
1528 return pci_register_driver(&mptspi_driver);
1529}
1530
1531/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1532/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1533/**
1534 * mptspi_exit - Unregisters MPT adapter(s)
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001535 */
1536static void __exit
1537mptspi_exit(void)
1538{
1539 pci_unregister_driver(&mptspi_driver);
Moore, Ericd8e925d2006-01-16 18:53:06 -07001540
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001541 mpt_reset_deregister(mptspiDoneCtx);
1542 dprintk((KERN_INFO MYNAM
1543 ": Deregistered for IOC reset notifications\n"));
1544
1545 mpt_event_deregister(mptspiDoneCtx);
1546 dprintk((KERN_INFO MYNAM
1547 ": Deregistered for IOC event notifications\n"));
1548
1549 mpt_deregister(mptspiInternalCtx);
1550 mpt_deregister(mptspiTaskCtx);
1551 mpt_deregister(mptspiDoneCtx);
James Bottomleyc92f2222006-03-01 09:02:49 -06001552 spi_release_transport(mptspi_transport_template);
Moore, Eric Dean 243eabc2005-04-22 18:02:25 -04001553}
1554
1555module_init(mptspi_init);
1556module_exit(mptspi_exit);