projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' into upstream-fixes
[deliverable/linux.git] / drivers / message / fusion / mptspi.c
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-2005 LSI Logic Corporation
7 * (mailto:mpt_linux_developer@lsil.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/sched.h>
58 #include <linux/workqueue.h>
59 #include <linux/raid_class.h>
60
61 #include <scsi/scsi.h>
62 #include <scsi/scsi_cmnd.h>
63 #include <scsi/scsi_device.h>
64 #include <scsi/scsi_host.h>
65 #include <scsi/scsi_tcq.h>
66 #include <scsi/scsi_transport.h>
67 #include <scsi/scsi_transport_spi.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
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 int mptspiDoneCtx = -1;
94 static int mptspiTaskCtx = -1;
95 static int mptspiInternalCtx = -1; /* Used only for internal commands */
96
97 static int mptspi_target_alloc(struct scsi_target *starget)
98 {
99 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
100 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
101 int ret;
102
103 if (hd == NULL)
104 return -ENODEV;
105
106 ret = mptscsih_target_alloc(starget);
107 if (ret)
108 return ret;
109
110 /* if we're a device on virtual channel 1 and we're not part
111 * of an array, just return here (otherwise the setup below
112 * may actually affect a real physical device on channel 0 */
113 if (starget->channel == 1 &&
114 mptscsih_raid_id_to_num(hd, starget->id) < 0)
115 return 0;
116
117 if (hd->ioc->spi_data.nvram &&
118 hd->ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
119 u32 nvram = hd->ioc->spi_data.nvram[starget->id];
120 spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
121 spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
122 } else {
123 spi_min_period(starget) = hd->ioc->spi_data.minSyncFactor;
124 spi_max_width(starget) = hd->ioc->spi_data.maxBusWidth;
125 }
126 spi_max_offset(starget) = hd->ioc->spi_data.maxSyncOffset;
127
128 spi_offset(starget) = 0;
129 mptspi_write_width(starget, 0);
130
131 return 0;
132 }
133
134 static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
135 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
136 {
137 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
138 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
139 struct _MPT_ADAPTER *ioc = hd->ioc;
140 struct _CONFIG_PAGE_SCSI_DEVICE_0 *pg0;
141 dma_addr_t pg0_dma;
142 int size;
143 struct _x_config_parms cfg;
144 struct _CONFIG_PAGE_HEADER hdr;
145 int err = -EBUSY;
146
147 /* No SPI parameters for RAID devices */
148 if (starget->channel == 0 &&
149 (hd->ioc->raid_data.isRaid & (1 << starget->id)))
150 return -1;
151
152 size = ioc->spi_data.sdp0length * 4;
153 /*
154 if (ioc->spi_data.sdp0length & 1)
155 size += size + 4;
156 size += 2048;
157 */
158
159 pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg0_dma, GFP_KERNEL);
160 if (pg0 == NULL) {
161 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
162 return -EINVAL;
163 }
164
165 memset(&hdr, 0, sizeof(hdr));
166
167 hdr.PageVersion = ioc->spi_data.sdp0version;
168 hdr.PageLength = ioc->spi_data.sdp0length;
169 hdr.PageNumber = 0;
170 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
171
172 memset(&cfg, 0, sizeof(cfg));
173
174 cfg.cfghdr.hdr = &hdr;
175 cfg.physAddr = pg0_dma;
176 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
177 cfg.dir = 0;
178 cfg.pageAddr = starget->id;
179
180 if (mpt_config(ioc, &cfg)) {
181 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
182 goto out_free;
183 }
184 err = 0;
185 memcpy(pass_pg0, pg0, size);
186
187 out_free:
188 dma_free_coherent(&ioc->pcidev->dev, size, pg0, pg0_dma);
189 return err;
190 }
191
192 static u32 mptspi_getRP(struct scsi_target *starget)
193 {
194 u32 nego = 0;
195
196 nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
197 nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
198 nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
199 nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
200 nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
201 nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
202 nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
203 nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
204
205 nego |= (spi_period(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
206 nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
207 nego |= spi_width(starget) ? MPI_SCSIDEVPAGE1_RP_WIDE : 0;
208
209 return nego;
210 }
211
212 static void mptspi_read_parameters(struct scsi_target *starget)
213 {
214 int nego;
215 struct _CONFIG_PAGE_SCSI_DEVICE_0 pg0;
216
217 mptspi_read_spi_device_pg0(starget, &pg0);
218
219 nego = le32_to_cpu(pg0.NegotiatedParameters);
220
221 spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
222 spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
223 spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
224 spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
225 spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
226 spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
227 spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
228 spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
229 spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
230 spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
231 spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
232 }
233
234 static int
235 mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, int disk)
236 {
237 MpiRaidActionRequest_t *pReq;
238 MPT_FRAME_HDR *mf;
239
240 /* Get and Populate a free Frame
241 */
242 if ((mf = mpt_get_msg_frame(hd->ioc->InternalCtx, hd->ioc)) == NULL) {
243 ddvprintk((MYIOC_s_WARN_FMT "_do_raid: no msg frames!\n",
244 hd->ioc->name));
245 return -EAGAIN;
246 }
247 pReq = (MpiRaidActionRequest_t *)mf;
248 if (quiesce)
249 pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
250 else
251 pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
252 pReq->Reserved1 = 0;
253 pReq->ChainOffset = 0;
254 pReq->Function = MPI_FUNCTION_RAID_ACTION;
255 pReq->VolumeID = disk;
256 pReq->VolumeBus = 0;
257 pReq->PhysDiskNum = 0;
258 pReq->MsgFlags = 0;
259 pReq->Reserved2 = 0;
260 pReq->ActionDataWord = 0; /* Reserved for this action */
261
262 mpt_add_sge((char *)&pReq->ActionDataSGE,
263 MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
264
265 ddvprintk((MYIOC_s_INFO_FMT "RAID Volume action %x id %d\n",
266 hd->ioc->name, action, io->id));
267
268 hd->pLocal = NULL;
269 hd->timer.expires = jiffies + HZ*10; /* 10 second timeout */
270 hd->scandv_wait_done = 0;
271
272 /* Save cmd pointer, for resource free if timeout or
273 * FW reload occurs
274 */
275 hd->cmdPtr = mf;
276
277 add_timer(&hd->timer);
278 mpt_put_msg_frame(hd->ioc->InternalCtx, hd->ioc, mf);
279 wait_event(hd->scandv_waitq, hd->scandv_wait_done);
280
281 if ((hd->pLocal == NULL) || (hd->pLocal->completion != 0))
282 return -1;
283
284 return 0;
285 }
286
287 static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
288 struct scsi_device *sdev)
289 {
290 VirtTarget *vtarget = scsi_target(sdev)->hostdata;
291
292 /* no DV on RAID devices */
293 if (sdev->channel == 0 &&
294 (hd->ioc->raid_data.isRaid & (1 << sdev->id)))
295 return;
296
297 /* If this is a piece of a RAID, then quiesce first */
298 if (sdev->channel == 1 &&
299 mptscsih_quiesce_raid(hd, 1, vtarget->target_id) < 0) {
300 starget_printk(KERN_ERR, scsi_target(sdev),
301 "Integrated RAID quiesce failed\n");
302 return;
303 }
304
305 spi_dv_device(sdev);
306
307 if (sdev->channel == 1 &&
308 mptscsih_quiesce_raid(hd, 0, vtarget->target_id) < 0)
309 starget_printk(KERN_ERR, scsi_target(sdev),
310 "Integrated RAID resume failed\n");
311
312 mptspi_read_parameters(sdev->sdev_target);
313 spi_display_xfer_agreement(sdev->sdev_target);
314 mptspi_read_parameters(sdev->sdev_target);
315 }
316
317 static int mptspi_slave_alloc(struct scsi_device *sdev)
318 {
319 int ret;
320 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)sdev->host->hostdata;
321 /* gcc doesn't see that all uses of this variable occur within
322 * the if() statements, so stop it from whining */
323 int physdisknum = 0;
324
325 if (sdev->channel == 1) {
326 physdisknum = mptscsih_raid_id_to_num(hd, sdev->id);
327
328 if (physdisknum < 0)
329 return physdisknum;
330 }
331
332 ret = mptscsih_slave_alloc(sdev);
333
334 if (ret)
335 return ret;
336
337 if (sdev->channel == 1) {
338 VirtDevice *vdev = sdev->hostdata;
339 sdev->no_uld_attach = 1;
340 vdev->vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
341 /* The real channel for this device is zero */
342 vdev->vtarget->bus_id = 0;
343 /* The actual physdisknum (for RAID passthrough) */
344 vdev->vtarget->target_id = physdisknum;
345 }
346
347 return 0;
348 }
349
350 static int mptspi_slave_configure(struct scsi_device *sdev)
351 {
352 int ret = mptscsih_slave_configure(sdev);
353 struct _MPT_SCSI_HOST *hd =
354 (struct _MPT_SCSI_HOST *)sdev->host->hostdata;
355
356 if (ret)
357 return ret;
358
359 if ((sdev->channel == 1 ||
360 !(hd->ioc->raid_data.isRaid & (1 << sdev->id))) &&
361 !spi_initial_dv(sdev->sdev_target))
362 mptspi_dv_device(hd, sdev);
363
364 return 0;
365 }
366
367 static void mptspi_slave_destroy(struct scsi_device *sdev)
368 {
369 struct scsi_target *starget = scsi_target(sdev);
370 VirtTarget *vtarget = starget->hostdata;
371 VirtDevice *vdevice = sdev->hostdata;
372
373 /* Will this be the last lun on a non-raid device? */
374 if (vtarget->num_luns == 1 && vdevice->configured_lun) {
375 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
376
377 /* Async Narrow */
378 pg1.RequestedParameters = 0;
379 pg1.Reserved = 0;
380 pg1.Configuration = 0;
381
382 mptspi_write_spi_device_pg1(starget, &pg1);
383 }
384
385 mptscsih_slave_destroy(sdev);
386 }
387
388 static struct scsi_host_template mptspi_driver_template = {
389 .module = THIS_MODULE,
390 .proc_name = "mptspi",
391 .proc_info = mptscsih_proc_info,
392 .name = "MPT SPI Host",
393 .info = mptscsih_info,
394 .queuecommand = mptscsih_qcmd,
395 .target_alloc = mptspi_target_alloc,
396 .slave_alloc = mptspi_slave_alloc,
397 .slave_configure = mptspi_slave_configure,
398 .target_destroy = mptscsih_target_destroy,
399 .slave_destroy = mptspi_slave_destroy,
400 .change_queue_depth = mptscsih_change_queue_depth,
401 .eh_abort_handler = mptscsih_abort,
402 .eh_device_reset_handler = mptscsih_dev_reset,
403 .eh_bus_reset_handler = mptscsih_bus_reset,
404 .eh_host_reset_handler = mptscsih_host_reset,
405 .bios_param = mptscsih_bios_param,
406 .can_queue = MPT_SCSI_CAN_QUEUE,
407 .this_id = -1,
408 .sg_tablesize = MPT_SCSI_SG_DEPTH,
409 .max_sectors = 8192,
410 .cmd_per_lun = 7,
411 .use_clustering = ENABLE_CLUSTERING,
412 };
413
414 static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
415 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
416 {
417 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
418 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
419 struct _MPT_ADAPTER *ioc = hd->ioc;
420 struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
421 dma_addr_t pg1_dma;
422 int size;
423 struct _x_config_parms cfg;
424 struct _CONFIG_PAGE_HEADER hdr;
425 int err = -EBUSY;
426
427 /* don't allow updating nego parameters on RAID devices */
428 if (starget->channel == 0 &&
429 (hd->ioc->raid_data.isRaid & (1 << starget->id)))
430 return -1;
431
432 size = ioc->spi_data.sdp1length * 4;
433
434 pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
435 if (pg1 == NULL) {
436 starget_printk(KERN_ERR, starget, "dma_alloc_coherent for parameters failed\n");
437 return -EINVAL;
438 }
439
440 memset(&hdr, 0, sizeof(hdr));
441
442 hdr.PageVersion = ioc->spi_data.sdp1version;
443 hdr.PageLength = ioc->spi_data.sdp1length;
444 hdr.PageNumber = 1;
445 hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
446
447 memset(&cfg, 0, sizeof(cfg));
448
449 cfg.cfghdr.hdr = &hdr;
450 cfg.physAddr = pg1_dma;
451 cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
452 cfg.dir = 1;
453 cfg.pageAddr = starget->id;
454
455 memcpy(pg1, pass_pg1, size);
456
457 pg1->Header.PageVersion = hdr.PageVersion;
458 pg1->Header.PageLength = hdr.PageLength;
459 pg1->Header.PageNumber = hdr.PageNumber;
460 pg1->Header.PageType = hdr.PageType;
461
462 if (mpt_config(ioc, &cfg)) {
463 starget_printk(KERN_ERR, starget, "mpt_config failed\n");
464 goto out_free;
465 }
466 err = 0;
467
468 out_free:
469 dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
470 return err;
471 }
472
473 static void mptspi_write_offset(struct scsi_target *starget, int offset)
474 {
475 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
476 u32 nego;
477
478 if (offset < 0)
479 offset = 0;
480
481 if (offset > 255)
482 offset = 255;
483
484 if (spi_offset(starget) == -1)
485 mptspi_read_parameters(starget);
486
487 spi_offset(starget) = offset;
488
489 nego = mptspi_getRP(starget);
490
491 pg1.RequestedParameters = cpu_to_le32(nego);
492 pg1.Reserved = 0;
493 pg1.Configuration = 0;
494
495 mptspi_write_spi_device_pg1(starget, &pg1);
496 }
497
498 static void mptspi_write_period(struct scsi_target *starget, int period)
499 {
500 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
501 u32 nego;
502
503 if (period < 8)
504 period = 8;
505
506 if (period > 255)
507 period = 255;
508
509 if (spi_period(starget) == -1)
510 mptspi_read_parameters(starget);
511
512 if (period == 8) {
513 spi_iu(starget) = 1;
514 spi_dt(starget) = 1;
515 } else if (period == 9) {
516 spi_dt(starget) = 1;
517 }
518
519 spi_period(starget) = period;
520
521 nego = mptspi_getRP(starget);
522
523 pg1.RequestedParameters = cpu_to_le32(nego);
524 pg1.Reserved = 0;
525 pg1.Configuration = 0;
526
527 mptspi_write_spi_device_pg1(starget, &pg1);
528 }
529
530 static void mptspi_write_dt(struct scsi_target *starget, int dt)
531 {
532 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
533 u32 nego;
534
535 if (spi_period(starget) == -1)
536 mptspi_read_parameters(starget);
537
538 if (!dt && spi_period(starget) < 10)
539 spi_period(starget) = 10;
540
541 spi_dt(starget) = dt;
542
543 nego = mptspi_getRP(starget);
544
545
546 pg1.RequestedParameters = cpu_to_le32(nego);
547 pg1.Reserved = 0;
548 pg1.Configuration = 0;
549
550 mptspi_write_spi_device_pg1(starget, &pg1);
551 }
552
553 static void mptspi_write_iu(struct scsi_target *starget, int iu)
554 {
555 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
556 u32 nego;
557
558 if (spi_period(starget) == -1)
559 mptspi_read_parameters(starget);
560
561 if (!iu && spi_period(starget) < 9)
562 spi_period(starget) = 9;
563
564 spi_iu(starget) = iu;
565
566 nego = mptspi_getRP(starget);
567
568 pg1.RequestedParameters = cpu_to_le32(nego);
569 pg1.Reserved = 0;
570 pg1.Configuration = 0;
571
572 mptspi_write_spi_device_pg1(starget, &pg1);
573 }
574
575 #define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) \
576 static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
577 { \
578 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1; \
579 u32 nego; \
580 \
581 spi_##parm(starget) = parm; \
582 \
583 nego = mptspi_getRP(starget); \
584 \
585 pg1.RequestedParameters = cpu_to_le32(nego); \
586 pg1.Reserved = 0; \
587 pg1.Configuration = 0; \
588 \
589 mptspi_write_spi_device_pg1(starget, &pg1); \
590 }
591
592 MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
593 MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
594 MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
595 MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
596 MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
597
598 static void mptspi_write_qas(struct scsi_target *starget, int qas)
599 {
600 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
601 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
602 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)shost->hostdata;
603 VirtTarget *vtarget = starget->hostdata;
604 u32 nego;
605
606 if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
607 hd->ioc->spi_data.noQas)
608 spi_qas(starget) = 0;
609 else
610 spi_qas(starget) = qas;
611
612 nego = mptspi_getRP(starget);
613
614 pg1.RequestedParameters = cpu_to_le32(nego);
615 pg1.Reserved = 0;
616 pg1.Configuration = 0;
617
618 mptspi_write_spi_device_pg1(starget, &pg1);
619 }
620
621 static void mptspi_write_width(struct scsi_target *starget, int width)
622 {
623 struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
624 u32 nego;
625
626 if (!width) {
627 spi_dt(starget) = 0;
628 if (spi_period(starget) < 10)
629 spi_period(starget) = 10;
630 }
631
632 spi_width(starget) = width;
633
634 nego = mptspi_getRP(starget);
635
636 pg1.RequestedParameters = cpu_to_le32(nego);
637 pg1.Reserved = 0;
638 pg1.Configuration = 0;
639
640 mptspi_write_spi_device_pg1(starget, &pg1);
641 }
642
643 struct work_queue_wrapper {
644 struct work_struct work;
645 struct _MPT_SCSI_HOST *hd;
646 int disk;
647 };
648
649 static void mpt_work_wrapper(void *data)
650 {
651 struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
652 struct _MPT_SCSI_HOST *hd = wqw->hd;
653 struct Scsi_Host *shost = hd->ioc->sh;
654 struct scsi_device *sdev;
655 int disk = wqw->disk;
656 struct _CONFIG_PAGE_IOC_3 *pg3;
657
658 kfree(wqw);
659
660 mpt_findImVolumes(hd->ioc);
661 pg3 = hd->ioc->raid_data.pIocPg3;
662 if (!pg3)
663 return;
664
665 shost_for_each_device(sdev,shost) {
666 struct scsi_target *starget = scsi_target(sdev);
667 VirtTarget *vtarget = starget->hostdata;
668
669 /* only want to search RAID components */
670 if (sdev->channel != 1)
671 continue;
672
673 /* The target_id is the raid PhysDiskNum, even if
674 * starget->id is the actual target address */
675 if(vtarget->target_id != disk)
676 continue;
677
678 starget_printk(KERN_INFO, vtarget->starget,
679 "Integrated RAID requests DV of new device\n");
680 mptspi_dv_device(hd, sdev);
681 }
682 shost_printk(KERN_INFO, shost,
683 "Integrated RAID detects new device %d\n", disk);
684 scsi_scan_target(&hd->ioc->sh->shost_gendev, 1, disk, 0, 1);
685 }
686
687
688 static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
689 {
690 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
691
692 if (!wqw) {
693 shost_printk(KERN_ERR, hd->ioc->sh,
694 "Failed to act on RAID event for physical disk %d\n",
695 disk);
696 return;
697 }
698 INIT_WORK(&wqw->work, mpt_work_wrapper, wqw);
699 wqw->hd = hd;
700 wqw->disk = disk;
701
702 schedule_work(&wqw->work);
703 }
704
705 static int
706 mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
707 {
708 u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
709 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
710
711 if (hd && event == MPI_EVENT_INTEGRATED_RAID) {
712 int reason
713 = (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
714
715 if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
716 int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
717 mpt_dv_raid(hd, disk);
718 }
719 }
720 return mptscsih_event_process(ioc, pEvReply);
721 }
722
723 static int
724 mptspi_deny_binding(struct scsi_target *starget)
725 {
726 struct _MPT_SCSI_HOST *hd =
727 (struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
728 return ((hd->ioc->raid_data.isRaid & (1 << starget->id)) &&
729 starget->channel == 0) ? 1 : 0;
730 }
731
732 static struct spi_function_template mptspi_transport_functions = {
733 .get_offset = mptspi_read_parameters,
734 .set_offset = mptspi_write_offset,
735 .show_offset = 1,
736 .get_period = mptspi_read_parameters,
737 .set_period = mptspi_write_period,
738 .show_period = 1,
739 .get_width = mptspi_read_parameters,
740 .set_width = mptspi_write_width,
741 .show_width = 1,
742 .get_iu = mptspi_read_parameters,
743 .set_iu = mptspi_write_iu,
744 .show_iu = 1,
745 .get_dt = mptspi_read_parameters,
746 .set_dt = mptspi_write_dt,
747 .show_dt = 1,
748 .get_qas = mptspi_read_parameters,
749 .set_qas = mptspi_write_qas,
750 .show_qas = 1,
751 .get_wr_flow = mptspi_read_parameters,
752 .set_wr_flow = mptspi_write_wr_flow,
753 .show_wr_flow = 1,
754 .get_rd_strm = mptspi_read_parameters,
755 .set_rd_strm = mptspi_write_rd_strm,
756 .show_rd_strm = 1,
757 .get_rti = mptspi_read_parameters,
758 .set_rti = mptspi_write_rti,
759 .show_rti = 1,
760 .get_pcomp_en = mptspi_read_parameters,
761 .set_pcomp_en = mptspi_write_pcomp_en,
762 .show_pcomp_en = 1,
763 .get_hold_mcs = mptspi_read_parameters,
764 .set_hold_mcs = mptspi_write_hold_mcs,
765 .show_hold_mcs = 1,
766 .deny_binding = mptspi_deny_binding,
767 };
768
769 /****************************************************************************
770 * Supported hardware
771 */
772
773 static struct pci_device_id mptspi_pci_table[] = {
774 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
775 PCI_ANY_ID, PCI_ANY_ID },
776 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
777 PCI_ANY_ID, PCI_ANY_ID },
778 {0} /* Terminating entry */
779 };
780 MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
781
782
783 /*
784 * renegotiate for a given target
785 */
786 static void
787 mptspi_dv_renegotiate_work(void *data)
788 {
789 struct work_queue_wrapper *wqw = (struct work_queue_wrapper *)data;
790 struct _MPT_SCSI_HOST *hd = wqw->hd;
791 struct scsi_device *sdev;
792
793 kfree(wqw);
794
795 shost_for_each_device(sdev, hd->ioc->sh)
796 mptspi_dv_device(hd, sdev);
797 }
798
799 static void
800 mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
801 {
802 struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
803
804 if (!wqw)
805 return;
806
807 INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work, wqw);
808 wqw->hd = hd;
809
810 schedule_work(&wqw->work);
811 }
812
813 /*
814 * spi module reset handler
815 */
816 static int
817 mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
818 {
819 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
820 int rc;
821
822 rc = mptscsih_ioc_reset(ioc, reset_phase);
823
824 if (reset_phase == MPT_IOC_POST_RESET)
825 mptspi_dv_renegotiate(hd);
826
827 return rc;
828 }
829
830 #ifdef CONFIG_PM
831 /*
832 * spi module resume handler
833 */
834 static int
835 mptspi_resume(struct pci_dev *pdev)
836 {
837 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
838 struct _MPT_SCSI_HOST *hd = (struct _MPT_SCSI_HOST *)ioc->sh->hostdata;
839 int rc;
840
841 rc = mptscsih_resume(pdev);
842 mptspi_dv_renegotiate(hd);
843
844 return rc;
845 }
846 #endif
847
848 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
849 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
850 /*
851 * mptspi_probe - Installs scsi devices per bus.
852 * @pdev: Pointer to pci_dev structure
853 *
854 * Returns 0 for success, non-zero for failure.
855 *
856 */
857 static int
858 mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
859 {
860 struct Scsi_Host *sh;
861 MPT_SCSI_HOST *hd;
862 MPT_ADAPTER *ioc;
863 unsigned long flags;
864 int ii;
865 int numSGE = 0;
866 int scale;
867 int ioc_cap;
868 int error=0;
869 int r;
870
871 if ((r = mpt_attach(pdev,id)) != 0)
872 return r;
873
874 ioc = pci_get_drvdata(pdev);
875 ioc->DoneCtx = mptspiDoneCtx;
876 ioc->TaskCtx = mptspiTaskCtx;
877 ioc->InternalCtx = mptspiInternalCtx;
878
879 /* Added sanity check on readiness of the MPT adapter.
880 */
881 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
882 printk(MYIOC_s_WARN_FMT
883 "Skipping because it's not operational!\n",
884 ioc->name);
885 error = -ENODEV;
886 goto out_mptspi_probe;
887 }
888
889 if (!ioc->active) {
890 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
891 ioc->name);
892 error = -ENODEV;
893 goto out_mptspi_probe;
894 }
895
896 /* Sanity check - ensure at least 1 port is INITIATOR capable
897 */
898 ioc_cap = 0;
899 for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
900 if (ioc->pfacts[ii].ProtocolFlags &
901 MPI_PORTFACTS_PROTOCOL_INITIATOR)
902 ioc_cap ++;
903 }
904
905 if (!ioc_cap) {
906 printk(MYIOC_s_WARN_FMT
907 "Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
908 ioc->name, ioc);
909 return 0;
910 }
911
912 sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
913
914 if (!sh) {
915 printk(MYIOC_s_WARN_FMT
916 "Unable to register controller with SCSI subsystem\n",
917 ioc->name);
918 error = -1;
919 goto out_mptspi_probe;
920 }
921
922 spin_lock_irqsave(&ioc->FreeQlock, flags);
923
924 /* Attach the SCSI Host to the IOC structure
925 */
926 ioc->sh = sh;
927
928 sh->io_port = 0;
929 sh->n_io_port = 0;
930 sh->irq = 0;
931
932 /* set 16 byte cdb's */
933 sh->max_cmd_len = 16;
934
935 /* Yikes! This is important!
936 * Otherwise, by default, linux
937 * only scans target IDs 0-7!
938 * pfactsN->MaxDevices unreliable
939 * (not supported in early
940 * versions of the FW).
941 * max_id = 1 + actual max id,
942 * max_lun = 1 + actual last lun,
943 * see hosts.h :o(
944 */
945 sh->max_id = MPT_MAX_SCSI_DEVICES;
946
947 sh->max_lun = MPT_LAST_LUN + 1;
948 /*
949 * If RAID Firmware Detected, setup virtual channel
950 */
951 if ((ioc->facts.ProductID & MPI_FW_HEADER_PID_PROD_MASK)
952 > MPI_FW_HEADER_PID_PROD_TARGET_SCSI)
953 sh->max_channel = 1;
954 else
955 sh->max_channel = 0;
956 sh->this_id = ioc->pfacts[0].PortSCSIID;
957
958 /* Required entry.
959 */
960 sh->unique_id = ioc->id;
961
962 /* Verify that we won't exceed the maximum
963 * number of chain buffers
964 * We can optimize: ZZ = req_sz/sizeof(SGE)
965 * For 32bit SGE's:
966 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
967 * + (req_sz - 64)/sizeof(SGE)
968 * A slightly different algorithm is required for
969 * 64bit SGEs.
970 */
971 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32));
972 if (sizeof(dma_addr_t) == sizeof(u64)) {
973 numSGE = (scale - 1) *
974 (ioc->facts.MaxChainDepth-1) + scale +
975 (ioc->req_sz - 60) / (sizeof(dma_addr_t) +
976 sizeof(u32));
977 } else {
978 numSGE = 1 + (scale - 1) *
979 (ioc->facts.MaxChainDepth-1) + scale +
980 (ioc->req_sz - 64) / (sizeof(dma_addr_t) +
981 sizeof(u32));
982 }
983
984 if (numSGE < sh->sg_tablesize) {
985 /* Reset this value */
986 dprintk((MYIOC_s_INFO_FMT
987 "Resetting sg_tablesize to %d from %d\n",
988 ioc->name, numSGE, sh->sg_tablesize));
989 sh->sg_tablesize = numSGE;
990 }
991
992 spin_unlock_irqrestore(&ioc->FreeQlock, flags);
993
994 hd = (MPT_SCSI_HOST *) sh->hostdata;
995 hd->ioc = ioc;
996
997 /* SCSI needs scsi_cmnd lookup table!
998 * (with size equal to req_depth*PtrSz!)
999 */
1000 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1001 if (!hd->ScsiLookup) {
1002 error = -ENOMEM;
1003 goto out_mptspi_probe;
1004 }
1005
1006 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n",
1007 ioc->name, hd->ScsiLookup));
1008
1009 /* Allocate memory for the device structures.
1010 * A non-Null pointer at an offset
1011 * indicates a device exists.
1012 * max_id = 1 + maximum id (hosts.h)
1013 */
1014 hd->Targets = kcalloc(sh->max_id * (sh->max_channel + 1),
1015 sizeof(void *), GFP_ATOMIC);
1016 if (!hd->Targets) {
1017 error = -ENOMEM;
1018 goto out_mptspi_probe;
1019 }
1020
1021 dprintk((KERN_INFO " vdev @ %p\n", hd->Targets));
1022
1023 /* Clear the TM flags
1024 */
1025 hd->tmPending = 0;
1026 hd->tmState = TM_STATE_NONE;
1027 hd->resetPending = 0;
1028 hd->abortSCpnt = NULL;
1029
1030 /* Clear the pointer used to store
1031 * single-threaded commands, i.e., those
1032 * issued during a bus scan, dv and
1033 * configuration pages.
1034 */
1035 hd->cmdPtr = NULL;
1036
1037 /* Initialize this SCSI Hosts' timers
1038 * To use, set the timer expires field
1039 * and add_timer
1040 */
1041 init_timer(&hd->timer);
1042 hd->timer.data = (unsigned long) hd;
1043 hd->timer.function = mptscsih_timer_expired;
1044
1045 ioc->spi_data.Saf_Te = mpt_saf_te;
1046
1047 hd->negoNvram = MPT_SCSICFG_USE_NVRAM;
1048 ddvprintk((MYIOC_s_INFO_FMT
1049 "saf_te %x\n",
1050 ioc->name,
1051 mpt_saf_te));
1052 ioc->spi_data.noQas = 0;
1053
1054 init_waitqueue_head(&hd->scandv_waitq);
1055 hd->scandv_wait_done = 0;
1056 hd->last_queue_full = 0;
1057
1058 /* Some versions of the firmware don't support page 0; without
1059 * that we can't get the parameters */
1060 if (hd->ioc->spi_data.sdp0length != 0)
1061 sh->transportt = mptspi_transport_template;
1062
1063 error = scsi_add_host (sh, &ioc->pcidev->dev);
1064 if(error) {
1065 dprintk((KERN_ERR MYNAM
1066 "scsi_add_host failed\n"));
1067 goto out_mptspi_probe;
1068 }
1069
1070 /*
1071 * issue internal bus reset
1072 */
1073 if (ioc->spi_data.bus_reset)
1074 mptscsih_TMHandler(hd,
1075 MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1076 0, 0, 0, 0, 5);
1077
1078 scsi_scan_host(sh);
1079 return 0;
1080
1081 out_mptspi_probe:
1082
1083 mptscsih_remove(pdev);
1084 return error;
1085 }
1086
1087 static struct pci_driver mptspi_driver = {
1088 .name = "mptspi",
1089 .id_table = mptspi_pci_table,
1090 .probe = mptspi_probe,
1091 .remove = __devexit_p(mptscsih_remove),
1092 .shutdown = mptscsih_shutdown,
1093 #ifdef CONFIG_PM
1094 .suspend = mptscsih_suspend,
1095 .resume = mptspi_resume,
1096 #endif
1097 };
1098
1099 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1100 /**
1101 * mptspi_init - Register MPT adapter(s) as SCSI host(s) with
1102 * linux scsi mid-layer.
1103 *
1104 * Returns 0 for success, non-zero for failure.
1105 */
1106 static int __init
1107 mptspi_init(void)
1108 {
1109 show_mptmod_ver(my_NAME, my_VERSION);
1110
1111 mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1112 if (!mptspi_transport_template)
1113 return -ENODEV;
1114
1115 mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER);
1116 mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER);
1117 mptspiInternalCtx = mpt_register(mptscsih_scandv_complete, MPTSPI_DRIVER);
1118
1119 if (mpt_event_register(mptspiDoneCtx, mptspi_event_process) == 0) {
1120 devtverboseprintk((KERN_INFO MYNAM
1121 ": Registered for IOC event notifications\n"));
1122 }
1123
1124 if (mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset) == 0) {
1125 dprintk((KERN_INFO MYNAM
1126 ": Registered for IOC reset notifications\n"));
1127 }
1128
1129 return pci_register_driver(&mptspi_driver);
1130 }
1131
1132 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1133 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1134 /**
1135 * mptspi_exit - Unregisters MPT adapter(s)
1136 *
1137 */
1138 static void __exit
1139 mptspi_exit(void)
1140 {
1141 pci_unregister_driver(&mptspi_driver);
1142
1143 mpt_reset_deregister(mptspiDoneCtx);
1144 dprintk((KERN_INFO MYNAM
1145 ": Deregistered for IOC reset notifications\n"));
1146
1147 mpt_event_deregister(mptspiDoneCtx);
1148 dprintk((KERN_INFO MYNAM
1149 ": Deregistered for IOC event notifications\n"));
1150
1151 mpt_deregister(mptspiInternalCtx);
1152 mpt_deregister(mptspiTaskCtx);
1153 mpt_deregister(mptspiDoneCtx);
1154 spi_release_transport(mptspi_transport_template);
1155 }
1156
1157 module_init(mptspi_init);
1158 module_exit(mptspi_exit);
Linux kernel - Deliverables
This page took 0.053549 seconds and 6 git commands to generate.