?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acpi_pad: build only on X86
[linux-2.6/linux-acpi-2.6.git] / drivers / message / fusion / mptspi.c
blobc5b808fd55ba6fc2b523939836abe347e85aeeea
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 ioc->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 int
618 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
619 {
620 MPT_ADAPTER *ioc = hd->ioc;
621 MpiRaidActionRequest_t *pReq;
622 MPT_FRAME_HDR *mf;
623 int ret;
624 unsigned long timeleft;
625
626 mutex_lock(&ioc->internal_cmds.mutex);
627
628 /* Get and Populate a free Frame
629 */
630 if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
631 dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
632 "%s: no msg frames!\n", ioc->name, __func__));
633 ret = -EAGAIN;
634 goto out;
635 }
636 pReq = (MpiRaidActionRequest_t *)mf;
637 if (quiesce)
638 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
639 else
640 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
641 pReq->Reserved1 = 0;
642 pReq->ChainOffset = 0;
643 pReq->Function = MPI_FUNCTION_RAID_ACTION;
644 pReq->VolumeID = id;
645 pReq->VolumeBus = channel;
646 pReq->PhysDiskNum = 0;
647 pReq->MsgFlags = 0;
648 pReq->Reserved2 = 0;
649 pReq->ActionDataWord = 0; /* Reserved for this action */
650
651 ioc->add_sge((char *)&pReq->ActionDataSGE,
652 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
653
654 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
655 ioc->name, pReq->Action, channel, id));
656
657 INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
658 mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
659 timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
660 if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
661 ret = -ETIME;
662 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
663 ioc->name, __func__));
664 if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
665 goto out;
666 if (!timeleft) {
667 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
668 ioc->name, __func__);
669 mpt_HardResetHandler(ioc, CAN_SLEEP);
670 mpt_free_msg_frame(ioc, mf);
671 }
672 goto out;
673 }
674
675 ret = ioc->internal_cmds.completion_code;
676
677 out:
678 CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
679 mutex_unlock(&ioc->internal_cmds.mutex);
680 return ret;
681 }
682
683 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
684 struct scsi_device *sdev)
685 {
686 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
687 MPT_ADAPTER *ioc = hd->ioc;
688
689 /* no DV on RAID devices */
690 if (sdev->channel == 0 &&
691 mptspi_is_raid(hd, sdev->id))
692 return;
693
694 /* If this is a piece of a RAID, then quiesce first */
695 if (sdev->channel == 1 &&
696 mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
697 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
698 "Integrated RAID quiesce failed\n", ioc->name);
699 return;
700 }
701
702 hd->spi_pending |= (1 << sdev->id);
703 spi_dv_device(sdev);
704 hd->spi_pending &= ~(1 << sdev->id);
705
706 if (sdev->channel == 1 &&
707 mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
708 starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
709 "Integrated RAID resume failed\n", ioc->name);
710
711 mptspi_read_parameters(sdev->sdev_target);
712 spi_display_xfer_agreement(sdev->sdev_target);
713 mptspi_read_parameters(sdev->sdev_target);
714 }
715
716 static int mptspi_slave_alloc(struct scsi_device *sdev)
717 {
718 MPT_SCSI_HOST *hd = shost_priv(sdev->host);
719 VirtTarget *vtarget;
720 VirtDevice *vdevice;
721 struct scsi_target *starget;
722 MPT_ADAPTER *ioc = hd->ioc;
723
724 if (sdev->channel == 1 &&
725 mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
726 return -ENXIO;
727
728 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
729 if (!vdevice) {
730 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
731 ioc->name, sizeof(VirtDevice));
732 return -ENOMEM;
733 }
734
735 vdevice->lun = sdev->lun;
736 sdev->hostdata = vdevice;
737
738 starget = scsi_target(sdev);
739 vtarget = starget->hostdata;
740 vdevice->vtarget = vtarget;
741 vtarget->num_luns++;
742
743 if (sdev->channel == 1)
744 sdev->no_uld_attach = 1;
745
746 return 0;
747 }
748
749 static int mptspi_slave_configure(struct scsi_device *sdev)
750 {
751 struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
752 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
753 int ret;
754
755 mptspi_initTarget(hd, vtarget, sdev);
756
757 ret = mptscsih_slave_configure(sdev);
758
759 if (ret)
760 return ret;
761
762 ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
763 " max_offset=0x%02x max_width=%d\n", hd->ioc->name,
764 sdev->id, spi_min_period(scsi_target(sdev)),
765 spi_max_offset(scsi_target(sdev)),
766 spi_max_width(scsi_target(sdev))));
767
768 if ((sdev->channel == 1 ||
769 !(mptspi_is_raid(hd, sdev->id))) &&
770 !spi_initial_dv(sdev->sdev_target))
771 mptspi_dv_device(hd, sdev);
772
773 return 0;
774 }
775
776 static int
777 mptspi_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
778 {
779 struct _MPT_SCSI_HOST *hd = shost_priv(SCpnt->device->host);
780 VirtDevice *vdevice = SCpnt->device->hostdata;
781 MPT_ADAPTER *ioc = hd->ioc;
782
783 if (!vdevice || !vdevice->vtarget) {
784 SCpnt->result = DID_NO_CONNECT << 16;
785 done(SCpnt);
786 return 0;
787 }
788
789 if (SCpnt->device->channel == 1 &&
790 mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
791 SCpnt->result = DID_NO_CONNECT << 16;
792 done(SCpnt);
793 return 0;
794 }
795
796 if (spi_dv_pending(scsi_target(SCpnt->device)))
797 ddvprintk(ioc, scsi_print_command(SCpnt));
798
799 return mptscsih_qcmd(SCpnt,done);
800 }
801
802 static void mptspi_slave_destroy(struct scsi_device *sdev)
803 {
804 struct scsi_target *starget = scsi_target(sdev);
805 VirtTarget *vtarget = starget->hostdata;
806 VirtDevice *vdevice = sdev->hostdata;
807
808 /* Will this be the last lun on a non-raid device? */
809 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
810 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
811
812 /* Async Narrow */
813 pg1.RequestedParameters = 0;
814 pg1.Reserved = 0;
815 pg1.Configuration = 0;
816
817 mptspi_write_spi_device_pg1(starget, &pg1);
818 }
819
820 mptscsih_slave_destroy(sdev);
821 }
822
823 static struct scsi_host_template mptspi_driver_template = {
824 .module = THIS_MODULE,
825 .proc_name = "mptspi",
826 .proc_info = mptscsih_proc_info,
827 .name = "MPT SPI Host",
828 .info = mptscsih_info,
829 .queuecommand = mptspi_qcmd,
830 .target_alloc = mptspi_target_alloc,
831 .slave_alloc = mptspi_slave_alloc,
832 .slave_configure = mptspi_slave_configure,
833 .target_destroy = mptspi_target_destroy,
834 .slave_destroy = mptspi_slave_destroy,
835 .change_queue_depth = mptscsih_change_queue_depth,
836 .eh_abort_handler = mptscsih_abort,
837 .eh_device_reset_handler = mptscsih_dev_reset,
838 .eh_bus_reset_handler = mptscsih_bus_reset,
839 .eh_host_reset_handler = mptscsih_host_reset,
840 .bios_param = mptscsih_bios_param,
841 .can_queue = MPT_SCSI_CAN_QUEUE,
842 .this_id = -1,
843 .sg_tablesize = MPT_SCSI_SG_DEPTH,
844 .max_sectors = 8192,
845 .cmd_per_lun = 7,
846 .use_clustering = ENABLE_CLUSTERING,
847 .shost_attrs = mptscsih_host_attrs,
848 };
849
850 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
851 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
852 {
853 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
854 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
855 struct _MPT_ADAPTER *ioc = hd->ioc;
856 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
857 dma_addr_t pg1_dma;
858 int size;
859 struct _x_config_parms cfg;
860 struct _CONFIG_PAGE_HEADER hdr;
861 int err = -EBUSY;
862
863 /* don't allow updating nego parameters on RAID devices */
864 if (starget->channel == 0 &&
865 mptspi_is_raid(hd, starget->id))
866 return -1;
867
868 size = ioc->spi_data.sdp1length * 4;
869
870 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
871 if (pg1 == NULL) {
872 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
873 "dma_alloc_coherent for parameters failed\n", ioc->name);
874 return -EINVAL;
875 }
876
877 memset(&hdr, 0, sizeof(hdr));
878
879 hdr.PageVersion = ioc->spi_data.sdp1version;
880 hdr.PageLength = ioc->spi_data.sdp1length;
881 hdr.PageNumber = 1;
882 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
883
884 memset(&cfg, 0, sizeof(cfg));
885
886 cfg.cfghdr.hdr = &hdr;
887 cfg.physAddr = pg1_dma;
888 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
889 cfg.dir = 1;
890 cfg.pageAddr = starget->id;
891
892 memcpy(pg1, pass_pg1, size);
893
894 pg1->Header.PageVersion = hdr.PageVersion;
895 pg1->Header.PageLength = hdr.PageLength;
896 pg1->Header.PageNumber = hdr.PageNumber;
897 pg1->Header.PageType = hdr.PageType;
898
899 mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
900
901 if (mpt_config(ioc, &cfg)) {
902 starget_printk(KERN_ERR, starget, MYIOC_s_FMT
903 "mpt_config failed\n", ioc->name);
904 goto out_free;
905 }
906 err = 0;
907
908 out_free:
909 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
910 return err;
911 }
912
913 static void mptspi_write_offset(struct scsi_target *starget, int offset)
914 {
915 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
916 u32 nego;
917
918 if (offset < 0)
919 offset = 0;
920
921 if (offset > 255)
922 offset = 255;
923
924 if (spi_offset(starget) == -1)
925 mptspi_read_parameters(starget);
926
927 spi_offset(starget) = offset;
928
929 nego = mptspi_getRP(starget);
930
931 pg1.RequestedParameters = cpu_to_le32(nego);
932 pg1.Reserved = 0;
933 pg1.Configuration = 0;
934
935 mptspi_write_spi_device_pg1(starget, &pg1);
936 }
937
938 static void mptspi_write_period(struct scsi_target *starget, int period)
939 {
940 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
941 u32 nego;
942
943 if (period < 8)
944 period = 8;
945
946 if (period > 255)
947 period = 255;
948
949 if (spi_period(starget) == -1)
950 mptspi_read_parameters(starget);
951
952 if (period == 8) {
953 spi_iu(starget) = 1;
954 spi_dt(starget) = 1;
955 } else if (period == 9) {
956 spi_dt(starget) = 1;
957 }
958
959 spi_period(starget) = period;
960
961 nego = mptspi_getRP(starget);
962
963 pg1.RequestedParameters = cpu_to_le32(nego);
964 pg1.Reserved = 0;
965 pg1.Configuration = 0;
966
967 mptspi_write_spi_device_pg1(starget, &pg1);
968 }
969
970 static void mptspi_write_dt(struct scsi_target *starget, int dt)
971 {
972 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
973 u32 nego;
974
975 if (spi_period(starget) == -1)
976 mptspi_read_parameters(starget);
977
978 if (!dt && spi_period(starget) < 10)
979 spi_period(starget) = 10;
980
981 spi_dt(starget) = dt;
982
983 nego = mptspi_getRP(starget);
984
985
986 pg1.RequestedParameters = cpu_to_le32(nego);
987 pg1.Reserved = 0;
988 pg1.Configuration = 0;
989
990 mptspi_write_spi_device_pg1(starget, &pg1);
991 }
992
993 static void mptspi_write_iu(struct scsi_target *starget, int iu)
994 {
995 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
996 u32 nego;
997
998 if (spi_period(starget) == -1)
999 mptspi_read_parameters(starget);
1000
1001 if (!iu && spi_period(starget) < 9)
1002 spi_period(starget) = 9;
1003
1004 spi_iu(starget) = iu;
1005
1006 nego = mptspi_getRP(starget);
1007
1008 pg1.RequestedParameters = cpu_to_le32(nego);
1009 pg1.Reserved = 0;
1010 pg1.Configuration = 0;
1011
1012 mptspi_write_spi_device_pg1(starget, &pg1);
1013 }
1014
1015 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
1016 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1017 { \
1018 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
1019 u32 nego; \
1020 \
1021 spi_##parm(starget) = parm; \
1022 \
1023 nego = mptspi_getRP(starget); \
1024 \
1025 pg1.RequestedParameters = cpu_to_le32(nego); \
1026 pg1.Reserved = 0; \
1027 pg1.Configuration = 0; \
1028 \
1029 mptspi_write_spi_device_pg1(starget, &pg1); \
1030 }
1031
1032 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1033 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1034 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1035 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1036 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1037
1038 static void mptspi_write_qas(struct scsi_target *starget, int qas)
1039 {
1040 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1041 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1042 struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1043 VirtTarget *vtarget = starget->hostdata;
1044 u32 nego;
1045
1046 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1047 hd->ioc->spi_data.noQas)
1048 spi_qas(starget) = 0;
1049 else
1050 spi_qas(starget) = qas;
1051
1052 nego = mptspi_getRP(starget);
1053
1054 pg1.RequestedParameters = cpu_to_le32(nego);
1055 pg1.Reserved = 0;
1056 pg1.Configuration = 0;
1057
1058 mptspi_write_spi_device_pg1(starget, &pg1);
1059 }
1060
1061 static void mptspi_write_width(struct scsi_target *starget, int width)
1062 {
1063 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1064 u32 nego;
1065
1066 if (!width) {
1067 spi_dt(starget) = 0;
1068 if (spi_period(starget) < 10)
1069 spi_period(starget) = 10;
1070 }
1071
1072 spi_width(starget) = width;
1073
1074 nego = mptspi_getRP(starget);
1075
1076 pg1.RequestedParameters = cpu_to_le32(nego);
1077 pg1.Reserved = 0;
1078 pg1.Configuration = 0;
1079
1080 mptspi_write_spi_device_pg1(starget, &pg1);
1081 }
1082
1083 struct work_queue_wrapper {
1084 struct work_struct work;
1085 struct _MPT_SCSI_HOST *hd;
1086 int disk;
1087 };
1088
1089 static void mpt_work_wrapper(struct work_struct *work)
1090 {
1091 struct work_queue_wrapper *wqw =
1092 container_of(work, struct work_queue_wrapper, work);
1093 struct _MPT_SCSI_HOST *hd = wqw->hd;
1094 MPT_ADAPTER *ioc = hd->ioc;
1095 struct Scsi_Host *shost = ioc->sh;
1096 struct scsi_device *sdev;
1097 int disk = wqw->disk;
1098 struct _CONFIG_PAGE_IOC_3 *pg3;
1099
1100 kfree(wqw);
1101
1102 mpt_findImVolumes(ioc);
1103 pg3 = ioc->raid_data.pIocPg3;
1104 if (!pg3)
1105 return;
1106
1107 shost_for_each_device(sdev,shost) {
1108 struct scsi_target *starget = scsi_target(sdev);
1109 VirtTarget *vtarget = starget->hostdata;
1110
1111 /* only want to search RAID components */
1112 if (sdev->channel != 1)
1113 continue;
1114
1115 /* The id is the raid PhysDiskNum, even if
1116 * starget->id is the actual target address */
1117 if(vtarget->id != disk)
1118 continue;
1119
1120 starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1121 "Integrated RAID requests DV of new device\n", ioc->name);
1122 mptspi_dv_device(hd, sdev);
1123 }
1124 shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1125 "Integrated RAID detects new device %d\n", ioc->name, disk);
1126 scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, 1);
1127 }
1128
1129
1130 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1131 {
1132 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1133 MPT_ADAPTER *ioc = hd->ioc;
1134
1135 if (!wqw) {
1136 shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1137 "Failed to act on RAID event for physical disk %d\n",
1138 ioc->name, disk);
1139 return;
1140 }
1141 INIT_WORK(&wqw->work, mpt_work_wrapper);
1142 wqw->hd = hd;
1143 wqw->disk = disk;
1144
1145 schedule_work(&wqw->work);
1146 }
1147
1148 static int
1149 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1150 {
1151 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1152 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1153
1154 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
1155 int reason
1156 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1157
1158 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1159 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1160 mpt_dv_raid(hd, disk);
1161 }
1162 }
1163 return mptscsih_event_process(ioc, pEvReply);
1164 }
1165
1166 static int
1167 mptspi_deny_binding(struct scsi_target *starget)
1168 {
1169 struct _MPT_SCSI_HOST *hd =
1170 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1171 return ((mptspi_is_raid(hd, starget->id)) &&
1172 starget->channel == 0) ? 1 : 0;
1173 }
1174
1175 static struct spi_function_template mptspi_transport_functions = {
1176 .get_offset = mptspi_read_parameters,
1177 .set_offset = mptspi_write_offset,
1178 .show_offset = 1,
1179 .get_period = mptspi_read_parameters,
1180 .set_period = mptspi_write_period,
1181 .show_period = 1,
1182 .get_width = mptspi_read_parameters,
1183 .set_width = mptspi_write_width,
1184 .show_width = 1,
1185 .get_iu = mptspi_read_parameters,
1186 .set_iu = mptspi_write_iu,
1187 .show_iu = 1,
1188 .get_dt = mptspi_read_parameters,
1189 .set_dt = mptspi_write_dt,
1190 .show_dt = 1,
1191 .get_qas = mptspi_read_parameters,
1192 .set_qas = mptspi_write_qas,
1193 .show_qas = 1,
1194 .get_wr_flow = mptspi_read_parameters,
1195 .set_wr_flow = mptspi_write_wr_flow,
1196 .show_wr_flow = 1,
1197 .get_rd_strm = mptspi_read_parameters,
1198 .set_rd_strm = mptspi_write_rd_strm,
1199 .show_rd_strm = 1,
1200 .get_rti = mptspi_read_parameters,
1201 .set_rti = mptspi_write_rti,
1202 .show_rti = 1,
1203 .get_pcomp_en = mptspi_read_parameters,
1204 .set_pcomp_en = mptspi_write_pcomp_en,
1205 .show_pcomp_en = 1,
1206 .get_hold_mcs = mptspi_read_parameters,
1207 .set_hold_mcs = mptspi_write_hold_mcs,
1208 .show_hold_mcs = 1,
1209 .deny_binding = mptspi_deny_binding,
1210 };
1211
1212 /****************************************************************************
1213 * Supported hardware
1214 */
1215
1216 static struct pci_device_id mptspi_pci_table[] = {
1217 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1218 PCI_ANY_ID, PCI_ANY_ID },
1219 { PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1220 PCI_ANY_ID, PCI_ANY_ID },
1221 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1222 PCI_ANY_ID, PCI_ANY_ID },
1223 {0} /* Terminating entry */
1224 };
1225 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1226
1227
1228 /*
1229 * renegotiate for a given target
1230 */
1231 static void
1232 mptspi_dv_renegotiate_work(struct work_struct *work)
1233 {
1234 struct work_queue_wrapper *wqw =
1235 container_of(work, struct work_queue_wrapper, work);
1236 struct _MPT_SCSI_HOST *hd = wqw->hd;
1237 struct scsi_device *sdev;
1238 struct scsi_target *starget;
1239 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1240 u32 nego;
1241 MPT_ADAPTER *ioc = hd->ioc;
1242
1243 kfree(wqw);
1244
1245 if (hd->spi_pending) {
1246 shost_for_each_device(sdev, ioc->sh) {
1247 if (hd->spi_pending & (1 << sdev->id))
1248 continue;
1249 starget = scsi_target(sdev);
1250 nego = mptspi_getRP(starget);
1251 pg1.RequestedParameters = cpu_to_le32(nego);
1252 pg1.Reserved = 0;
1253 pg1.Configuration = 0;
1254 mptspi_write_spi_device_pg1(starget, &pg1);
1255 }
1256 } else {
1257 shost_for_each_device(sdev, ioc->sh)
1258 mptspi_dv_device(hd, sdev);
1259 }
1260 }
1261
1262 static void
1263 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1264 {
1265 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1266
1267 if (!wqw)
1268 return;
1269
1270 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1271 wqw->hd = hd;
1272
1273 schedule_work(&wqw->work);
1274 }
1275
1276 /*
1277 * spi module reset handler
1278 */
1279 static int
1280 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1281 {
1282 int rc;
1283
1284 rc = mptscsih_ioc_reset(ioc, reset_phase);
1285
1286 /* only try to do a renegotiation if we're properly set up
1287 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1288 if (reset_phase == MPT_IOC_POST_RESET &&
1289 ioc->sh) {
1290 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1291
1292 mptspi_dv_renegotiate(hd);
1293 }
1294
1295 return rc;
1296 }
1297
1298 #ifdef CONFIG_PM
1299 /*
1300 * spi module resume handler
1301 */
1302 static int
1303 mptspi_resume(struct pci_dev *pdev)
1304 {
1305 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1306 struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1307 int rc;
1308
1309 rc = mptscsih_resume(pdev);
1310 mptspi_dv_renegotiate(hd);
1311
1312 return rc;
1313 }
1314 #endif
1315
1316 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1317 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1318 /*
1319 * mptspi_probe - Installs scsi devices per bus.
1320 * @pdev: Pointer to pci_dev structure
1321 *
1322 * Returns 0 for success, non-zero for failure.
1323 *
1324 */
1325 static int
1326 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1327 {
1328 struct Scsi_Host *sh;
1329 MPT_SCSI_HOST *hd;
1330 MPT_ADAPTER *ioc;
1331 unsigned long flags;
1332 int ii;
1333 int numSGE = 0;
1334 int scale;
1335 int ioc_cap;
1336 int error=0;
1337 int r;
1338
1339 if ((r = mpt_attach(pdev,id)) != 0)
1340 return r;
1341
1342 ioc = pci_get_drvdata(pdev);
1343 ioc->DoneCtx = mptspiDoneCtx;
1344 ioc->TaskCtx = mptspiTaskCtx;
1345 ioc->InternalCtx = mptspiInternalCtx;
1346
1347 /* Added sanity check on readiness of the MPT adapter.
1348 */
1349 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1350 printk(MYIOC_s_WARN_FMT
1351 "Skipping because it's not operational!\n",
1352 ioc->name);
1353 error = -ENODEV;
1354 goto out_mptspi_probe;
1355 }
1356
1357 if (!ioc->active) {
1358 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1359 ioc->name);
1360 error = -ENODEV;
1361 goto out_mptspi_probe;
1362 }
1363
1364 /* Sanity check - ensure at least 1 port is INITIATOR capable
1365 */
1366 ioc_cap = 0;
1367 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1368 if (ioc->pfacts[ii].ProtocolFlags &
1369 MPI_PORTFACTS_PROTOCOL_INITIATOR)
1370 ioc_cap ++;
1371 }
1372
1373 if (!ioc_cap) {
1374 printk(MYIOC_s_WARN_FMT
1375 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1376 ioc->name, ioc);
1377 return 0;
1378 }
1379
1380 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1381
1382 if (!sh) {
1383 printk(MYIOC_s_WARN_FMT
1384 "Unable to register controller with SCSI subsystem\n",
1385 ioc->name);
1386 error = -1;
1387 goto out_mptspi_probe;
1388 }
1389
1390 spin_lock_irqsave(&ioc->FreeQlock, flags);
1391
1392 /* Attach the SCSI Host to the IOC structure
1393 */
1394 ioc->sh = sh;
1395
1396 sh->io_port = 0;
1397 sh->n_io_port = 0;
1398 sh->irq = 0;
1399
1400 /* set 16 byte cdb's */
1401 sh->max_cmd_len = 16;
1402
1403 /* Yikes! This is important!
1404 * Otherwise, by default, linux
1405 * only scans target IDs 0-7!
1406 * pfactsN->MaxDevices unreliable
1407 * (not supported in early
1408 * versions of the FW).
1409 * max_id = 1 + actual max id,
1410 * max_lun = 1 + actual last lun,
1411 * see hosts.h :o(
1412 */
1413 sh->max_id = ioc->devices_per_bus;
1414
1415 sh->max_lun = MPT_LAST_LUN + 1;
1416 /*
1417 * If RAID Firmware Detected, setup virtual channel
1418 */
1419 if (ioc->ir_firmware)
1420 sh->max_channel = 1;
1421 else
1422 sh->max_channel = 0;
1423 sh->this_id = ioc->pfacts[0].PortSCSIID;
1424
1425 /* Required entry.
1426 */
1427 sh->unique_id = ioc->id;
1428
1429 /* Verify that we won't exceed the maximum
1430 * number of chain buffers
1431 * We can optimize: ZZ = req_sz/sizeof(SGE)
1432 * For 32bit SGE's:
1433 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1434 * + (req_sz - 64)/sizeof(SGE)
1435 * A slightly different algorithm is required for
1436 * 64bit SGEs.
1437 */
1438 scale = ioc->req_sz/ioc->SGE_size;
1439 if (ioc->sg_addr_size == sizeof(u64)) {
1440 numSGE = (scale - 1) *
1441 (ioc->facts.MaxChainDepth-1) + scale +
1442 (ioc->req_sz - 60) / ioc->SGE_size;
1443 } else {
1444 numSGE = 1 + (scale - 1) *
1445 (ioc->facts.MaxChainDepth-1) + scale +
1446 (ioc->req_sz - 64) / ioc->SGE_size;
1447 }
1448
1449 if (numSGE < sh->sg_tablesize) {
1450 /* Reset this value */
1451 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1452 "Resetting sg_tablesize to %d from %d\n",
1453 ioc->name, numSGE, sh->sg_tablesize));
1454 sh->sg_tablesize = numSGE;
1455 }
1456
1457 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1458
1459 hd = shost_priv(sh);
1460 hd->ioc = ioc;
1461
1462 /* SCSI needs scsi_cmnd lookup table!
1463 * (with size equal to req_depth*PtrSz!)
1464 */
1465 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1466 if (!ioc->ScsiLookup) {
1467 error = -ENOMEM;
1468 goto out_mptspi_probe;
1469 }
1470 spin_lock_init(&ioc->scsi_lookup_lock);
1471
1472 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1473 ioc->name, ioc->ScsiLookup));
1474
1475 /* Clear the TM flags
1476 */
1477 hd->abortSCpnt = NULL;
1478
1479 /* Clear the pointer used to store
1480 * single-threaded commands, i.e., those
1481 * issued during a bus scan, dv and
1482 * configuration pages.
1483 */
1484 hd->cmdPtr = NULL;
1485
1486 /* Initialize this SCSI Hosts' timers
1487 * To use, set the timer expires field
1488 * and add_timer
1489 */
1490 init_timer(&hd->timer);
1491 hd->timer.data = (unsigned long) hd;
1492 hd->timer.function = mptscsih_timer_expired;
1493
1494 ioc->spi_data.Saf_Te = mpt_saf_te;
1495
1496 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1497 ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1498 "saf_te %x\n",
1499 ioc->name,
1500 mpt_saf_te));
1501 ioc->spi_data.noQas = 0;
1502
1503 hd->last_queue_full = 0;
1504 hd->spi_pending = 0;
1505
1506 /* Some versions of the firmware don't support page 0; without
1507 * that we can't get the parameters */
1508 if (ioc->spi_data.sdp0length != 0)
1509 sh->transportt = mptspi_transport_template;
1510
1511 error = scsi_add_host (sh, &ioc->pcidev->dev);
1512 if(error) {
1513 dprintk(ioc, printk(MYIOC_s_ERR_FMT
1514 "scsi_add_host failed\n", ioc->name));
1515 goto out_mptspi_probe;
1516 }
1517
1518 /*
1519 * issue internal bus reset
1520 */
1521 if (ioc->spi_data.bus_reset)
1522 mptscsih_IssueTaskMgmt(hd,
1523 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1524 0, 0, 0, 0, 5);
1525
1526 scsi_scan_host(sh);
1527 return 0;
1528
1529 out_mptspi_probe:
1530
1531 mptscsih_remove(pdev);
1532 return error;
1533 }
1534
1535 static struct pci_driver mptspi_driver = {
1536 .name = "mptspi",
1537 .id_table = mptspi_pci_table,
1538 .probe = mptspi_probe,
1539 .remove = __devexit_p(mptscsih_remove),
1540 .shutdown = mptscsih_shutdown,
1541 #ifdef CONFIG_PM
1542 .suspend = mptscsih_suspend,
1543 .resume = mptspi_resume,
1544 #endif
1545 };
1546
1547 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1548 /**
1549 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1550 *
1551 * Returns 0 for success, non-zero for failure.
1552 */
1553 static int __init
1554 mptspi_init(void)
1555 {
1556 int error;
1557
1558 show_mptmod_ver(my_NAME, my_VERSION);
1559
1560 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1561 if (!mptspi_transport_template)
1562 return -ENODEV;
1563
1564 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1565 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1566 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1567
1568 mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1569 mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1570
1571 error = pci_register_driver(&mptspi_driver);
1572 if (error)
1573 spi_release_transport(mptspi_transport_template);
1574
1575 return error;
1576 }
1577
1578 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1579 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1580 /**
1581 * mptspi_exit - Unregisters MPT adapter(s)
1582 */
1583 static void __exit
1584 mptspi_exit(void)
1585 {
1586 pci_unregister_driver(&mptspi_driver);
1587
1588 mpt_reset_deregister(mptspiDoneCtx);
1589 mpt_event_deregister(mptspiDoneCtx);
1590
1591 mpt_deregister(mptspiInternalCtx);
1592 mpt_deregister(mptspiTaskCtx);
1593 mpt_deregister(mptspiDoneCtx);
1594 spi_release_transport(mptspi_transport_template);
1595 }
1596
1597 module_init(mptspi_init);
1598 module_exit(mptspi_exit);
Linux ACPI git tree (mirror)