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