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