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