]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/message/fusion/mptspi.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
SCSI host lock push-down
[mirror_ubuntu-artful-kernel.git] / drivers / message / fusion / mptspi.c
1 /*
2 * linux/drivers/message/fusion/mptspi.c
3 * For use with LSI PCI chip/adapter(s)
4 * running LSI Fusion MPT (Message Passing Technology) firmware.
5 *
6 * Copyright (c) 1999-2008 LSI Corporation
7 * (mailto:DL-MPTFusionLinux@lsi.com)
8 *
9 */
10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
11 /*
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; version 2 of the License.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 NO WARRANTY
22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
26 solely responsible for determining the appropriateness of using and
27 distributing the Program and assumes all risks associated with its
28 exercise of rights under this Agreement, including but not limited to
29 the risks and costs of program errors, damage to or loss of data,
30 programs or equipment, and unavailability or interruption of operations.
31
32 DISCLAIMER OF LIABILITY
33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
40
41 You should have received a copy of the GNU General Public License
42 along with this program; if not, write to the Free Software
43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
44 */
45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
46
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/slab.h>
50 #include <linux/init.h>
51 #include <linux/errno.h>
52 #include <linux/kdev_t.h>
53 #include <linux/blkdev.h>
54 #include <linux/delay.h> /* for mdelay */
55 #include <linux/interrupt.h> /* needed for in_interrupt() proto */
56 #include <linux/reboot.h> /* notifier code */
57 #include <linux/workqueue.h>
58 #include <linux/raid_class.h>
59
60 #include <scsi/scsi.h>
61 #include <scsi/scsi_cmnd.h>
62 #include <scsi/scsi_device.h>
63 #include <scsi/scsi_host.h>
64 #include <scsi/scsi_tcq.h>
65 #include <scsi/scsi_transport.h>
66 #include <scsi/scsi_transport_spi.h>
67 #include <scsi/scsi_dbg.h>
68
69 #include "mptbase.h"
70 #include "mptscsih.h"
71
72 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
73 #define my_NAME "Fusion MPT SPI Host driver"
74 #define my_VERSION MPT_LINUX_VERSION_COMMON
75 #define MYNAM "mptspi"
76
77 MODULE_AUTHOR(MODULEAUTHOR);
78 MODULE_DESCRIPTION(my_NAME);
79 MODULE_LICENSE("GPL");
80 MODULE_VERSION(my_VERSION);
81
82 /* Command line args */
83 static int mpt_saf_te = MPTSCSIH_SAF_TE;
84 module_param(mpt_saf_te, int, 0);
85 MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1 (default=MPTSCSIH_SAF_TE=0)");
86
87 static void mptspi_write_offset(struct scsi_target *, int);
88 static void mptspi_write_width(struct scsi_target *, int);
89 static int mptspi_write_spi_device_pg1(struct scsi_target *,
90 struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
91
92 static struct scsi_transport_template *mptspi_transport_template = NULL;
93
94 static u8 mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
95 static u8 mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
96 static u8 mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
97
98 /**
99 * mptspi_setTargetNegoParms - Update the target negotiation parameters
100 * @hd: Pointer to a SCSI Host Structure
101 * @target: per target private data
102 * @sdev: SCSI device
103 *
104 * Update the target negotiation parameters based on the the Inquiry
105 * data, adapter capabilities, and NVRAM settings.
106 **/
107 static void
108 mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
109 struct scsi_device *sdev)
110 {
111 MPT_ADAPTER *ioc = hd->ioc;
112 SpiCfgData *pspi_data = &ioc->spi_data;
113 int id = (int) target->id;
114 int nvram;
115 u8 width = MPT_NARROW;
116 u8 factor = MPT_ASYNC;
117 u8 offset = 0;
118 u8 nfactor;
119 u8 noQas = 1;
120
121 target->negoFlags = pspi_data->noQas;
122
123 if (sdev->scsi_level < SCSI_2) {
124 width = 0;
125 factor = MPT_ULTRA2;
126 offset = pspi_data->maxSyncOffset;
127 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
128 } else {
129 if (scsi_device_wide(sdev))
130 width = 1;
131
132 if (scsi_device_sync(sdev)) {
133 factor = pspi_data->minSyncFactor;
134 if (!scsi_device_dt(sdev))
135 factor = MPT_ULTRA2;
136 else {
137 if (!scsi_device_ius(sdev) &&
138 !scsi_device_qas(sdev))
139 factor = MPT_ULTRA160;
140 else {
141 factor = MPT_ULTRA320;
142 if (scsi_device_qas(sdev)) {
143 ddvprintk(ioc,
144 printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
145 "byte56=%02x on id=%d!\n", ioc->name,
146 scsi_device_qas(sdev), id));
147 noQas = 0;
148 }
149 if (sdev->type == TYPE_TAPE &&
150 scsi_device_ius(sdev))
151 target->negoFlags |= MPT_TAPE_NEGO_IDP;
152 }
153 }
154 offset = pspi_data->maxSyncOffset;
155
156 /* If RAID, never disable QAS
157 * else if non RAID, do not disable
158 * QAS if bit 1 is set
159 * bit 1 QAS support, non-raid only
160 * bit 0 IU support
161 */
162 if (target->raidVolume == 1)
163 noQas = 0;
164 } else {
165 factor = MPT_ASYNC;
166 offset = 0;
167 }
168 }
169
170 if (!sdev->tagged_supported)
171 target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
172
173 /* Update tflags based on NVRAM settings. (SCSI only)
174 */
175 if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
176 nvram = pspi_data->nvram[id];
177 nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
178
179 if (width)
180 width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
181
182 if (offset > 0) {
183 /* Ensure factor is set to the
184 * maximum of: adapter, nvram, inquiry
185 */
186 if (nfactor) {
187 if (nfactor < pspi_data->minSyncFactor )
188 nfactor = pspi_data->minSyncFactor;
189
190 factor = max(factor, nfactor);
191 if (factor == MPT_ASYNC)
192 offset = 0;
193 } else {
194 offset = 0;
195 factor = MPT_ASYNC;
196 }
197 } else {
198 factor = MPT_ASYNC;
199 }
200 }
201
202 /* Make sure data is consistent
203 */
204 if ((!width) && (factor < MPT_ULTRA2))
205 factor = MPT_ULTRA2;
206
207 /* Save the data to the target structure.
208 */
209 target->minSyncFactor = factor;
210 target->maxOffset = offset;
211 target->maxWidth = width;
212
213 spi_min_period(scsi_target(sdev)) = factor;
214 spi_max_offset(scsi_target(sdev)) = offset;
215 spi_max_width(scsi_target(sdev)) = width;
216
217 target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
218
219 /* Disable unused features.
220 */
221 if (!width)
222 target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
223
224 if (!offset)
225 target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
226
227 if ( factor > MPT_ULTRA320 )
228 noQas = 0;
229
230 if (noQas && (pspi_data->noQas == 0)) {
231 pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
232 target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
233
234 /* Disable QAS in a mixed configuration case
235 */
236
237 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
238 "Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
239 }
240 }
241
242 /**
243 * mptspi_writeIOCPage4 - write IOC Page 4
244 * @hd: Pointer to a SCSI Host Structure
245 * @channel: channel number
246 * @id: write IOC Page4 for this ID & Bus
247 *
248 * Return: -EAGAIN if unable to obtain a Message Frame
249 * or 0 if success.
250 *
251 * Remark: We do not wait for a return, write pages sequentially.
252 **/
253 static int
254 mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
255 {
256 MPT_ADAPTER *ioc = hd->ioc;
257 Config_t *pReq;
258 IOCPage4_t *IOCPage4Ptr;
259 MPT_FRAME_HDR *mf;
260 dma_addr_t dataDma;
261 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) {
269 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
270 "writeIOCPage4 : no msg frames!\n",ioc->name));
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
308 ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
309
310 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
311 "writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
312 ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
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 **/
332 static void
333 mptspi_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 }
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 */
380 static int
381 mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
382 {
383 int i, rc = 0;
384 MPT_ADAPTER *ioc = hd->ioc;
385
386 if (!ioc->raid_data.pIocPg2)
387 goto out;
388
389 if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
390 goto out;
391 for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
392 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
393 rc = 1;
394 goto out;
395 }
396 }
397
398 out:
399 return rc;
400 }
401
402 static int mptspi_target_alloc(struct scsi_target *starget)
403 {
404 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
405 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
406 VirtTarget *vtarget;
407 MPT_ADAPTER *ioc;
408
409 if (hd == NULL)
410 return -ENODEV;
411
412 ioc = hd->ioc;
413 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
414 if (!vtarget)
415 return -ENOMEM;
416
417 vtarget->ioc_id = ioc->id;
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) {
425 if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
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) */
431 vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
432 starget->id);
433 }
434
435 if (starget->channel == 0 &&
436 mptspi_is_raid(hd, starget->id)) {
437 vtarget->raidVolume = 1;
438 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
439 "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
440 starget->id));
441 }
442
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];
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 {
449 spi_min_period(starget) = ioc->spi_data.minSyncFactor;
450 spi_max_width(starget) = ioc->spi_data.maxBusWidth;
451 }
452 spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
453
454 spi_offset(starget) = 0;
455 spi_period(starget) = 0xFF;
456 mptspi_write_width(starget, 0);
457
458 return 0;
459 }
460
461 static void
462 mptspi_target_destroy(struct scsi_target *starget)
463 {
464 if (starget->hostdata)
465 kfree(starget->hostdata);
466 starget->hostdata = NULL;
467 }
468
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 */
476 static void
477 mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
478 {
479 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
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 */
501 static void
502 mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
503 {
504 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
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
519 static 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);
523 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
524 struct _MPT_ADAPTER *ioc = hd->ioc;
525 struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
526 dma_addr_t spi_dev_pg0_dma;
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 &&
534 mptspi_is_raid(hd, starget->id))
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
544 spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
545 if (spi_dev_pg0 == NULL) {
546 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
547 "dma_alloc_coherent for parameters failed\n", ioc->name);
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;
561 cfg.physAddr = spi_dev_pg0_dma;
562 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
563 cfg.dir = 0;
564 cfg.pageAddr = starget->id;
565 cfg.timeout = 60;
566
567 if (mpt_config(ioc, &cfg)) {
568 starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
569 goto out_free;
570 }
571 err = 0;
572 memcpy(pass_pg0, spi_dev_pg0, size);
573
574 mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
575
576 out_free:
577 dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
578 return err;
579 }
580
581 static 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
601 static void mptspi_read_parameters(struct scsi_target *starget)
602 {
603 int nego;
604 struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
605
606 mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
607
608 nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
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
623 int
624 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
625 {
626 MPT_ADAPTER *ioc = hd->ioc;
627 MpiRaidActionRequest_t *pReq;
628 MPT_FRAME_HDR *mf;
629 int ret;
630 unsigned long timeleft;
631
632 mutex_lock(&ioc->internal_cmds.mutex);
633
634 /* Get and Populate a free Frame
635 */
636 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
637 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
638 "%s: no msg frames!\n", ioc->name, __func__));
639 ret = -EAGAIN;
640 goto out;
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;
650 pReq->VolumeID = id;
651 pReq->VolumeBus = channel;
652 pReq->PhysDiskNum = 0;
653 pReq->MsgFlags = 0;
654 pReq->Reserved2 = 0;
655 pReq->ActionDataWord = 0; /* Reserved for this action */
656
657 ioc->add_sge((char *)&pReq->ActionDataSGE,
658 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
659
660 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
661 ioc->name, pReq->Action, channel, id));
662
663 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
664 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
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 }
680
681 ret = ioc->internal_cmds.completion_code;
682
683 out:
684 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
685 mutex_unlock(&ioc->internal_cmds.mutex);
686 return ret;
687 }
688
689 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
690 struct scsi_device *sdev)
691 {
692 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
693 MPT_ADAPTER *ioc = hd->ioc;
694
695 /* no DV on RAID devices */
696 if (sdev->channel == 0 &&
697 mptspi_is_raid(hd, sdev->id))
698 return;
699
700 /* If this is a piece of a RAID, then quiesce first */
701 if (sdev->channel == 1 &&
702 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
703 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
704 "Integrated RAID quiesce failed\n", ioc->name);
705 return;
706 }
707
708 hd->spi_pending |= (1 << sdev->id);
709 spi_dv_device(sdev);
710 hd->spi_pending &= ~(1 << sdev->id);
711
712 if (sdev->channel == 1 &&
713 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
714 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
715 "Integrated RAID resume failed\n", ioc->name);
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
722 static int mptspi_slave_alloc(struct scsi_device *sdev)
723 {
724 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
725 VirtTarget *vtarget;
726 VirtDevice *vdevice;
727 struct scsi_target *starget;
728 MPT_ADAPTER *ioc = hd->ioc;
729
730 if (sdev->channel == 1 &&
731 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
732 return -ENXIO;
733
734 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
735 if (!vdevice) {
736 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
737 ioc->name, sizeof(VirtDevice));
738 return -ENOMEM;
739 }
740
741 vdevice->lun = sdev->lun;
742 sdev->hostdata = vdevice;
743
744 starget = scsi_target(sdev);
745 vtarget = starget->hostdata;
746 vdevice->vtarget = vtarget;
747 vtarget->num_luns++;
748
749 if (sdev->channel == 1)
750 sdev->no_uld_attach = 1;
751
752 return 0;
753 }
754
755 static int mptspi_slave_configure(struct scsi_device *sdev)
756 {
757 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
758 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
759 int ret;
760
761 mptspi_initTarget(hd, vtarget, sdev);
762
763 ret = mptscsih_slave_configure(sdev);
764
765 if (ret)
766 return ret;
767
768 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
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
774 if ((sdev->channel == 1 ||
775 !(mptspi_is_raid(hd, sdev->id))) &&
776 !spi_initial_dv(sdev->sdev_target))
777 mptspi_dv_device(hd, sdev);
778
779 return 0;
780 }
781
782 static int
783 mptspi_qcmd_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
784 {
785 struct _MPT_SCSI_HOST *hd = shost_priv(SCpnt->device->host);
786 VirtDevice *vdevice = SCpnt->device->hostdata;
787 MPT_ADAPTER *ioc = hd->ioc;
788
789 if (!vdevice || !vdevice->vtarget) {
790 SCpnt->result = DID_NO_CONNECT << 16;
791 done(SCpnt);
792 return 0;
793 }
794
795 if (SCpnt->device->channel == 1 &&
796 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
797 SCpnt->result = DID_NO_CONNECT << 16;
798 done(SCpnt);
799 return 0;
800 }
801
802 if (spi_dv_pending(scsi_target(SCpnt->device)))
803 ddvprintk(ioc, scsi_print_command(SCpnt));
804
805 return mptscsih_qcmd(SCpnt,done);
806 }
807
808 static DEF_SCSI_QCMD(mptspi_qcmd)
809
810 static void mptspi_slave_destroy(struct scsi_device *sdev)
811 {
812 struct scsi_target *starget = scsi_target(sdev);
813 VirtTarget *vtarget = starget->hostdata;
814 VirtDevice *vdevice = sdev->hostdata;
815
816 /* Will this be the last lun on a non-raid device? */
817 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
818 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
819
820 /* Async Narrow */
821 pg1.RequestedParameters = 0;
822 pg1.Reserved = 0;
823 pg1.Configuration = 0;
824
825 mptspi_write_spi_device_pg1(starget, &pg1);
826 }
827
828 mptscsih_slave_destroy(sdev);
829 }
830
831 static struct scsi_host_template mptspi_driver_template = {
832 .module = THIS_MODULE,
833 .proc_name = "mptspi",
834 .proc_info = mptscsih_proc_info,
835 .name = "MPT SPI Host",
836 .info = mptscsih_info,
837 .queuecommand = mptspi_qcmd,
838 .target_alloc = mptspi_target_alloc,
839 .slave_alloc = mptspi_slave_alloc,
840 .slave_configure = mptspi_slave_configure,
841 .target_destroy = mptspi_target_destroy,
842 .slave_destroy = mptspi_slave_destroy,
843 .change_queue_depth = mptscsih_change_queue_depth,
844 .eh_abort_handler = mptscsih_abort,
845 .eh_device_reset_handler = mptscsih_dev_reset,
846 .eh_bus_reset_handler = mptscsih_bus_reset,
847 .eh_host_reset_handler = mptscsih_host_reset,
848 .bios_param = mptscsih_bios_param,
849 .can_queue = MPT_SCSI_CAN_QUEUE,
850 .this_id = -1,
851 .sg_tablesize = MPT_SCSI_SG_DEPTH,
852 .max_sectors = 8192,
853 .cmd_per_lun = 7,
854 .use_clustering = ENABLE_CLUSTERING,
855 .shost_attrs = mptscsih_host_attrs,
856 };
857
858 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
859 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
860 {
861 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
862 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
863 struct _MPT_ADAPTER *ioc = hd->ioc;
864 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
865 dma_addr_t pg1_dma;
866 int size;
867 struct _x_config_parms cfg;
868 struct _CONFIG_PAGE_HEADER hdr;
869 int err = -EBUSY;
870
871 /* don't allow updating nego parameters on RAID devices */
872 if (starget->channel == 0 &&
873 mptspi_is_raid(hd, starget->id))
874 return -1;
875
876 size = ioc->spi_data.sdp1length * 4;
877
878 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
879 if (pg1 == NULL) {
880 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
881 "dma_alloc_coherent for parameters failed\n", ioc->name);
882 return -EINVAL;
883 }
884
885 memset(&hdr, 0, sizeof(hdr));
886
887 hdr.PageVersion = ioc->spi_data.sdp1version;
888 hdr.PageLength = ioc->spi_data.sdp1length;
889 hdr.PageNumber = 1;
890 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
891
892 memset(&cfg, 0, sizeof(cfg));
893
894 cfg.cfghdr.hdr = &hdr;
895 cfg.physAddr = pg1_dma;
896 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
897 cfg.dir = 1;
898 cfg.pageAddr = starget->id;
899
900 memcpy(pg1, pass_pg1, size);
901
902 pg1->Header.PageVersion = hdr.PageVersion;
903 pg1->Header.PageLength = hdr.PageLength;
904 pg1->Header.PageNumber = hdr.PageNumber;
905 pg1->Header.PageType = hdr.PageType;
906
907 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
908
909 if (mpt_config(ioc, &cfg)) {
910 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
911 "mpt_config failed\n", ioc->name);
912 goto out_free;
913 }
914 err = 0;
915
916 out_free:
917 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
918 return err;
919 }
920
921 static void mptspi_write_offset(struct scsi_target *starget, int offset)
922 {
923 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
924 u32 nego;
925
926 if (offset < 0)
927 offset = 0;
928
929 if (offset > 255)
930 offset = 255;
931
932 if (spi_offset(starget) == -1)
933 mptspi_read_parameters(starget);
934
935 spi_offset(starget) = offset;
936
937 nego = mptspi_getRP(starget);
938
939 pg1.RequestedParameters = cpu_to_le32(nego);
940 pg1.Reserved = 0;
941 pg1.Configuration = 0;
942
943 mptspi_write_spi_device_pg1(starget, &pg1);
944 }
945
946 static void mptspi_write_period(struct scsi_target *starget, int period)
947 {
948 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
949 u32 nego;
950
951 if (period < 8)
952 period = 8;
953
954 if (period > 255)
955 period = 255;
956
957 if (spi_period(starget) == -1)
958 mptspi_read_parameters(starget);
959
960 if (period == 8) {
961 spi_iu(starget) = 1;
962 spi_dt(starget) = 1;
963 } else if (period == 9) {
964 spi_dt(starget) = 1;
965 }
966
967 spi_period(starget) = period;
968
969 nego = mptspi_getRP(starget);
970
971 pg1.RequestedParameters = cpu_to_le32(nego);
972 pg1.Reserved = 0;
973 pg1.Configuration = 0;
974
975 mptspi_write_spi_device_pg1(starget, &pg1);
976 }
977
978 static void mptspi_write_dt(struct scsi_target *starget, int dt)
979 {
980 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
981 u32 nego;
982
983 if (spi_period(starget) == -1)
984 mptspi_read_parameters(starget);
985
986 if (!dt && spi_period(starget) < 10)
987 spi_period(starget) = 10;
988
989 spi_dt(starget) = dt;
990
991 nego = mptspi_getRP(starget);
992
993
994 pg1.RequestedParameters = cpu_to_le32(nego);
995 pg1.Reserved = 0;
996 pg1.Configuration = 0;
997
998 mptspi_write_spi_device_pg1(starget, &pg1);
999 }
1000
1001 static void mptspi_write_iu(struct scsi_target *starget, int iu)
1002 {
1003 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1004 u32 nego;
1005
1006 if (spi_period(starget) == -1)
1007 mptspi_read_parameters(starget);
1008
1009 if (!iu && spi_period(starget) < 9)
1010 spi_period(starget) = 9;
1011
1012 spi_iu(starget) = iu;
1013
1014 nego = mptspi_getRP(starget);
1015
1016 pg1.RequestedParameters = cpu_to_le32(nego);
1017 pg1.Reserved = 0;
1018 pg1.Configuration = 0;
1019
1020 mptspi_write_spi_device_pg1(starget, &pg1);
1021 }
1022
1023 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1024 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1025 { \
1026 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1027 u32 nego; \
1028 \
1029 spi_##parm(starget) = parm; \
1030 \
1031 nego = mptspi_getRP(starget); \
1032 \
1033 pg1.RequestedParameters = cpu_to_le32(nego); \
1034 pg1.Reserved = 0; \
1035 pg1.Configuration = 0; \
1036 \
1037 mptspi_write_spi_device_pg1(starget, &pg1); \
1038 }
1039
1040 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1041 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1042 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1043 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1044 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1045
1046 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1047 {
1048 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1049 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1050 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1051 VirtTarget *vtarget = starget->hostdata;
1052 u32 nego;
1053
1054 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1055 hd->ioc->spi_data.noQas)
1056 spi_qas(starget) = 0;
1057 else
1058 spi_qas(starget) = qas;
1059
1060 nego = mptspi_getRP(starget);
1061
1062 pg1.RequestedParameters = cpu_to_le32(nego);
1063 pg1.Reserved = 0;
1064 pg1.Configuration = 0;
1065
1066 mptspi_write_spi_device_pg1(starget, &pg1);
1067 }
1068
1069 static void mptspi_write_width(struct scsi_target *starget, int width)
1070 {
1071 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1072 u32 nego;
1073
1074 if (!width) {
1075 spi_dt(starget) = 0;
1076 if (spi_period(starget) < 10)
1077 spi_period(starget) = 10;
1078 }
1079
1080 spi_width(starget) = width;
1081
1082 nego = mptspi_getRP(starget);
1083
1084 pg1.RequestedParameters = cpu_to_le32(nego);
1085 pg1.Reserved = 0;
1086 pg1.Configuration = 0;
1087
1088 mptspi_write_spi_device_pg1(starget, &pg1);
1089 }
1090
1091 struct work_queue_wrapper {
1092 struct work_struct work;
1093 struct _MPT_SCSI_HOST *hd;
1094 int disk;
1095 };
1096
1097 static void mpt_work_wrapper(struct work_struct *work)
1098 {
1099 struct work_queue_wrapper *wqw =
1100 container_of(work, struct work_queue_wrapper, work);
1101 struct _MPT_SCSI_HOST *hd = wqw->hd;
1102 MPT_ADAPTER *ioc = hd->ioc;
1103 struct Scsi_Host *shost = ioc->sh;
1104 struct scsi_device *sdev;
1105 int disk = wqw->disk;
1106 struct _CONFIG_PAGE_IOC_3 *pg3;
1107
1108 kfree(wqw);
1109
1110 mpt_findImVolumes(ioc);
1111 pg3 = ioc->raid_data.pIocPg3;
1112 if (!pg3)
1113 return;
1114
1115 shost_for_each_device(sdev,shost) {
1116 struct scsi_target *starget = scsi_target(sdev);
1117 VirtTarget *vtarget = starget->hostdata;
1118
1119 /* only want to search RAID components */
1120 if (sdev->channel != 1)
1121 continue;
1122
1123 /* The id is the raid PhysDiskNum, even if
1124 * starget->id is the actual target address */
1125 if(vtarget->id != disk)
1126 continue;
1127
1128 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1129 "Integrated RAID requests DV of new device\n", ioc->name);
1130 mptspi_dv_device(hd, sdev);
1131 }
1132 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1133 "Integrated RAID detects new device %d\n", ioc->name, disk);
1134 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1135 }
1136
1137
1138 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1139 {
1140 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1141 MPT_ADAPTER *ioc = hd->ioc;
1142
1143 if (!wqw) {
1144 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1145 "Failed to act on RAID event for physical disk %d\n",
1146 ioc->name, disk);
1147 return;
1148 }
1149 INIT_WORK(&wqw->work, mpt_work_wrapper);
1150 wqw->hd = hd;
1151 wqw->disk = disk;
1152
1153 schedule_work(&wqw->work);
1154 }
1155
1156 static int
1157 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1158 {
1159 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1160 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1161
1162 if (ioc->bus_type != SPI)
1163 return 0;
1164
1165 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1166 int reason
1167 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1168
1169 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1170 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1171 mpt_dv_raid(hd, disk);
1172 }
1173 }
1174 return mptscsih_event_process(ioc, pEvReply);
1175 }
1176
1177 static int
1178 mptspi_deny_binding(struct scsi_target *starget)
1179 {
1180 struct _MPT_SCSI_HOST *hd =
1181 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1182 return ((mptspi_is_raid(hd, starget->id)) &&
1183 starget->channel == 0) ? 1 : 0;
1184 }
1185
1186 static struct spi_function_template mptspi_transport_functions = {
1187 .get_offset = mptspi_read_parameters,
1188 .set_offset = mptspi_write_offset,
1189 .show_offset = 1,
1190 .get_period = mptspi_read_parameters,
1191 .set_period = mptspi_write_period,
1192 .show_period = 1,
1193 .get_width = mptspi_read_parameters,
1194 .set_width = mptspi_write_width,
1195 .show_width = 1,
1196 .get_iu = mptspi_read_parameters,
1197 .set_iu = mptspi_write_iu,
1198 .show_iu = 1,
1199 .get_dt = mptspi_read_parameters,
1200 .set_dt = mptspi_write_dt,
1201 .show_dt = 1,
1202 .get_qas = mptspi_read_parameters,
1203 .set_qas = mptspi_write_qas,
1204 .show_qas = 1,
1205 .get_wr_flow = mptspi_read_parameters,
1206 .set_wr_flow = mptspi_write_wr_flow,
1207 .show_wr_flow = 1,
1208 .get_rd_strm = mptspi_read_parameters,
1209 .set_rd_strm = mptspi_write_rd_strm,
1210 .show_rd_strm = 1,
1211 .get_rti = mptspi_read_parameters,
1212 .set_rti = mptspi_write_rti,
1213 .show_rti = 1,
1214 .get_pcomp_en = mptspi_read_parameters,
1215 .set_pcomp_en = mptspi_write_pcomp_en,
1216 .show_pcomp_en = 1,
1217 .get_hold_mcs = mptspi_read_parameters,
1218 .set_hold_mcs = mptspi_write_hold_mcs,
1219 .show_hold_mcs = 1,
1220 .deny_binding = mptspi_deny_binding,
1221 };
1222
1223 /****************************************************************************
1224 * Supported hardware
1225 */
1226
1227 static struct pci_device_id mptspi_pci_table[] = {
1228 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1229 PCI_ANY_ID, PCI_ANY_ID },
1230 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1231 PCI_ANY_ID, PCI_ANY_ID },
1232 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1233 PCI_ANY_ID, PCI_ANY_ID },
1234 {0} /* Terminating entry */
1235 };
1236 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1237
1238
1239 /*
1240 * renegotiate for a given target
1241 */
1242 static void
1243 mptspi_dv_renegotiate_work(struct work_struct *work)
1244 {
1245 struct work_queue_wrapper *wqw =
1246 container_of(work, struct work_queue_wrapper, work);
1247 struct _MPT_SCSI_HOST *hd = wqw->hd;
1248 struct scsi_device *sdev;
1249 struct scsi_target *starget;
1250 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1251 u32 nego;
1252 MPT_ADAPTER *ioc = hd->ioc;
1253
1254 kfree(wqw);
1255
1256 if (hd->spi_pending) {
1257 shost_for_each_device(sdev, ioc->sh) {
1258 if (hd->spi_pending & (1 << sdev->id))
1259 continue;
1260 starget = scsi_target(sdev);
1261 nego = mptspi_getRP(starget);
1262 pg1.RequestedParameters = cpu_to_le32(nego);
1263 pg1.Reserved = 0;
1264 pg1.Configuration = 0;
1265 mptspi_write_spi_device_pg1(starget, &pg1);
1266 }
1267 } else {
1268 shost_for_each_device(sdev, ioc->sh)
1269 mptspi_dv_device(hd, sdev);
1270 }
1271 }
1272
1273 static void
1274 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1275 {
1276 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1277
1278 if (!wqw)
1279 return;
1280
1281 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1282 wqw->hd = hd;
1283
1284 schedule_work(&wqw->work);
1285 }
1286
1287 /*
1288 * spi module reset handler
1289 */
1290 static int
1291 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1292 {
1293 int rc;
1294
1295 rc = mptscsih_ioc_reset(ioc, reset_phase);
1296 if ((ioc->bus_type != SPI) || (!rc))
1297 return rc;
1298
1299 /* only try to do a renegotiation if we're properly set up
1300 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1301 if (reset_phase == MPT_IOC_POST_RESET &&
1302 ioc->sh) {
1303 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1304
1305 mptspi_dv_renegotiate(hd);
1306 }
1307
1308 return rc;
1309 }
1310
1311 #ifdef CONFIG_PM
1312 /*
1313 * spi module resume handler
1314 */
1315 static int
1316 mptspi_resume(struct pci_dev *pdev)
1317 {
1318 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1319 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1320 int rc;
1321
1322 rc = mptscsih_resume(pdev);
1323 mptspi_dv_renegotiate(hd);
1324
1325 return rc;
1326 }
1327 #endif
1328
1329 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1330 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1331 /*
1332 * mptspi_probe - Installs scsi devices per bus.
1333 * @pdev: Pointer to pci_dev structure
1334 *
1335 * Returns 0 for success, non-zero for failure.
1336 *
1337 */
1338 static int
1339 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1340 {
1341 struct Scsi_Host *sh;
1342 MPT_SCSI_HOST *hd;
1343 MPT_ADAPTER *ioc;
1344 unsigned long flags;
1345 int ii;
1346 int numSGE = 0;
1347 int scale;
1348 int ioc_cap;
1349 int error=0;
1350 int r;
1351
1352 if ((r = mpt_attach(pdev,id)) != 0)
1353 return r;
1354
1355 ioc = pci_get_drvdata(pdev);
1356 ioc->DoneCtx = mptspiDoneCtx;
1357 ioc->TaskCtx = mptspiTaskCtx;
1358 ioc->InternalCtx = mptspiInternalCtx;
1359
1360 /* Added sanity check on readiness of the MPT adapter.
1361 */
1362 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1363 printk(MYIOC_s_WARN_FMT
1364 "Skipping because it's not operational!\n",
1365 ioc->name);
1366 error = -ENODEV;
1367 goto out_mptspi_probe;
1368 }
1369
1370 if (!ioc->active) {
1371 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1372 ioc->name);
1373 error = -ENODEV;
1374 goto out_mptspi_probe;
1375 }
1376
1377 /* Sanity check - ensure at least 1 port is INITIATOR capable
1378 */
1379 ioc_cap = 0;
1380 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1381 if (ioc->pfacts[ii].ProtocolFlags &
1382 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1383 ioc_cap ++;
1384 }
1385
1386 if (!ioc_cap) {
1387 printk(MYIOC_s_WARN_FMT
1388 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1389 ioc->name, ioc);
1390 return 0;
1391 }
1392
1393 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1394
1395 if (!sh) {
1396 printk(MYIOC_s_WARN_FMT
1397 "Unable to register controller with SCSI subsystem\n",
1398 ioc->name);
1399 error = -1;
1400 goto out_mptspi_probe;
1401 }
1402
1403 spin_lock_irqsave(&ioc->FreeQlock, flags);
1404
1405 /* Attach the SCSI Host to the IOC structure
1406 */
1407 ioc->sh = sh;
1408
1409 sh->io_port = 0;
1410 sh->n_io_port = 0;
1411 sh->irq = 0;
1412
1413 /* set 16 byte cdb's */
1414 sh->max_cmd_len = 16;
1415
1416 /* Yikes! This is important!
1417 * Otherwise, by default, linux
1418 * only scans target IDs 0-7!
1419 * pfactsN->MaxDevices unreliable
1420 * (not supported in early
1421 * versions of the FW).
1422 * max_id = 1 + actual max id,
1423 * max_lun = 1 + actual last lun,
1424 * see hosts.h :o(
1425 */
1426 sh->max_id = ioc->devices_per_bus;
1427
1428 sh->max_lun = MPT_LAST_LUN + 1;
1429 /*
1430 * If RAID Firmware Detected, setup virtual channel
1431 */
1432 if (ioc->ir_firmware)
1433 sh->max_channel = 1;
1434 else
1435 sh->max_channel = 0;
1436 sh->this_id = ioc->pfacts[0].PortSCSIID;
1437
1438 /* Required entry.
1439 */
1440 sh->unique_id = ioc->id;
1441
1442 /* Verify that we won't exceed the maximum
1443 * number of chain buffers
1444 * We can optimize: ZZ = req_sz/sizeof(SGE)
1445 * For 32bit SGE's:
1446 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1447 * + (req_sz - 64)/sizeof(SGE)
1448 * A slightly different algorithm is required for
1449 * 64bit SGEs.
1450 */
1451 scale = ioc->req_sz/ioc->SGE_size;
1452 if (ioc->sg_addr_size == sizeof(u64)) {
1453 numSGE = (scale - 1) *
1454 (ioc->facts.MaxChainDepth-1) + scale +
1455 (ioc->req_sz - 60) / ioc->SGE_size;
1456 } else {
1457 numSGE = 1 + (scale - 1) *
1458 (ioc->facts.MaxChainDepth-1) + scale +
1459 (ioc->req_sz - 64) / ioc->SGE_size;
1460 }
1461
1462 if (numSGE < sh->sg_tablesize) {
1463 /* Reset this value */
1464 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1465 "Resetting sg_tablesize to %d from %d\n",
1466 ioc->name, numSGE, sh->sg_tablesize));
1467 sh->sg_tablesize = numSGE;
1468 }
1469
1470 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1471
1472 hd = shost_priv(sh);
1473 hd->ioc = ioc;
1474
1475 /* SCSI needs scsi_cmnd lookup table!
1476 * (with size equal to req_depth*PtrSz!)
1477 */
1478 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1479 if (!ioc->ScsiLookup) {
1480 error = -ENOMEM;
1481 goto out_mptspi_probe;
1482 }
1483 spin_lock_init(&ioc->scsi_lookup_lock);
1484
1485 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1486 ioc->name, ioc->ScsiLookup));
1487
1488 ioc->spi_data.Saf_Te = mpt_saf_te;
1489 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1490 "saf_te %x\n",
1491 ioc->name,
1492 mpt_saf_te));
1493 ioc->spi_data.noQas = 0;
1494
1495 hd->last_queue_full = 0;
1496 hd->spi_pending = 0;
1497
1498 /* Some versions of the firmware don't support page 0; without
1499 * that we can't get the parameters */
1500 if (ioc->spi_data.sdp0length != 0)
1501 sh->transportt = mptspi_transport_template;
1502
1503 error = scsi_add_host (sh, &ioc->pcidev->dev);
1504 if(error) {
1505 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1506 "scsi_add_host failed\n", ioc->name));
1507 goto out_mptspi_probe;
1508 }
1509
1510 /*
1511 * issue internal bus reset
1512 */
1513 if (ioc->spi_data.bus_reset)
1514 mptscsih_IssueTaskMgmt(hd,
1515 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1516 0, 0, 0, 0, 5);
1517
1518 scsi_scan_host(sh);
1519 return 0;
1520
1521 out_mptspi_probe:
1522
1523 mptscsih_remove(pdev);
1524 return error;
1525 }
1526
1527 static struct pci_driver mptspi_driver = {
1528 .name = "mptspi",
1529 .id_table = mptspi_pci_table,
1530 .probe = mptspi_probe,
1531 .remove = __devexit_p(mptscsih_remove),
1532 .shutdown = mptscsih_shutdown,
1533 #ifdef CONFIG_PM
1534 .suspend = mptscsih_suspend,
1535 .resume = mptspi_resume,
1536 #endif
1537 };
1538
1539 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1540 /**
1541 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1542 *
1543 * Returns 0 for success, non-zero for failure.
1544 */
1545 static int __init
1546 mptspi_init(void)
1547 {
1548 int error;
1549
1550 show_mptmod_ver(my_NAME, my_VERSION);
1551
1552 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1553 if (!mptspi_transport_template)
1554 return -ENODEV;
1555
1556 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1557 "mptscsih_io_done");
1558 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1559 "mptscsih_taskmgmt_complete");
1560 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1561 MPTSPI_DRIVER, "mptscsih_scandv_complete");
1562
1563 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1564 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1565
1566 error = pci_register_driver(&mptspi_driver);
1567 if (error)
1568 spi_release_transport(mptspi_transport_template);
1569
1570 return error;
1571 }
1572
1573 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1574 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1575 /**
1576 * mptspi_exit - Unregisters MPT adapter(s)
1577 */
1578 static void __exit
1579 mptspi_exit(void)
1580 {
1581 pci_unregister_driver(&mptspi_driver);
1582
1583 mpt_reset_deregister(mptspiDoneCtx);
1584 mpt_event_deregister(mptspiDoneCtx);
1585
1586 mpt_deregister(mptspiInternalCtx);
1587 mpt_deregister(mptspiTaskCtx);
1588 mpt_deregister(mptspiDoneCtx);
1589 spi_release_transport(mptspi_transport_template);
1590 }
1591
1592 module_init(mptspi_init);
1593 module_exit(mptspi_exit);
Ubuntu Artful kernel mirror