]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/message/fusion/mptspi.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] fusion: power pc and miscellaneous bug fixs
[mirror_ubuntu-zesty-kernel.git] / drivers / message / fusion / mptspi.c
CommitLineData
243eabcf
MED		 1/*
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 *
6 * Copyright (c) 1999-2005 LSI Logic Corporation
7 * (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>
c92f222e 59#include <linux/raid_class.h>
243eabcf
MED		 60
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>
c92f222e
JB		 66#include <scsi/scsi_transport.h>
67#include <scsi/scsi_transport_spi.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");
80
81/* Command line args */
243eabcf
MED		 82static int mpt_saf_te = MPTSCSIH_SAF_TE;
83module_param(mpt_saf_te, int, 0);
84MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
85
c92f222e
JB		 86static void mptspi_write_offset(struct scsi_target *, int);
87static void mptspi_write_width(struct scsi_target *, int);
88static int mptspi_write_spi_device_pg1(struct scsi_target *,
89 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
90
91static struct scsi_transport_template *mptspi_transport_template = NULL;
92
243eabcf
MED		 93static int mptspiDoneCtx = -1;
94static int mptspiTaskCtx = -1;
95static int mptspiInternalCtx = -1; /* Used only for internal commands */
96
c92f222e
JB		 97static int mptspi_target_alloc(struct scsi_target *starget)
98{
99 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
100 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
101 int ret;
102
103 if (hd == NULL)
104 return -ENODEV;
105
106 ret = mptscsih_target_alloc(starget);
107 if (ret)
108 return ret;
109
110 /* if we're a device on virtual channel 1 and we're not part
111 * of an array, just return here (otherwise the setup below
112 * may actually affect a real physical device on channel 0 */
113 if (starget->channel == 1 &&
114 mptscsih_raid_id_to_num(hd, starget->id) < 0)
115 return 0;
116
117 if (hd->ioc->spi_data.nvram &&
118 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
119 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
120 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
121 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
122 } else {
123 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
124 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
125 }
126 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
127
128 spi_offset(starget) = 0;
129 mptspi_write_width(starget, 0);
130
131 return 0;
132}
133
134static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
135 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
136{
137 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
138 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
139 struct _MPT_ADAPTER *ioc = hd->ioc;
140 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
141 dma_addr_t pg0_dma;
142 int size;
143 struct _x_config_parms cfg;
144 struct _CONFIG_PAGE_HEADER hdr;
145 int err = -EBUSY;
146
147 /* No SPI parameters for RAID devices */
148 if (starget->channel == 0 &&
149 (hd->ioc->raid_data.isRaid & (1 << starget->id)))
150 return -1;
151
152 size = ioc->spi_data.sdp0length * 4;
153 /*
154 if (ioc->spi_data.sdp0length & 1)
155 size += size + 4;
156 size += 2048;
157 */
158
159 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
160 if (pg0 == NULL) {
161 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
162 return -EINVAL;
163 }
164
165 memset(&hdr, 0, sizeof(hdr));
166
167 hdr.PageVersion = ioc->spi_data.sdp0version;
168 hdr.PageLength = ioc->spi_data.sdp0length;
169 hdr.PageNumber = 0;
170 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
171
172 memset(&cfg, 0, sizeof(cfg));
173
174 cfg.cfghdr.hdr = &hdr;
175 cfg.physAddr = pg0_dma;
176 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
177 cfg.dir = 0;
178 cfg.pageAddr = starget->id;
179
180 if (mpt_config(ioc, &cfg)) {
181 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
182 goto out_free;
183 }
184 err = 0;
185 memcpy(pass_pg0, pg0, size);
186
187 out_free:
188 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
189 return err;
190}
191
192static u32 mptspi_getRP(struct scsi_target *starget)
193{
194 u32 nego = 0;
195
196 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
197 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
198 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
199 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
200 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
201 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
202 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
203 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
204
205 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
206 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
207 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
208
209 return nego;
210}
211
212static void mptspi_read_parameters(struct scsi_target *starget)
213{
214 int nego;
215 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
216
217 mptspi_read_spi_device_pg0(starget, &pg0);
218
219 nego = le32_to_cpu(pg0.NegotiatedParameters);
220
221 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
222 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
223 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
224 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
225 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
226 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
227 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
228 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
229 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
230 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
231 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
232}
233
234static int
235mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, int disk)
236{
237 MpiRaidActionRequest_t *pReq;
238 MPT_FRAME_HDR *mf;
239
240 /* Get and Populate a free Frame
241 */
242 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
243 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
244 hd->ioc->name));
245 return -EAGAIN;
246 }
247 pReq = (MpiRaidActionRequest_t *)mf;
248 if (quiesce)
249 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
250 else
251 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
252 pReq->Reserved1 = 0;
253 pReq->ChainOffset = 0;
254 pReq->Function = MPI_FUNCTION_RAID_ACTION;
255 pReq->VolumeID = disk;
256 pReq->VolumeBus = 0;
257 pReq->PhysDiskNum = 0;
258 pReq->MsgFlags = 0;
259 pReq->Reserved2 = 0;
260 pReq->ActionDataWord = 0; /* Reserved for this action */
261
262 mpt_add_sge((char *)&pReq->ActionDataSGE,
263 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
264
265 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action %x id %d\n",
266 hd->ioc->name, action, io->id));
267
268 hd->pLocal = NULL;
269 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
270 hd->scandv_wait_done = 0;
271
272 /* Save cmd pointer, for resource free if timeout or
273 * FW reload occurs
274 */
275 hd->cmdPtr = mf;
276
277 add_timer(&hd->timer);
278 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
279 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
280
281 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
282 return -1;
283
284 return 0;
285}
286
287static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
288 struct scsi_device *sdev)
289{
290 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
291
292 /* no DV on RAID devices */
293 if (sdev->channel == 0 &&
294 (hd->ioc->raid_data.isRaid & (1 << sdev->id)))
295 return;
296
297 /* If this is a piece of a RAID, then quiesce first */
298 if (sdev->channel == 1 &&
299 mptscsih_quiesce_raid(hd, 1, vtarget->target_id) < 0) {
300 starget_printk(KERN_ERR, scsi_target(sdev),
301 "Integrated RAID quiesce failed\n");
302 return;
303 }
304
305 spi_dv_device(sdev);
306
307 if (sdev->channel == 1 &&
308 mptscsih_quiesce_raid(hd, 0, vtarget->target_id) < 0)
309 starget_printk(KERN_ERR, scsi_target(sdev),
310 "Integrated RAID resume failed\n");
311
312 mptspi_read_parameters(sdev->sdev_target);
313 spi_display_xfer_agreement(sdev->sdev_target);
314 mptspi_read_parameters(sdev->sdev_target);
315}
316
317static int mptspi_slave_alloc(struct scsi_device *sdev)
318{
319 int ret;
320 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
321 /* gcc doesn't see that all uses of this variable occur within
322 * the if() statements, so stop it from whining */
323 int physdisknum = 0;
324
325 if (sdev->channel == 1) {
326 physdisknum = mptscsih_raid_id_to_num(hd, sdev->id);
327
328 if (physdisknum < 0)
329 return physdisknum;
330 }
331
332 ret = mptscsih_slave_alloc(sdev);
333
334 if (ret)
335 return ret;
336
337 if (sdev->channel == 1) {
338 VirtDevice *vdev = sdev->hostdata;
339 sdev->no_uld_attach = 1;
340 vdev->vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
341 /* The real channel for this device is zero */
914c2d8e 342 vdev->vtarget->bus_id = 0;
c92f222e 343 /* The actual physdisknum (for RAID passthrough) */
914c2d8e 344 vdev->vtarget->target_id = physdisknum;
c92f222e
JB		 345 }
346
347 return 0;
348}
349
350static int mptspi_slave_configure(struct scsi_device *sdev)
351{
352 int ret = mptscsih_slave_configure(sdev);
353 struct _MPT_SCSI_HOST *hd =
354 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
355
356 if (ret)
357 return ret;
358
359 if ((sdev->channel == 1 ||
360 !(hd->ioc->raid_data.isRaid & (1 << sdev->id))) &&
361 !spi_initial_dv(sdev->sdev_target))
362 mptspi_dv_device(hd, sdev);
363
364 return 0;
365}
366
367static void mptspi_slave_destroy(struct scsi_device *sdev)
368{
369 struct scsi_target *starget = scsi_target(sdev);
370 VirtTarget *vtarget = starget->hostdata;
371 VirtDevice *vdevice = sdev->hostdata;
372
373 /* Will this be the last lun on a non-raid device? */
374 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
375 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
376
377 /* Async Narrow */
378 pg1.RequestedParameters = 0;
379 pg1.Reserved = 0;
380 pg1.Configuration = 0;
381
382 mptspi_write_spi_device_pg1(starget, &pg1);
383 }
384
385 mptscsih_slave_destroy(sdev);
386}
387
243eabcf 388static struct scsi_host_template mptspi_driver_template = {
f78496da 389 .module = THIS_MODULE,
243eabcf
MED		 390 .proc_name = "mptspi",
391 .proc_info = mptscsih_proc_info,
392 .name = "MPT SPI Host",
393 .info = mptscsih_info,
394 .queuecommand = mptscsih_qcmd,
c92f222e
JB		 395 .target_alloc = mptspi_target_alloc,
396 .slave_alloc = mptspi_slave_alloc,
397 .slave_configure = mptspi_slave_configure,
c7c82987 398 .target_destroy = mptscsih_target_destroy,
c92f222e 399 .slave_destroy = mptspi_slave_destroy,
6e3815ba 400 .change_queue_depth = mptscsih_change_queue_depth,
243eabcf
MED		 401 .eh_abort_handler = mptscsih_abort,
402 .eh_device_reset_handler = mptscsih_dev_reset,
403 .eh_bus_reset_handler = mptscsih_bus_reset,
404 .eh_host_reset_handler = mptscsih_host_reset,
405 .bios_param = mptscsih_bios_param,
406 .can_queue = MPT_SCSI_CAN_QUEUE,
407 .this_id = -1,
408 .sg_tablesize = MPT_SCSI_SG_DEPTH,
409 .max_sectors = 8192,
410 .cmd_per_lun = 7,
411 .use_clustering = ENABLE_CLUSTERING,
243eabcf
MED		 412};
413
c92f222e
JB		 414static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
415 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
416{
417 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
418 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
419 struct _MPT_ADAPTER *ioc = hd->ioc;
420 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
421 dma_addr_t pg1_dma;
422 int size;
423 struct _x_config_parms cfg;
424 struct _CONFIG_PAGE_HEADER hdr;
425 int err = -EBUSY;
426
427 /* don't allow updating nego parameters on RAID devices */
428 if (starget->channel == 0 &&
429 (hd->ioc->raid_data.isRaid & (1 << starget->id)))
430 return -1;
431
432 size = ioc->spi_data.sdp1length * 4;
433
434 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
435 if (pg1 == NULL) {
436 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
437 return -EINVAL;
438 }
439
440 memset(&hdr, 0, sizeof(hdr));
441
442 hdr.PageVersion = ioc->spi_data.sdp1version;
443 hdr.PageLength = ioc->spi_data.sdp1length;
444 hdr.PageNumber = 1;
445 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
446
447 memset(&cfg, 0, sizeof(cfg));
448
449 cfg.cfghdr.hdr = &hdr;
450 cfg.physAddr = pg1_dma;
451 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
452 cfg.dir = 1;
453 cfg.pageAddr = starget->id;
454
455 memcpy(pg1, pass_pg1, size);
456
457 pg1->Header.PageVersion = hdr.PageVersion;
458 pg1->Header.PageLength = hdr.PageLength;
459 pg1->Header.PageNumber = hdr.PageNumber;
460 pg1->Header.PageType = hdr.PageType;
461
462 if (mpt_config(ioc, &cfg)) {
463 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
464 goto out_free;
465 }
466 err = 0;
467
468 out_free:
469 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
470 return err;
471}
472
473static void mptspi_write_offset(struct scsi_target *starget, int offset)
474{
475 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
476 u32 nego;
477
478 if (offset < 0)
479 offset = 0;
480
481 if (offset > 255)
482 offset = 255;
483
484 if (spi_offset(starget) == -1)
485 mptspi_read_parameters(starget);
486
487 spi_offset(starget) = offset;
488
489 nego = mptspi_getRP(starget);
490
491 pg1.RequestedParameters = cpu_to_le32(nego);
492 pg1.Reserved = 0;
493 pg1.Configuration = 0;
494
495 mptspi_write_spi_device_pg1(starget, &pg1);
496}
497
498static void mptspi_write_period(struct scsi_target *starget, int period)
499{
500 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
501 u32 nego;
502
503 if (period < 8)
504 period = 8;
505
506 if (period > 255)
507 period = 255;
508
509 if (spi_period(starget) == -1)
510 mptspi_read_parameters(starget);
511
512 if (period == 8) {
513 spi_iu(starget) = 1;
514 spi_dt(starget) = 1;
515 } else if (period == 9) {
516 spi_dt(starget) = 1;
517 }
518
519 spi_period(starget) = period;
520
521 nego = mptspi_getRP(starget);
522
523 pg1.RequestedParameters = cpu_to_le32(nego);
524 pg1.Reserved = 0;
525 pg1.Configuration = 0;
526
527 mptspi_write_spi_device_pg1(starget, &pg1);
528}
529
530static void mptspi_write_dt(struct scsi_target *starget, int dt)
531{
532 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
533 u32 nego;
534
535 if (spi_period(starget) == -1)
536 mptspi_read_parameters(starget);
537
538 if (!dt && spi_period(starget) < 10)
539 spi_period(starget) = 10;
540
541 spi_dt(starget) = dt;
542
543 nego = mptspi_getRP(starget);
544
545
546 pg1.RequestedParameters = cpu_to_le32(nego);
547 pg1.Reserved = 0;
548 pg1.Configuration = 0;
549
550 mptspi_write_spi_device_pg1(starget, &pg1);
551}
552
553static void mptspi_write_iu(struct scsi_target *starget, int iu)
554{
555 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
556 u32 nego;
557
558 if (spi_period(starget) == -1)
559 mptspi_read_parameters(starget);
560
561 if (!iu && spi_period(starget) < 9)
562 spi_period(starget) = 9;
563
564 spi_iu(starget) = iu;
565
566 nego = mptspi_getRP(starget);
567
568 pg1.RequestedParameters = cpu_to_le32(nego);
569 pg1.Reserved = 0;
570 pg1.Configuration = 0;
571
572 mptspi_write_spi_device_pg1(starget, &pg1);
573}
574
575#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
576static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
577{ \
578 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
579 u32 nego; \
580 \
581 spi_##parm(starget) = parm; \
582 \
583 nego = mptspi_getRP(starget); \
584 \
585 pg1.RequestedParameters = cpu_to_le32(nego); \
586 pg1.Reserved = 0; \
587 pg1.Configuration = 0; \
588 \
589 mptspi_write_spi_device_pg1(starget, &pg1); \
590}
591
592MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
593MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
594MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
595MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
596MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
597
598static void mptspi_write_qas(struct scsi_target *starget, int qas)
599{
600 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
601 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
602 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
603 VirtTarget *vtarget = starget->hostdata;
604 u32 nego;
605
606 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
607 hd->ioc->spi_data.noQas)
608 spi_qas(starget) = 0;
609 else
610 spi_qas(starget) = qas;
611
612 nego = mptspi_getRP(starget);
613
614 pg1.RequestedParameters = cpu_to_le32(nego);
615 pg1.Reserved = 0;
616 pg1.Configuration = 0;
617
618 mptspi_write_spi_device_pg1(starget, &pg1);
619}
620
621static void mptspi_write_width(struct scsi_target *starget, int width)
622{
623 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
624 u32 nego;
625
626 if (!width) {
627 spi_dt(starget) = 0;
628 if (spi_period(starget) < 10)
629 spi_period(starget) = 10;
630 }
631
632 spi_width(starget) = width;
633
634 nego = mptspi_getRP(starget);
635
636 pg1.RequestedParameters = cpu_to_le32(nego);
637 pg1.Reserved = 0;
638 pg1.Configuration = 0;
639
640 mptspi_write_spi_device_pg1(starget, &pg1);
641}
642
643struct work_queue_wrapper {
644 struct work_struct work;
645 struct _MPT_SCSI_HOST *hd;
646 int disk;
647};
648
c4028958 649static void mpt_work_wrapper(struct work_struct *work)
c92f222e 650{
c4028958
DH		 651 struct work_queue_wrapper *wqw =
652 container_of(work, struct work_queue_wrapper, work);
c92f222e
JB		 653 struct _MPT_SCSI_HOST *hd = wqw->hd;
654 struct Scsi_Host *shost = hd->ioc->sh;
655 struct scsi_device *sdev;
656 int disk = wqw->disk;
657 struct _CONFIG_PAGE_IOC_3 *pg3;
658
659 kfree(wqw);
660
661 mpt_findImVolumes(hd->ioc);
662 pg3 = hd->ioc->raid_data.pIocPg3;
663 if (!pg3)
664 return;
665
666 shost_for_each_device(sdev,shost) {
667 struct scsi_target *starget = scsi_target(sdev);
668 VirtTarget *vtarget = starget->hostdata;
669
670 /* only want to search RAID components */
671 if (sdev->channel != 1)
672 continue;
673
674 /* The target_id is the raid PhysDiskNum, even if
675 * starget->id is the actual target address */
676 if(vtarget->target_id != disk)
677 continue;
678
679 starget_printk(KERN_INFO, vtarget->starget,
680 "Integrated RAID requests DV of new device\n");
681 mptspi_dv_device(hd, sdev);
682 }
683 shost_printk(KERN_INFO, shost,
684 "Integrated RAID detects new device %d\n", disk);
685 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
686}
687
688
689static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
690{
691 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
692
693 if (!wqw) {
694 shost_printk(KERN_ERR, hd->ioc->sh,
695 "Failed to act on RAID event for physical disk %d\n",
696 disk);
697 return;
698 }
c4028958 699 INIT_WORK(&wqw->work, mpt_work_wrapper);
c92f222e
JB		 700 wqw->hd = hd;
701 wqw->disk = disk;
702
703 schedule_work(&wqw->work);
704}
705
706static int
707mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
708{
709 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
710 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
711
712 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
713 int reason
714 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
715
716 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
717 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
718 mpt_dv_raid(hd, disk);
719 }
720 }
721 return mptscsih_event_process(ioc, pEvReply);
722}
723
724static int
725mptspi_deny_binding(struct scsi_target *starget)
726{
727 struct _MPT_SCSI_HOST *hd =
728 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
729 return ((hd->ioc->raid_data.isRaid & (1 << starget->id)) &&
730 starget->channel == 0) ? 1 : 0;
731}
732
733static struct spi_function_template mptspi_transport_functions = {
734 .get_offset = mptspi_read_parameters,
735 .set_offset = mptspi_write_offset,
736 .show_offset = 1,
737 .get_period = mptspi_read_parameters,
738 .set_period = mptspi_write_period,
739 .show_period = 1,
740 .get_width = mptspi_read_parameters,
741 .set_width = mptspi_write_width,
742 .show_width = 1,
743 .get_iu = mptspi_read_parameters,
744 .set_iu = mptspi_write_iu,
745 .show_iu = 1,
746 .get_dt = mptspi_read_parameters,
747 .set_dt = mptspi_write_dt,
748 .show_dt = 1,
749 .get_qas = mptspi_read_parameters,
750 .set_qas = mptspi_write_qas,
751 .show_qas = 1,
752 .get_wr_flow = mptspi_read_parameters,
753 .set_wr_flow = mptspi_write_wr_flow,
754 .show_wr_flow = 1,
755 .get_rd_strm = mptspi_read_parameters,
756 .set_rd_strm = mptspi_write_rd_strm,
757 .show_rd_strm = 1,
758 .get_rti = mptspi_read_parameters,
759 .set_rti = mptspi_write_rti,
760 .show_rti = 1,
761 .get_pcomp_en = mptspi_read_parameters,
762 .set_pcomp_en = mptspi_write_pcomp_en,
763 .show_pcomp_en = 1,
764 .get_hold_mcs = mptspi_read_parameters,
765 .set_hold_mcs = mptspi_write_hold_mcs,
766 .show_hold_mcs = 1,
767 .deny_binding = mptspi_deny_binding,
768};
243eabcf
MED		 769
770/****************************************************************************
771 * Supported hardware
772 */
773
774static struct pci_device_id mptspi_pci_table[] = {
87cf8986 775 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
243eabcf 776 PCI_ANY_ID, PCI_ANY_ID },
87cf8986 777 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
243eabcf
MED		 778 PCI_ANY_ID, PCI_ANY_ID },
779 {0} /* Terminating entry */
780};
781MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
782
6e1cad02
EM		 783
784/*
785 * renegotiate for a given target
786 */
787static void
c4028958 788mptspi_dv_renegotiate_work(struct work_struct *work)
6e1cad02 789{
c4028958
DH		 790 struct work_queue_wrapper *wqw =
791 container_of(work, struct work_queue_wrapper, work);
6e1cad02
EM		 792 struct _MPT_SCSI_HOST *hd = wqw->hd;
793 struct scsi_device *sdev;
794
795 kfree(wqw);
796
797 shost_for_each_device(sdev, hd->ioc->sh)
798 mptspi_dv_device(hd, sdev);
799}
800
801static void
802mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
803{
804 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
805
806 if (!wqw)
807 return;
808
c4028958 809 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
6e1cad02
EM		 810 wqw->hd = hd;
811
812 schedule_work(&wqw->work);
813}
814
815/*
816 * spi module reset handler
817 */
818static int
819mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
820{
821 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
822 int rc;
823
824 rc = mptscsih_ioc_reset(ioc, reset_phase);
825
826 if (reset_phase == MPT_IOC_POST_RESET)
827 mptspi_dv_renegotiate(hd);
828
829 return rc;
830}
831
c29ca9d1 832#ifdef CONFIG_PM
6e1cad02
EM		 833/*
834 * spi module resume handler
835 */
836static int
837mptspi_resume(struct pci_dev *pdev)
838{
839 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
840 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
841 int rc;
842
843 rc = mptscsih_resume(pdev);
844 mptspi_dv_renegotiate(hd);
845
846 return rc;
847}
c29ca9d1 848#endif
6e1cad02 849
243eabcf
MED		 850/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
851/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
852/*
853 * mptspi_probe - Installs scsi devices per bus.
854 * @pdev: Pointer to pci_dev structure
855 *
856 * Returns 0 for success, non-zero for failure.
857 *
858 */
859static int
860mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
861{
862 struct Scsi_Host *sh;
863 MPT_SCSI_HOST *hd;
864 MPT_ADAPTER *ioc;
865 unsigned long flags;
1ca00bb7 866 int ii;
243eabcf
MED		 867 int numSGE = 0;
868 int scale;
869 int ioc_cap;
243eabcf
MED		 870 int error=0;
871 int r;
c6678e0c 872
243eabcf
MED		 873 if ((r = mpt_attach(pdev,id)) != 0)
874 return r;
c6678e0c 875
243eabcf 876 ioc = pci_get_drvdata(pdev);
d335cc38
MED		 877 ioc->DoneCtx = mptspiDoneCtx;
878 ioc->TaskCtx = mptspiTaskCtx;
879 ioc->InternalCtx = mptspiInternalCtx;
c6678e0c 880
243eabcf
MED		 881 /* Added sanity check on readiness of the MPT adapter.
882 */
883 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
884 printk(MYIOC_s_WARN_FMT
885 "Skipping because it's not operational!\n",
886 ioc->name);
7acec1e7
MED		 887 error = -ENODEV;
888 goto out_mptspi_probe;
243eabcf
MED		 889 }
890
891 if (!ioc->active) {
892 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
893 ioc->name);
7acec1e7
MED		 894 error = -ENODEV;
895 goto out_mptspi_probe;
243eabcf
MED		 896 }
897
898 /* Sanity check - ensure at least 1 port is INITIATOR capable
899 */
900 ioc_cap = 0;
901 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
902 if (ioc->pfacts[ii].ProtocolFlags &
903 MPI_PORTFACTS_PROTOCOL_INITIATOR)
904 ioc_cap ++;
905 }
906
907 if (!ioc_cap) {
908 printk(MYIOC_s_WARN_FMT
909 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
910 ioc->name, ioc);
466544d8 911 return 0;
243eabcf
MED		 912 }
913
914 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
915
916 if (!sh) {
917 printk(MYIOC_s_WARN_FMT
918 "Unable to register controller with SCSI subsystem\n",
919 ioc->name);
7acec1e7
MED		 920 error = -1;
921 goto out_mptspi_probe;
243eabcf
MED		 922 }
923
924 spin_lock_irqsave(&ioc->FreeQlock, flags);
925
926 /* Attach the SCSI Host to the IOC structure
927 */
928 ioc->sh = sh;
929
930 sh->io_port = 0;
931 sh->n_io_port = 0;
932 sh->irq = 0;
933
934 /* set 16 byte cdb's */
935 sh->max_cmd_len = 16;
936
937 /* Yikes! This is important!
938 * Otherwise, by default, linux
939 * only scans target IDs 0-7!
940 * pfactsN->MaxDevices unreliable
941 * (not supported in early
942 * versions of the FW).
943 * max_id = 1 + actual max id,
944 * max_lun = 1 + actual last lun,
945 * see hosts.h :o(
946 */
947 sh->max_id = MPT_MAX_SCSI_DEVICES;
948
949 sh->max_lun = MPT_LAST_LUN + 1;
c92f222e
JB		 950 /*
951 * If RAID Firmware Detected, setup virtual channel
952 */
953 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
954 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
955 sh->max_channel = 1;
956 else
957 sh->max_channel = 0;
243eabcf
MED		 958 sh->this_id = ioc->pfacts[0].PortSCSIID;
959
960 /* Required entry.
961 */
962 sh->unique_id = ioc->id;
963
964 /* Verify that we won't exceed the maximum
965 * number of chain buffers
966 * We can optimize: ZZ = req_sz/sizeof(SGE)
967 * For 32bit SGE's:
968 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
969 * + (req_sz - 64)/sizeof(SGE)
970 * A slightly different algorithm is required for
971 * 64bit SGEs.
972 */
973 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
974 if (sizeof(dma_addr_t) == sizeof(u64)) {
975 numSGE = (scale - 1) *
976 (ioc->facts.MaxChainDepth-1) + scale +
977 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
978 sizeof(u32));
979 } else {
980 numSGE = 1 + (scale - 1) *
981 (ioc->facts.MaxChainDepth-1) + scale +
982 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
983 sizeof(u32));
984 }
985
986 if (numSGE < sh->sg_tablesize) {
987 /* Reset this value */
988 dprintk((MYIOC_s_INFO_FMT
989 "Resetting sg_tablesize to %d from %d\n",
990 ioc->name, numSGE, sh->sg_tablesize));
991 sh->sg_tablesize = numSGE;
992 }
993
243eabcf
MED		 994 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
995
996 hd = (MPT_SCSI_HOST *) sh->hostdata;
997 hd->ioc = ioc;
998
999 /* SCSI needs scsi_cmnd lookup table!
1000 * (with size equal to req_depth*PtrSz!)
1001 */
1ca00bb7
CH		 1002 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1003 if (!hd->ScsiLookup) {
243eabcf 1004 error = -ENOMEM;
7acec1e7 1005 goto out_mptspi_probe;
243eabcf
MED		 1006 }
1007
1ca00bb7
CH		 1008 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1009 ioc->name, hd->ScsiLookup));
243eabcf
MED		 1010
1011 /* Allocate memory for the device structures.
1012 * A non-Null pointer at an offset
1013 * indicates a device exists.
1014 * max_id = 1 + maximum id (hosts.h)
1015 */
c92f222e
JB		 1016 hd->Targets = kcalloc(sh->max_id * (sh->max_channel + 1),
1017 sizeof(void *), GFP_ATOMIC);
1ca00bb7 1018 if (!hd->Targets) {
243eabcf 1019 error = -ENOMEM;
7acec1e7 1020 goto out_mptspi_probe;
243eabcf
MED		 1021 }
1022
1ca00bb7 1023 dprintk((KERN_INFO " vdev @ %p\n", hd->Targets));
243eabcf
MED		 1024
1025 /* Clear the TM flags
1026 */
1027 hd->tmPending = 0;
1028 hd->tmState = TM_STATE_NONE;
1029 hd->resetPending = 0;
1030 hd->abortSCpnt = NULL;
1031
1032 /* Clear the pointer used to store
1033 * single-threaded commands, i.e., those
1034 * issued during a bus scan, dv and
1035 * configuration pages.
1036 */
1037 hd->cmdPtr = NULL;
1038
1039 /* Initialize this SCSI Hosts' timers
1040 * To use, set the timer expires field
1041 * and add_timer
1042 */
1043 init_timer(&hd->timer);
1044 hd->timer.data = (unsigned long) hd;
1045 hd->timer.function = mptscsih_timer_expired;
1046
1047 ioc->spi_data.Saf_Te = mpt_saf_te;
243eabcf 1048
243eabcf
MED		 1049 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1050 ddvprintk((MYIOC_s_INFO_FMT
ba856d32 1051 "saf_te %x\n",
243eabcf 1052 ioc->name,
ba856d32 1053 mpt_saf_te));
243eabcf
MED		 1054 ioc->spi_data.noQas = 0;
1055
243eabcf
MED		 1056 init_waitqueue_head(&hd->scandv_waitq);
1057 hd->scandv_wait_done = 0;
1058 hd->last_queue_full = 0;
1059
c92f222e
JB		 1060 /* Some versions of the firmware don't support page 0; without
1061 * that we can't get the parameters */
1062 if (hd->ioc->spi_data.sdp0length != 0)
1063 sh->transportt = mptspi_transport_template;
1064
243eabcf
MED		 1065 error = scsi_add_host (sh, &ioc->pcidev->dev);
1066 if(error) {
1067 dprintk((KERN_ERR MYNAM
1068 "scsi_add_host failed\n"));
7acec1e7 1069 goto out_mptspi_probe;
243eabcf
MED		 1070 }
1071
d8e925dc
ME		 1072 /*
1073 * issue internal bus reset
1074 */
1075 if (ioc->spi_data.bus_reset)
1076 mptscsih_TMHandler(hd,
1077 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1078 0, 0, 0, 0, 5);
1079
243eabcf
MED		 1080 scsi_scan_host(sh);
1081 return 0;
1082
7acec1e7 1083out_mptspi_probe:
243eabcf
MED		 1084
1085 mptscsih_remove(pdev);
1086 return error;
1087}
1088
1089static struct pci_driver mptspi_driver = {
1090 .name = "mptspi",
1091 .id_table = mptspi_pci_table,
1092 .probe = mptspi_probe,
1093 .remove = __devexit_p(mptscsih_remove),
d18c3db5 1094 .shutdown = mptscsih_shutdown,
243eabcf
MED		 1095#ifdef CONFIG_PM
1096 .suspend = mptscsih_suspend,
6e1cad02 1097 .resume = mptspi_resume,
243eabcf
MED		 1098#endif
1099};
1100
1101/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1102/**
d9489fb6 1103 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
243eabcf
MED		 1104 *
1105 * Returns 0 for success, non-zero for failure.
1106 */
1107static int __init
1108mptspi_init(void)
1109{
243eabcf
MED		 1110 show_mptmod_ver(my_NAME, my_VERSION);
1111
c92f222e
JB		 1112 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1113 if (!mptspi_transport_template)
1114 return -ENODEV;
1115
243eabcf
MED		 1116 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1117 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1118 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1119
c92f222e 1120 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
3a892bef 1121 devtverboseprintk((KERN_INFO MYNAM
243eabcf
MED		 1122 ": Registered for IOC event notifications\n"));
1123 }
1124
6e1cad02 1125 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
243eabcf
MED		 1126 dprintk((KERN_INFO MYNAM
1127 ": Registered for IOC reset notifications\n"));
1128 }
1129
1130 return pci_register_driver(&mptspi_driver);
1131}
1132
1133/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1134/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1135/**
1136 * mptspi_exit - Unregisters MPT adapter(s)
243eabcf
MED		 1137 */
1138static void __exit
1139mptspi_exit(void)
1140{
1141 pci_unregister_driver(&mptspi_driver);
d8e925dc 1142
243eabcf
MED		 1143 mpt_reset_deregister(mptspiDoneCtx);
1144 dprintk((KERN_INFO MYNAM
1145 ": Deregistered for IOC reset notifications\n"));
1146
1147 mpt_event_deregister(mptspiDoneCtx);
1148 dprintk((KERN_INFO MYNAM
1149 ": Deregistered for IOC event notifications\n"));
1150
1151 mpt_deregister(mptspiInternalCtx);
1152 mpt_deregister(mptspiTaskCtx);
1153 mpt_deregister(mptspiDoneCtx);
c92f222e 1154 spi_release_transport(mptspi_transport_template);
243eabcf
MED		 1155}
1156
1157module_init(mptspi_init);
1158module_exit(mptspi_exit);
ubuntu-zesty-kernel mirror