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