1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40#include <linux/ctype.h>
41#include <linux/init.h>
42#include <linux/module.h>
43#include <linux/moduleparam.h>
44#include <linux/spinlock.h>
45#include <scsi/scsi.h>
46#include <scsi/scsi_tcq.h>
47#include <scsi/scsi_device.h>
48#include <scsi/scsi_transport.h>
49
50#include "sym_glue.h"
51#include "sym_nvram.h"
52
53#define NAME53C "sym53c"
54#define NAME53C8XX "sym53c8xx"
55
56struct sym_driver_setup sym_driver_setup = SYM_LINUX_DRIVER_SETUP;
57unsigned int sym_debug_flags = 0;
58
59static char *excl_string;
60static char *safe_string;
61module_param_named(cmd_per_lun, sym_driver_setup.max_tag, ushort, 0);
62module_param_named(burst, sym_driver_setup.burst_order, byte, 0);
63module_param_named(led, sym_driver_setup.scsi_led, byte, 0);
64module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0);
65module_param_named(irqm, sym_driver_setup.irq_mode, byte, 0);
66module_param_named(buschk, sym_driver_setup.scsi_bus_check, byte, 0);
67module_param_named(hostid, sym_driver_setup.host_id, byte, 0);
68module_param_named(verb, sym_driver_setup.verbose, byte, 0);
69module_param_named(debug, sym_debug_flags, uint, 0);
70module_param_named(settle, sym_driver_setup.settle_delay, byte, 0);
71module_param_named(nvram, sym_driver_setup.use_nvram, byte, 0);
72module_param_named(excl, excl_string, charp, 0);
73module_param_named(safe, safe_string, charp, 0);
74
75MODULE_PARM_DESC(cmd_per_lun, "The maximum number of tags to use by default");
76MODULE_PARM_DESC(burst, "Maximum burst. 0 to disable, 255 to read from registers");
77MODULE_PARM_DESC(led, "Set to 1 to enable LED support");
78MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3");
79MODULE_PARM_DESC(irqm, "0 for open drain, 1 to leave alone, 2 for totem pole");
80MODULE_PARM_DESC(buschk, "0 to not check, 1 for detach on error, 2 for warn on error");
81MODULE_PARM_DESC(hostid, "The SCSI ID to use for the host adapters");
82MODULE_PARM_DESC(verb, "0 for minimal verbosity, 1 for normal, 2 for excessive");
83MODULE_PARM_DESC(debug, "Set bits to enable debugging");
84MODULE_PARM_DESC(settle, "Settle delay in seconds. Default 3");
85MODULE_PARM_DESC(nvram, "Option currently not used");
86MODULE_PARM_DESC(excl, "List ioport addresses here to prevent controllers from being attached");
87MODULE_PARM_DESC(safe, "Set other settings to a \"safe mode\"");
88
89MODULE_LICENSE("GPL");
90MODULE_VERSION(SYM_VERSION);
91MODULE_AUTHOR("Matthew Wilcox <matthew@wil.cx>");
92MODULE_DESCRIPTION("NCR, Symbios and LSI 8xx and 1010 PCI SCSI adapters");
93
94static void sym2_setup_params(void)
95{
96 char *p = excl_string;
97 int xi = 0;
98
99 while (p && (xi < 8)) {
100 char *next_p;
101 int val = (int) simple_strtoul(p, &next_p, 0);
102 sym_driver_setup.excludes[xi++] = val;
103 p = next_p;
104 }
105
106 if (safe_string) {
107 if (*safe_string == 'y') {
108 sym_driver_setup.max_tag = 0;
109 sym_driver_setup.burst_order = 0;
110 sym_driver_setup.scsi_led = 0;
111 sym_driver_setup.scsi_diff = 1;
112 sym_driver_setup.irq_mode = 0;
113 sym_driver_setup.scsi_bus_check = 2;
114 sym_driver_setup.host_id = 7;
115 sym_driver_setup.verbose = 2;
116 sym_driver_setup.settle_delay = 10;
117 sym_driver_setup.use_nvram = 1;
118 } else if (*safe_string != 'n') {
119 printk(KERN_WARNING NAME53C8XX "Ignoring parameter %s"
120 " passed to safe option", safe_string);
121 }
122 }
123}
124
125static struct scsi_transport_template *sym2_transport_template = NULL;
126
127
128
129
130struct sym_ucmd {
131 struct completion *eh_done;
132};
133
134#define SYM_UCMD_PTR(cmd) ((struct sym_ucmd *)(&(cmd)->SCp))
135#define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host)
136
137
138
139
140void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *cmd)
141{
142 struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
143 BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd));
144
145 if (ucmd->eh_done)
146 complete(ucmd->eh_done);
147
148 scsi_dma_unmap(cmd);
149 cmd->scsi_done(cmd);
150}
151
152
153
154
155void sym_xpt_async_bus_reset(struct sym_hcb *np)
156{
157 printf_notice("%s: SCSI BUS has been reset.\n", sym_name(np));
158 np->s.settle_time = jiffies + sym_driver_setup.settle_delay * HZ;
159 np->s.settle_time_valid = 1;
160 if (sym_verbose >= 2)
161 printf_info("%s: command processing suspended for %d seconds\n",
162 sym_name(np), sym_driver_setup.settle_delay);
163}
164
165
166
167
168
169static int sym_xerr_cam_status(int cam_status, int x_status)
170{
171 if (x_status) {
172 if (x_status & XE_PARITY_ERR)
173 cam_status = DID_PARITY;
174 else if (x_status &(XE_EXTRA_DATA|XE_SODL_UNRUN|XE_SWIDE_OVRUN))
175 cam_status = DID_ERROR;
176 else if (x_status & XE_BAD_PHASE)
177 cam_status = DID_ERROR;
178 else
179 cam_status = DID_ERROR;
180 }
181 return cam_status;
182}
183
184
185
186
187void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
188{
189 struct scsi_cmnd *cmd = cp->cmd;
190 u_int cam_status, scsi_status, drv_status;
191
192 drv_status = 0;
193 cam_status = DID_OK;
194 scsi_status = cp->ssss_status;
195
196 if (cp->host_flags & HF_SENSE) {
197 scsi_status = cp->sv_scsi_status;
198 resid = cp->sv_resid;
199 if (sym_verbose && cp->sv_xerr_status)
200 sym_print_xerr(cmd, cp->sv_xerr_status);
201 if (cp->host_status == HS_COMPLETE &&
202 cp->ssss_status == S_GOOD &&
203 cp->xerr_status == 0) {
204 cam_status = sym_xerr_cam_status(DID_OK,
205 cp->sv_xerr_status);
206 drv_status = DRIVER_SENSE;
207
208
209
210 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
211 memcpy(cmd->sense_buffer, cp->sns_bbuf,
212 min(SCSI_SENSE_BUFFERSIZE, SYM_SNS_BBUF_LEN));
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227 } else {
228
229
230
231
232
233
234 sym_reset_scsi_target(np, cmd->device->id);
235 cam_status = DID_ERROR;
236 }
237 } else if (cp->host_status == HS_COMPLETE)
238 cam_status = DID_OK;
239 else if (cp->host_status == HS_SEL_TIMEOUT)
240 cam_status = DID_NO_CONNECT;
241 else if (cp->host_status == HS_UNEXPECTED)
242 cam_status = DID_ERROR;
243 else {
244 if (sym_verbose) {
245 sym_print_addr(cmd, "COMMAND FAILED (%x %x %x).\n",
246 cp->host_status, cp->ssss_status,
247 cp->xerr_status);
248 }
249
250
251
252 cam_status = sym_xerr_cam_status(DID_ERROR, cp->xerr_status);
253 }
254 scsi_set_resid(cmd, resid);
255 cmd->result = (drv_status << 24) + (cam_status << 16) + scsi_status;
256}
257
258static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd *cmd)
259{
260 int segment;
261 int use_sg;
262
263 cp->data_len = 0;
264
265 use_sg = scsi_dma_map(cmd);
266 if (use_sg > 0) {
267 struct scatterlist *sg;
268 struct sym_tcb *tp = &np->target[cp->target];
269 struct sym_tblmove *data;
270
271 if (use_sg > SYM_CONF_MAX_SG) {
272 scsi_dma_unmap(cmd);
273 return -1;
274 }
275
276 data = &cp->phys.data[SYM_CONF_MAX_SG - use_sg];
277
278 scsi_for_each_sg(cmd, sg, use_sg, segment) {
279 dma_addr_t baddr = sg_dma_address(sg);
280 unsigned int len = sg_dma_len(sg);
281
282 if ((len & 1) && (tp->head.wval & EWS)) {
283 len++;
284 cp->odd_byte_adjustment++;
285 }
286
287 sym_build_sge(np, &data[segment], baddr, len);
288 cp->data_len += len;
289 }
290 } else {
291 segment = -2;
292 }
293
294 return segment;
295}
296
297
298
299
300static int sym_queue_command(struct sym_hcb *np, struct scsi_cmnd *cmd)
301{
302 struct scsi_device *sdev = cmd->device;
303 struct sym_tcb *tp;
304 struct sym_lcb *lp;
305 struct sym_ccb *cp;
306 int order;
307
308
309
310
311 tp = &np->target[sdev->id];
312
313
314
315
316 lp = sym_lp(tp, sdev->lun);
317 order = (lp && lp->s.reqtags) ? M_SIMPLE_TAG : 0;
318
319
320
321
322 cp = sym_get_ccb(np, cmd, order);
323 if (!cp)
324 return 1;
325 sym_queue_scsiio(np, cmd, cp);
326 return 0;
327}
328
329
330
331
332static inline int sym_setup_cdb(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp)
333{
334 memcpy(cp->cdb_buf, cmd->cmnd, cmd->cmd_len);
335
336 cp->phys.cmd.addr = CCB_BA(cp, cdb_buf[0]);
337 cp->phys.cmd.size = cpu_to_scr(cmd->cmd_len);
338
339 return 0;
340}
341
342
343
344
345int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct sym_ccb *cp)
346{
347 u32 lastp, goalp;
348 int dir;
349
350
351
352
353 if (sym_setup_cdb(np, cmd, cp))
354 goto out_abort;
355
356
357
358
359 dir = cmd->sc_data_direction;
360 if (dir != DMA_NONE) {
361 cp->segments = sym_scatter(np, cp, cmd);
362 if (cp->segments < 0) {
363 sym_set_cam_status(cmd, DID_ERROR);
364 goto out_abort;
365 }
366
367
368
369
370 if (!cp->segments)
371 dir = DMA_NONE;
372 } else {
373 cp->data_len = 0;
374 cp->segments = 0;
375 }
376
377
378
379
380 switch (dir) {
381 case DMA_BIDIRECTIONAL:
382 scmd_printk(KERN_INFO, cmd, "got DMA_BIDIRECTIONAL command");
383 sym_set_cam_status(cmd, DID_ERROR);
384 goto out_abort;
385 case DMA_TO_DEVICE:
386 goalp = SCRIPTA_BA(np, data_out2) + 8;
387 lastp = goalp - 8 - (cp->segments * (2*4));
388 break;
389 case DMA_FROM_DEVICE:
390 cp->host_flags |= HF_DATA_IN;
391 goalp = SCRIPTA_BA(np, data_in2) + 8;
392 lastp = goalp - 8 - (cp->segments * (2*4));
393 break;
394 case DMA_NONE:
395 default:
396 lastp = goalp = SCRIPTB_BA(np, no_data);
397 break;
398 }
399
400
401
402
403 cp->phys.head.lastp = cpu_to_scr(lastp);
404 cp->phys.head.savep = cpu_to_scr(lastp);
405 cp->startp = cp->phys.head.savep;
406 cp->goalp = cpu_to_scr(goalp);
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427 sym_put_start_queue(np, cp);
428 return 0;
429
430out_abort:
431 sym_free_ccb(np, cp);
432 sym_xpt_done(np, cmd);
433 return 0;
434}
435
436
437
438
439
440
441
442
443static void sym_timer(struct sym_hcb *np)
444{
445 unsigned long thistime = jiffies;
446
447
448
449
450 np->s.timer.expires = thistime + SYM_CONF_TIMER_INTERVAL;
451 add_timer(&np->s.timer);
452
453
454
455
456
457 if (np->s.settle_time_valid) {
458 if (time_before_eq(np->s.settle_time, thistime)) {
459 if (sym_verbose >= 2 )
460 printk("%s: command processing resumed\n",
461 sym_name(np));
462 np->s.settle_time_valid = 0;
463 }
464 return;
465 }
466
467
468
469
470 if (np->s.lasttime + 4*HZ < thistime) {
471 np->s.lasttime = thistime;
472 }
473
474#ifdef SYM_CONF_PCIQ_MAY_MISS_COMPLETIONS
475
476
477
478
479
480
481
482
483 sym_wakeup_done(np);
484#endif
485}
486
487
488
489
490
491void sym_log_bus_error(struct Scsi_Host *shost)
492{
493 struct sym_data *sym_data = shost_priv(shost);
494 struct pci_dev *pdev = sym_data->pdev;
495 unsigned short pci_sts;
496 pci_read_config_word(pdev, PCI_STATUS, &pci_sts);
497 if (pci_sts & 0xf900) {
498 pci_write_config_word(pdev, PCI_STATUS, pci_sts);
499 shost_printk(KERN_WARNING, shost,
500 "PCI bus error: status = 0x%04x\n", pci_sts & 0xf900);
501 }
502}
503
504
505
506
507
508static int sym53c8xx_queue_command(struct scsi_cmnd *cmd,
509 void (*done)(struct scsi_cmnd *))
510{
511 struct sym_hcb *np = SYM_SOFTC_PTR(cmd);
512 struct sym_ucmd *ucp = SYM_UCMD_PTR(cmd);
513 int sts = 0;
514
515 cmd->scsi_done = done;
516 memset(ucp, 0, sizeof(*ucp));
517
518
519
520
521
522 if (np->s.settle_time_valid && cmd->request->timeout) {
523 unsigned long tlimit = jiffies + cmd->request->timeout;
524 tlimit -= SYM_CONF_TIMER_INTERVAL*2;
525 if (time_after(np->s.settle_time, tlimit)) {
526 np->s.settle_time = tlimit;
527 }
528 }
529
530 if (np->s.settle_time_valid)
531 return SCSI_MLQUEUE_HOST_BUSY;
532
533 sts = sym_queue_command(np, cmd);
534 if (sts)
535 return SCSI_MLQUEUE_HOST_BUSY;
536 return 0;
537}
538
539
540
541
542static irqreturn_t sym53c8xx_intr(int irq, void *dev_id)
543{
544 struct Scsi_Host *shost = dev_id;
545 struct sym_data *sym_data = shost_priv(shost);
546 irqreturn_t result;
547
548
549 if (pci_channel_offline(sym_data->pdev))
550 return IRQ_NONE;
551
552 if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("[");
553
554 spin_lock(shost->host_lock);
555 result = sym_interrupt(shost);
556 spin_unlock(shost->host_lock);
557
558 if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("]\n");
559
560 return result;
561}
562
563
564
565
566static void sym53c8xx_timer(unsigned long npref)
567{
568 struct sym_hcb *np = (struct sym_hcb *)npref;
569 unsigned long flags;
570
571 spin_lock_irqsave(np->s.host->host_lock, flags);
572 sym_timer(np);
573 spin_unlock_irqrestore(np->s.host->host_lock, flags);
574}
575
576
577
578
579
580#define SYM_EH_ABORT 0
581#define SYM_EH_DEVICE_RESET 1
582#define SYM_EH_BUS_RESET 2
583#define SYM_EH_HOST_RESET 3
584
585
586
587
588
589static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
590{
591 struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
592 struct Scsi_Host *shost = cmd->device->host;
593 struct sym_data *sym_data = shost_priv(shost);
594 struct pci_dev *pdev = sym_data->pdev;
595 struct sym_hcb *np = sym_data->ncb;
596 SYM_QUEHEAD *qp;
597 int cmd_queued = 0;
598 int sts = -1;
599 struct completion eh_done;
600
601 scmd_printk(KERN_WARNING, cmd, "%s operation started\n", opname);
602
603
604
605
606
607
608
609#define WAIT_FOR_PCI_RECOVERY 35
610 if (pci_channel_offline(pdev)) {
611 int finished_reset = 0;
612 init_completion(&eh_done);
613 spin_lock_irq(shost->host_lock);
614
615 if (pci_channel_offline(pdev)) {
616 BUG_ON(sym_data->io_reset);
617 sym_data->io_reset = &eh_done;
618 } else {
619 finished_reset = 1;
620 }
621 spin_unlock_irq(shost->host_lock);
622 if (!finished_reset)
623 finished_reset = wait_for_completion_timeout
624 (sym_data->io_reset,
625 WAIT_FOR_PCI_RECOVERY*HZ);
626 spin_lock_irq(shost->host_lock);
627 sym_data->io_reset = NULL;
628 spin_unlock_irq(shost->host_lock);
629 if (!finished_reset)
630 return SCSI_FAILED;
631 }
632
633 spin_lock_irq(shost->host_lock);
634
635 FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) {
636 struct sym_ccb *cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
637 if (cp->cmd == cmd) {
638 cmd_queued = 1;
639 break;
640 }
641 }
642
643
644 sts = -1;
645 switch(op) {
646 case SYM_EH_ABORT:
647 sts = sym_abort_scsiio(np, cmd, 1);
648 break;
649 case SYM_EH_DEVICE_RESET:
650 sts = sym_reset_scsi_target(np, cmd->device->id);
651 break;
652 case SYM_EH_BUS_RESET:
653 sym_reset_scsi_bus(np, 1);
654 sts = 0;
655 break;
656 case SYM_EH_HOST_RESET:
657 sym_reset_scsi_bus(np, 0);
658 sym_start_up(shost, 1);
659 sts = 0;
660 break;
661 default:
662 break;
663 }
664
665
666 if (sts)
667 cmd_queued = 0;
668
669 if (cmd_queued) {
670 init_completion(&eh_done);
671 ucmd->eh_done = &eh_done;
672 spin_unlock_irq(shost->host_lock);
673 if (!wait_for_completion_timeout(&eh_done, 5*HZ)) {
674 ucmd->eh_done = NULL;
675 sts = -2;
676 }
677 } else {
678 spin_unlock_irq(shost->host_lock);
679 }
680
681 dev_warn(&cmd->device->sdev_gendev, "%s operation %s.\n", opname,
682 sts==0 ? "complete" :sts==-2 ? "timed-out" : "failed");
683 return sts ? SCSI_FAILED : SCSI_SUCCESS;
684}
685
686
687
688
689
690static int sym53c8xx_eh_abort_handler(struct scsi_cmnd *cmd)
691{
692 return sym_eh_handler(SYM_EH_ABORT, "ABORT", cmd);
693}
694
695static int sym53c8xx_eh_device_reset_handler(struct scsi_cmnd *cmd)
696{
697 return sym_eh_handler(SYM_EH_DEVICE_RESET, "DEVICE RESET", cmd);
698}
699
700static int sym53c8xx_eh_bus_reset_handler(struct scsi_cmnd *cmd)
701{
702 return sym_eh_handler(SYM_EH_BUS_RESET, "BUS RESET", cmd);
703}
704
705static int sym53c8xx_eh_host_reset_handler(struct scsi_cmnd *cmd)
706{
707 return sym_eh_handler(SYM_EH_HOST_RESET, "HOST RESET", cmd);
708}
709
710
711
712
713static void sym_tune_dev_queuing(struct sym_tcb *tp, int lun, u_short reqtags)
714{
715 struct sym_lcb *lp = sym_lp(tp, lun);
716 u_short oldtags;
717
718 if (!lp)
719 return;
720
721 oldtags = lp->s.reqtags;
722
723 if (reqtags > lp->s.scdev_depth)
724 reqtags = lp->s.scdev_depth;
725
726 lp->s.reqtags = reqtags;
727
728 if (reqtags != oldtags) {
729 dev_info(&tp->starget->dev,
730 "tagged command queuing %s, command queue depth %d.\n",
731 lp->s.reqtags ? "enabled" : "disabled", reqtags);
732 }
733}
734
735static int sym53c8xx_slave_alloc(struct scsi_device *sdev)
736{
737 struct sym_hcb *np = sym_get_hcb(sdev->host);
738 struct sym_tcb *tp = &np->target[sdev->id];
739 struct sym_lcb *lp;
740
741 if (sdev->id >= SYM_CONF_MAX_TARGET || sdev->lun >= SYM_CONF_MAX_LUN)
742 return -ENXIO;
743
744 tp->starget = sdev->sdev_target;
745
746
747
748
749
750
751
752
753
754 if (tp->usrflags & SYM_SCAN_BOOT_DISABLED) {
755 tp->usrflags &= ~SYM_SCAN_BOOT_DISABLED;
756 starget_printk(KERN_INFO, tp->starget,
757 "Scan at boot disabled in NVRAM\n");
758 return -ENXIO;
759 }
760
761 if (tp->usrflags & SYM_SCAN_LUNS_DISABLED) {
762 if (sdev->lun != 0)
763 return -ENXIO;
764 starget_printk(KERN_INFO, tp->starget,
765 "Multiple LUNs disabled in NVRAM\n");
766 }
767
768 lp = sym_alloc_lcb(np, sdev->id, sdev->lun);
769 if (!lp)
770 return -ENOMEM;
771
772 spi_min_period(tp->starget) = tp->usr_period;
773 spi_max_width(tp->starget) = tp->usr_width;
774
775 return 0;
776}
777
778
779
780
781static int sym53c8xx_slave_configure(struct scsi_device *sdev)
782{
783 struct sym_hcb *np = sym_get_hcb(sdev->host);
784 struct sym_tcb *tp = &np->target[sdev->id];
785 struct sym_lcb *lp = sym_lp(tp, sdev->lun);
786 int reqtags, depth_to_use;
787
788
789
790
791 lp->curr_flags = lp->user_flags;
792
793
794
795
796
797
798
799 reqtags = sym_driver_setup.max_tag;
800 if (reqtags > tp->usrtags)
801 reqtags = tp->usrtags;
802 if (!sdev->tagged_supported)
803 reqtags = 0;
804 if (reqtags > SYM_CONF_MAX_TAG)
805 reqtags = SYM_CONF_MAX_TAG;
806 depth_to_use = reqtags ? reqtags : 2;
807 scsi_adjust_queue_depth(sdev,
808 sdev->tagged_supported ? MSG_SIMPLE_TAG : 0,
809 depth_to_use);
810 lp->s.scdev_depth = depth_to_use;
811 sym_tune_dev_queuing(tp, sdev->lun, reqtags);
812
813 if (!spi_initial_dv(sdev->sdev_target))
814 spi_dv_device(sdev);
815
816 return 0;
817}
818
819static void sym53c8xx_slave_destroy(struct scsi_device *sdev)
820{
821 struct sym_hcb *np = sym_get_hcb(sdev->host);
822 struct sym_lcb *lp = sym_lp(&np->target[sdev->id], sdev->lun);
823
824 if (lp->itlq_tbl)
825 sym_mfree_dma(lp->itlq_tbl, SYM_CONF_MAX_TASK * 4, "ITLQ_TBL");
826 kfree(lp->cb_tags);
827 sym_mfree_dma(lp, sizeof(*lp), "LCB");
828}
829
830
831
832
833static const char *sym53c8xx_info (struct Scsi_Host *host)
834{
835 return SYM_DRIVER_NAME;
836}
837
838
839#ifdef SYM_LINUX_PROC_INFO_SUPPORT
840
841
842
843
844
845
846
847
848
849#ifdef SYM_LINUX_USER_COMMAND_SUPPORT
850
851struct sym_usrcmd {
852 u_long target;
853 u_long lun;
854 u_long data;
855 u_long cmd;
856};
857
858#define UC_SETSYNC 10
859#define UC_SETTAGS 11
860#define UC_SETDEBUG 12
861#define UC_SETWIDE 14
862#define UC_SETFLAG 15
863#define UC_SETVERBOSE 17
864#define UC_RESETDEV 18
865#define UC_CLEARDEV 19
866
867static void sym_exec_user_command (struct sym_hcb *np, struct sym_usrcmd *uc)
868{
869 struct sym_tcb *tp;
870 int t, l;
871
872 switch (uc->cmd) {
873 case 0: return;
874
875#ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
876 case UC_SETDEBUG:
877 sym_debug_flags = uc->data;
878 break;
879#endif
880 case UC_SETVERBOSE:
881 np->verbose = uc->data;
882 break;
883 default:
884
885
886
887
888
889 for (t = 0; t < SYM_CONF_MAX_TARGET; t++) {
890 if (!((uc->target >> t) & 1))
891 continue;
892 tp = &np->target[t];
893
894 switch (uc->cmd) {
895
896 case UC_SETSYNC:
897 if (!uc->data || uc->data >= 255) {
898 tp->tgoal.iu = tp->tgoal.dt =
899 tp->tgoal.qas = 0;
900 tp->tgoal.offset = 0;
901 } else if (uc->data <= 9 && np->minsync_dt) {
902 if (uc->data < np->minsync_dt)
903 uc->data = np->minsync_dt;
904 tp->tgoal.iu = tp->tgoal.dt =
905 tp->tgoal.qas = 1;
906 tp->tgoal.width = 1;
907 tp->tgoal.period = uc->data;
908 tp->tgoal.offset = np->maxoffs_dt;
909 } else {
910 if (uc->data < np->minsync)
911 uc->data = np->minsync;
912 tp->tgoal.iu = tp->tgoal.dt =
913 tp->tgoal.qas = 0;
914 tp->tgoal.period = uc->data;
915 tp->tgoal.offset = np->maxoffs;
916 }
917 tp->tgoal.check_nego = 1;
918 break;
919 case UC_SETWIDE:
920 tp->tgoal.width = uc->data ? 1 : 0;
921 tp->tgoal.check_nego = 1;
922 break;
923 case UC_SETTAGS:
924 for (l = 0; l < SYM_CONF_MAX_LUN; l++)
925 sym_tune_dev_queuing(tp, l, uc->data);
926 break;
927 case UC_RESETDEV:
928 tp->to_reset = 1;
929 np->istat_sem = SEM;
930 OUTB(np, nc_istat, SIGP|SEM);
931 break;
932 case UC_CLEARDEV:
933 for (l = 0; l < SYM_CONF_MAX_LUN; l++) {
934 struct sym_lcb *lp = sym_lp(tp, l);
935 if (lp) lp->to_clear = 1;
936 }
937 np->istat_sem = SEM;
938 OUTB(np, nc_istat, SIGP|SEM);
939 break;
940 case UC_SETFLAG:
941 tp->usrflags = uc->data;
942 break;
943 }
944 }
945 break;
946 }
947}
948
949static int skip_spaces(char *ptr, int len)
950{
951 int cnt, c;
952
953 for (cnt = len; cnt > 0 && (c = *ptr++) && isspace(c); cnt--);
954
955 return (len - cnt);
956}
957
958static int get_int_arg(char *ptr, int len, u_long *pv)
959{
960 char *end;
961
962 *pv = simple_strtoul(ptr, &end, 10);
963 return (end - ptr);
964}
965
966static int is_keyword(char *ptr, int len, char *verb)
967{
968 int verb_len = strlen(verb);
969
970 if (len >= verb_len && !memcmp(verb, ptr, verb_len))
971 return verb_len;
972 else
973 return 0;
974}
975
976#define SKIP_SPACES(ptr, len) \
977 if ((arg_len = skip_spaces(ptr, len)) < 1) \
978 return -EINVAL; \
979 ptr += arg_len; len -= arg_len;
980
981#define GET_INT_ARG(ptr, len, v) \
982 if (!(arg_len = get_int_arg(ptr, len, &(v)))) \
983 return -EINVAL; \
984 ptr += arg_len; len -= arg_len;
985
986
987
988
989
990
991static int sym_user_command(struct Scsi_Host *shost, char *buffer, int length)
992{
993 struct sym_hcb *np = sym_get_hcb(shost);
994 char *ptr = buffer;
995 int len = length;
996 struct sym_usrcmd cmd, *uc = &cmd;
997 int arg_len;
998 u_long target;
999
1000 memset(uc, 0, sizeof(*uc));
1001
1002 if (len > 0 && ptr[len-1] == '\n')
1003 --len;
1004
1005 if ((arg_len = is_keyword(ptr, len, "setsync")) != 0)
1006 uc->cmd = UC_SETSYNC;
1007 else if ((arg_len = is_keyword(ptr, len, "settags")) != 0)
1008 uc->cmd = UC_SETTAGS;
1009 else if ((arg_len = is_keyword(ptr, len, "setverbose")) != 0)
1010 uc->cmd = UC_SETVERBOSE;
1011 else if ((arg_len = is_keyword(ptr, len, "setwide")) != 0)
1012 uc->cmd = UC_SETWIDE;
1013#ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1014 else if ((arg_len = is_keyword(ptr, len, "setdebug")) != 0)
1015 uc->cmd = UC_SETDEBUG;
1016#endif
1017 else if ((arg_len = is_keyword(ptr, len, "setflag")) != 0)
1018 uc->cmd = UC_SETFLAG;
1019 else if ((arg_len = is_keyword(ptr, len, "resetdev")) != 0)
1020 uc->cmd = UC_RESETDEV;
1021 else if ((arg_len = is_keyword(ptr, len, "cleardev")) != 0)
1022 uc->cmd = UC_CLEARDEV;
1023 else
1024 arg_len = 0;
1025
1026#ifdef DEBUG_PROC_INFO
1027printk("sym_user_command: arg_len=%d, cmd=%ld\n", arg_len, uc->cmd);
1028#endif
1029
1030 if (!arg_len)
1031 return -EINVAL;
1032 ptr += arg_len; len -= arg_len;
1033
1034 switch(uc->cmd) {
1035 case UC_SETSYNC:
1036 case UC_SETTAGS:
1037 case UC_SETWIDE:
1038 case UC_SETFLAG:
1039 case UC_RESETDEV:
1040 case UC_CLEARDEV:
1041 SKIP_SPACES(ptr, len);
1042 if ((arg_len = is_keyword(ptr, len, "all")) != 0) {
1043 ptr += arg_len; len -= arg_len;
1044 uc->target = ~0;
1045 } else {
1046 GET_INT_ARG(ptr, len, target);
1047 uc->target = (1<<target);
1048#ifdef DEBUG_PROC_INFO
1049printk("sym_user_command: target=%ld\n", target);
1050#endif
1051 }
1052 break;
1053 }
1054
1055 switch(uc->cmd) {
1056 case UC_SETVERBOSE:
1057 case UC_SETSYNC:
1058 case UC_SETTAGS:
1059 case UC_SETWIDE:
1060 SKIP_SPACES(ptr, len);
1061 GET_INT_ARG(ptr, len, uc->data);
1062#ifdef DEBUG_PROC_INFO
1063printk("sym_user_command: data=%ld\n", uc->data);
1064#endif
1065 break;
1066#ifdef SYM_LINUX_DEBUG_CONTROL_SUPPORT
1067 case UC_SETDEBUG:
1068 while (len > 0) {
1069 SKIP_SPACES(ptr, len);
1070 if ((arg_len = is_keyword(ptr, len, "alloc")))
1071 uc->data |= DEBUG_ALLOC;
1072 else if ((arg_len = is_keyword(ptr, len, "phase")))
1073 uc->data |= DEBUG_PHASE;
1074 else if ((arg_len = is_keyword(ptr, len, "queue")))
1075 uc->data |= DEBUG_QUEUE;
1076 else if ((arg_len = is_keyword(ptr, len, "result")))
1077 uc->data |= DEBUG_RESULT;
1078 else if ((arg_len = is_keyword(ptr, len, "scatter")))
1079 uc->data |= DEBUG_SCATTER;
1080 else if ((arg_len = is_keyword(ptr, len, "script")))
1081 uc->data |= DEBUG_SCRIPT;
1082 else if ((arg_len = is_keyword(ptr, len, "tiny")))
1083 uc->data |= DEBUG_TINY;
1084 else if ((arg_len = is_keyword(ptr, len, "timing")))
1085 uc->data |= DEBUG_TIMING;
1086 else if ((arg_len = is_keyword(ptr, len, "nego")))
1087 uc->data |= DEBUG_NEGO;
1088 else if ((arg_len = is_keyword(ptr, len, "tags")))
1089 uc->data |= DEBUG_TAGS;
1090 else if ((arg_len = is_keyword(ptr, len, "pointer")))
1091 uc->data |= DEBUG_POINTER;
1092 else
1093 return -EINVAL;
1094 ptr += arg_len; len -= arg_len;
1095 }
1096#ifdef DEBUG_PROC_INFO
1097printk("sym_user_command: data=%ld\n", uc->data);
1098#endif
1099 break;
1100#endif
1101 case UC_SETFLAG:
1102 while (len > 0) {
1103 SKIP_SPACES(ptr, len);
1104 if ((arg_len = is_keyword(ptr, len, "no_disc")))
1105 uc->data &= ~SYM_DISC_ENABLED;
1106 else
1107 return -EINVAL;
1108 ptr += arg_len; len -= arg_len;
1109 }
1110 break;
1111 default:
1112 break;
1113 }
1114
1115 if (len)
1116 return -EINVAL;
1117 else {
1118 unsigned long flags;
1119
1120 spin_lock_irqsave(shost->host_lock, flags);
1121 sym_exec_user_command(np, uc);
1122 spin_unlock_irqrestore(shost->host_lock, flags);
1123 }
1124 return length;
1125}
1126
1127#endif
1128
1129
1130#ifdef SYM_LINUX_USER_INFO_SUPPORT
1131
1132
1133
1134struct info_str {
1135 char *buffer;
1136 int length;
1137 int offset;
1138 int pos;
1139};
1140
1141static void copy_mem_info(struct info_str *info, char *data, int len)
1142{
1143 if (info->pos + len > info->length)
1144 len = info->length - info->pos;
1145
1146 if (info->pos + len < info->offset) {
1147 info->pos += len;
1148 return;
1149 }
1150 if (info->pos < info->offset) {
1151 data += (info->offset - info->pos);
1152 len -= (info->offset - info->pos);
1153 }
1154
1155 if (len > 0) {
1156 memcpy(info->buffer + info->pos, data, len);
1157 info->pos += len;
1158 }
1159}
1160
1161static int copy_info(struct info_str *info, char *fmt, ...)
1162{
1163 va_list args;
1164 char buf[81];
1165 int len;
1166
1167 va_start(args, fmt);
1168 len = vsprintf(buf, fmt, args);
1169 va_end(args);
1170
1171 copy_mem_info(info, buf, len);
1172 return len;
1173}
1174
1175
1176
1177
1178static int sym_host_info(struct Scsi_Host *shost, char *ptr, off_t offset, int len)
1179{
1180 struct sym_data *sym_data = shost_priv(shost);
1181 struct pci_dev *pdev = sym_data->pdev;
1182 struct sym_hcb *np = sym_data->ncb;
1183 struct info_str info;
1184
1185 info.buffer = ptr;
1186 info.length = len;
1187 info.offset = offset;
1188 info.pos = 0;
1189
1190 copy_info(&info, "Chip " NAME53C "%s, device id 0x%x, "
1191 "revision id 0x%x\n", np->s.chip_name,
1192 pdev->device, pdev->revision);
1193 copy_info(&info, "At PCI address %s, IRQ %u\n",
1194 pci_name(pdev), pdev->irq);
1195 copy_info(&info, "Min. period factor %d, %s SCSI BUS%s\n",
1196 (int) (np->minsync_dt ? np->minsync_dt : np->minsync),
1197 np->maxwide ? "Wide" : "Narrow",
1198 np->minsync_dt ? ", DT capable" : "");
1199
1200 copy_info(&info, "Max. started commands %d, "
1201 "max. commands per LUN %d\n",
1202 SYM_CONF_MAX_START, SYM_CONF_MAX_TAG);
1203
1204 return info.pos > info.offset? info.pos - info.offset : 0;
1205}
1206#endif
1207
1208
1209
1210
1211
1212
1213static int sym53c8xx_proc_info(struct Scsi_Host *shost, char *buffer,
1214 char **start, off_t offset, int length, int func)
1215{
1216 int retv;
1217
1218 if (func) {
1219#ifdef SYM_LINUX_USER_COMMAND_SUPPORT
1220 retv = sym_user_command(shost, buffer, length);
1221#else
1222 retv = -EINVAL;
1223#endif
1224 } else {
1225 if (start)
1226 *start = buffer;
1227#ifdef SYM_LINUX_USER_INFO_SUPPORT
1228 retv = sym_host_info(shost, buffer, offset, length);
1229#else
1230 retv = -EINVAL;
1231#endif
1232 }
1233
1234 return retv;
1235}
1236#endif
1237
1238
1239
1240
1241static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev)
1242{
1243
1244
1245
1246 if (pdev->irq)
1247 free_irq(pdev->irq, np->s.host);
1248 if (np->s.ioaddr)
1249 pci_iounmap(pdev, np->s.ioaddr);
1250 if (np->s.ramaddr)
1251 pci_iounmap(pdev, np->s.ramaddr);
1252
1253
1254
1255 sym_hcb_free(np);
1256
1257 sym_mfree_dma(np, sizeof(*np), "HCB");
1258}
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
1270 int unit, struct sym_device *dev)
1271{
1272 struct sym_data *sym_data;
1273 struct sym_hcb *np = NULL;
1274 struct Scsi_Host *shost;
1275 struct pci_dev *pdev = dev->pdev;
1276 unsigned long flags;
1277 struct sym_fw *fw;
1278
1279 printk(KERN_INFO "sym%d: <%s> rev 0x%x at pci %s irq %u\n",
1280 unit, dev->chip.name, pdev->revision, pci_name(pdev),
1281 pdev->irq);
1282
1283
1284
1285
1286 fw = sym_find_firmware(&dev->chip);
1287 if (!fw)
1288 return NULL;
1289
1290 shost = scsi_host_alloc(tpnt, sizeof(*sym_data));
1291 if (!shost)
1292 return NULL;
1293 sym_data = shost_priv(shost);
1294
1295
1296
1297
1298
1299
1300
1301 np = __sym_calloc_dma(&pdev->dev, sizeof(*np), "HCB");
1302 if (!np)
1303 goto attach_failed;
1304 np->bus_dmat = &pdev->dev;
1305 sym_data->ncb = np;
1306 sym_data->pdev = pdev;
1307 np->s.host = shost;
1308
1309 pci_set_drvdata(pdev, shost);
1310
1311
1312
1313
1314 np->hcb_ba = vtobus(np);
1315 np->verbose = sym_driver_setup.verbose;
1316 np->s.unit = unit;
1317 np->features = dev->chip.features;
1318 np->clock_divn = dev->chip.nr_divisor;
1319 np->maxoffs = dev->chip.offset_max;
1320 np->maxburst = dev->chip.burst_max;
1321 np->myaddr = dev->host_id;
1322
1323
1324
1325
1326 strlcpy(np->s.chip_name, dev->chip.name, sizeof(np->s.chip_name));
1327 sprintf(np->s.inst_name, "sym%d", np->s.unit);
1328
1329 if ((SYM_CONF_DMA_ADDRESSING_MODE > 0) && (np->features & FE_DAC) &&
1330 !pci_set_dma_mask(pdev, DMA_DAC_MASK)) {
1331 set_dac(np);
1332 } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
1333 printf_warning("%s: No suitable DMA available\n", sym_name(np));
1334 goto attach_failed;
1335 }
1336
1337
1338
1339
1340
1341 np->mmio_ba = (u32)dev->mmio_base;
1342 np->s.ioaddr = dev->s.ioaddr;
1343 np->s.ramaddr = dev->s.ramaddr;
1344
1345
1346
1347
1348 if (!(np->features & FE_RAM))
1349 dev->ram_base = 0;
1350 if (dev->ram_base)
1351 np->ram_ba = (u32)dev->ram_base;
1352
1353 if (sym_hcb_attach(shost, fw, dev->nvram))
1354 goto attach_failed;
1355
1356
1357
1358
1359
1360
1361 if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX,
1362 shost)) {
1363 printf_err("%s: request irq %u failure\n",
1364 sym_name(np), pdev->irq);
1365 goto attach_failed;
1366 }
1367
1368
1369
1370
1371
1372 spin_lock_irqsave(shost->host_lock, flags);
1373 if (sym_reset_scsi_bus(np, 0))
1374 goto reset_failed;
1375
1376
1377
1378
1379 sym_start_up(shost, 1);
1380
1381
1382
1383
1384 init_timer(&np->s.timer);
1385 np->s.timer.data = (unsigned long) np;
1386 np->s.timer.function = sym53c8xx_timer;
1387 np->s.lasttime=0;
1388 sym_timer (np);
1389
1390
1391
1392
1393
1394 shost->max_channel = 0;
1395 shost->this_id = np->myaddr;
1396 shost->max_id = np->maxwide ? 16 : 8;
1397 shost->max_lun = SYM_CONF_MAX_LUN;
1398 shost->unique_id = pci_resource_start(pdev, 0);
1399 shost->cmd_per_lun = SYM_CONF_MAX_TAG;
1400 shost->can_queue = (SYM_CONF_MAX_START-2);
1401 shost->sg_tablesize = SYM_CONF_MAX_SG;
1402 shost->max_cmd_len = 16;
1403 BUG_ON(sym2_transport_template == NULL);
1404 shost->transportt = sym2_transport_template;
1405
1406
1407 if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 2)
1408 shost->dma_boundary = 0xFFFFFF;
1409
1410 spin_unlock_irqrestore(shost->host_lock, flags);
1411
1412 return shost;
1413
1414 reset_failed:
1415 printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, "
1416 "TERMINATION, DEVICE POWER etc.!\n", sym_name(np));
1417 spin_unlock_irqrestore(shost->host_lock, flags);
1418 attach_failed:
1419 if (!shost)
1420 return NULL;
1421 printf_info("%s: giving up ...\n", sym_name(np));
1422 if (np)
1423 sym_free_resources(np, pdev);
1424 scsi_host_put(shost);
1425
1426 return NULL;
1427 }
1428
1429
1430
1431
1432
1433#if SYM_CONF_NVRAM_SUPPORT
1434static void __devinit sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp)
1435{
1436 devp->nvram = nvp;
1437 nvp->type = 0;
1438
1439 sym_read_nvram(devp, nvp);
1440}
1441#else
1442static inline void sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp)
1443{
1444}
1445#endif
1446
1447static int __devinit sym_check_supported(struct sym_device *device)
1448{
1449 struct sym_chip *chip;
1450 struct pci_dev *pdev = device->pdev;
1451 unsigned long io_port = pci_resource_start(pdev, 0);
1452 int i;
1453
1454
1455
1456
1457
1458 if (io_port) {
1459 for (i = 0 ; i < 8 ; i++) {
1460 if (sym_driver_setup.excludes[i] == io_port)
1461 return -ENODEV;
1462 }
1463 }
1464
1465
1466
1467
1468
1469
1470 chip = sym_lookup_chip_table(pdev->device, pdev->revision);
1471 if (!chip) {
1472 dev_info(&pdev->dev, "device not supported\n");
1473 return -ENODEV;
1474 }
1475 memcpy(&device->chip, chip, sizeof(device->chip));
1476
1477 return 0;
1478}
1479
1480
1481
1482
1483
1484static int __devinit sym_check_raid(struct sym_device *device)
1485{
1486 unsigned int ram_size, ram_val;
1487
1488 if (!device->s.ramaddr)
1489 return 0;
1490
1491 if (device->chip.features & FE_RAM8K)
1492 ram_size = 8192;
1493 else
1494 ram_size = 4096;
1495
1496 ram_val = readl(device->s.ramaddr + ram_size - 16);
1497 if (ram_val != 0x52414944)
1498 return 0;
1499
1500 dev_info(&device->pdev->dev,
1501 "not initializing, driven by RAID controller.\n");
1502 return -ENODEV;
1503}
1504
1505static int __devinit sym_set_workarounds(struct sym_device *device)
1506{
1507 struct sym_chip *chip = &device->chip;
1508 struct pci_dev *pdev = device->pdev;
1509 u_short status_reg;
1510
1511
1512
1513
1514
1515
1516 if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 0x4) {
1517 chip->features |= (FE_WRIE | FE_CLSE);
1518 }
1519
1520
1521 if (chip->features & FE_WRIE) {
1522 if (pci_set_mwi(pdev))
1523 return -ENODEV;
1524 }
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537 pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1538 if (chip->features & FE_66MHZ) {
1539 if (!(status_reg & PCI_STATUS_66MHZ))
1540 chip->features &= ~FE_66MHZ;
1541 } else {
1542 if (status_reg & PCI_STATUS_66MHZ) {
1543 status_reg = PCI_STATUS_66MHZ;
1544 pci_write_config_word(pdev, PCI_STATUS, status_reg);
1545 pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1546 }
1547 }
1548
1549 return 0;
1550}
1551
1552
1553
1554
1555
1556
1557static void __devinit
1558sym_init_device(struct pci_dev *pdev, struct sym_device *device)
1559{
1560 int i = 2;
1561 struct pci_bus_region bus_addr;
1562
1563 device->host_id = SYM_SETUP_HOST_ID;
1564 device->pdev = pdev;
1565
1566 pcibios_resource_to_bus(pdev, &bus_addr, &pdev->resource[1]);
1567 device->mmio_base = bus_addr.start;
1568
1569
1570
1571
1572
1573 if (!pdev->resource[i].flags)
1574 i++;
1575 pcibios_resource_to_bus(pdev, &bus_addr, &pdev->resource[i]);
1576 device->ram_base = bus_addr.start;
1577
1578#ifdef CONFIG_SCSI_SYM53C8XX_MMIO
1579 if (device->mmio_base)
1580 device->s.ioaddr = pci_iomap(pdev, 1,
1581 pci_resource_len(pdev, 1));
1582#endif
1583 if (!device->s.ioaddr)
1584 device->s.ioaddr = pci_iomap(pdev, 0,
1585 pci_resource_len(pdev, 0));
1586 if (device->ram_base)
1587 device->s.ramaddr = pci_iomap(pdev, i,
1588 pci_resource_len(pdev, i));
1589}
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604static void sym_config_pqs(struct pci_dev *pdev, struct sym_device *sym_dev)
1605{
1606 int slot;
1607 u8 tmp;
1608
1609 for (slot = 0; slot < 256; slot++) {
1610 struct pci_dev *memc = pci_get_slot(pdev->bus, slot);
1611
1612 if (!memc || memc->vendor != 0x101a || memc->device == 0x0009) {
1613 pci_dev_put(memc);
1614 continue;
1615 }
1616
1617
1618 pci_read_config_byte(memc, 0x44, &tmp);
1619 if ((tmp & 0x2) == 0) {
1620 tmp |= 0x2;
1621 pci_write_config_byte(memc, 0x44, tmp);
1622 }
1623
1624
1625 pci_read_config_byte(memc, 0x45, &tmp);
1626 if ((tmp & 0x4) == 0) {
1627 tmp |= 0x4;
1628 pci_write_config_byte(memc, 0x45, tmp);
1629 }
1630
1631 pci_dev_put(memc);
1632 break;
1633 }
1634
1635 pci_read_config_byte(pdev, 0x84, &tmp);
1636 sym_dev->host_id = tmp;
1637}
1638
1639
1640
1641
1642
1643
1644static int sym_detach(struct Scsi_Host *shost, struct pci_dev *pdev)
1645{
1646 struct sym_hcb *np = sym_get_hcb(shost);
1647 printk("%s: detaching ...\n", sym_name(np));
1648
1649 del_timer_sync(&np->s.timer);
1650
1651
1652
1653
1654
1655
1656 printk("%s: resetting chip\n", sym_name(np));
1657 OUTB(np, nc_istat, SRST);
1658 INB(np, nc_mbox1);
1659 udelay(10);
1660 OUTB(np, nc_istat, 0);
1661
1662 sym_free_resources(np, pdev);
1663
1664 return 1;
1665}
1666
1667
1668
1669
1670static struct scsi_host_template sym2_template = {
1671 .module = THIS_MODULE,
1672 .name = "sym53c8xx",
1673 .info = sym53c8xx_info,
1674 .queuecommand = sym53c8xx_queue_command,
1675 .slave_alloc = sym53c8xx_slave_alloc,
1676 .slave_configure = sym53c8xx_slave_configure,
1677 .slave_destroy = sym53c8xx_slave_destroy,
1678 .eh_abort_handler = sym53c8xx_eh_abort_handler,
1679 .eh_device_reset_handler = sym53c8xx_eh_device_reset_handler,
1680 .eh_bus_reset_handler = sym53c8xx_eh_bus_reset_handler,
1681 .eh_host_reset_handler = sym53c8xx_eh_host_reset_handler,
1682 .this_id = 7,
1683 .use_clustering = ENABLE_CLUSTERING,
1684 .max_sectors = 0xFFFF,
1685#ifdef SYM_LINUX_PROC_INFO_SUPPORT
1686 .proc_info = sym53c8xx_proc_info,
1687 .proc_name = NAME53C8XX,
1688#endif
1689};
1690
1691static int attach_count;
1692
1693static int __devinit sym2_probe(struct pci_dev *pdev,
1694 const struct pci_device_id *ent)
1695{
1696 struct sym_device sym_dev;
1697 struct sym_nvram nvram;
1698 struct Scsi_Host *shost;
1699
1700 memset(&sym_dev, 0, sizeof(sym_dev));
1701 memset(&nvram, 0, sizeof(nvram));
1702
1703 if (pci_enable_device(pdev))
1704 goto leave;
1705
1706 pci_set_master(pdev);
1707
1708 if (pci_request_regions(pdev, NAME53C8XX))
1709 goto disable;
1710
1711 sym_init_device(pdev, &sym_dev);
1712 if (sym_check_supported(&sym_dev))
1713 goto free;
1714
1715 if (sym_check_raid(&sym_dev))
1716 goto leave;
1717
1718 if (sym_set_workarounds(&sym_dev))
1719 goto free;
1720
1721 sym_config_pqs(pdev, &sym_dev);
1722
1723 sym_get_nvram(&sym_dev, &nvram);
1724
1725 shost = sym_attach(&sym2_template, attach_count, &sym_dev);
1726 if (!shost)
1727 goto free;
1728
1729 if (scsi_add_host(shost, &pdev->dev))
1730 goto detach;
1731 scsi_scan_host(shost);
1732
1733 attach_count++;
1734
1735 return 0;
1736
1737 detach:
1738 sym_detach(pci_get_drvdata(pdev), pdev);
1739 free:
1740 pci_release_regions(pdev);
1741 disable:
1742 pci_disable_device(pdev);
1743 leave:
1744 return -ENODEV;
1745}
1746
1747static void sym2_remove(struct pci_dev *pdev)
1748{
1749 struct Scsi_Host *shost = pci_get_drvdata(pdev);
1750
1751 scsi_remove_host(shost);
1752 scsi_host_put(shost);
1753 sym_detach(shost, pdev);
1754 pci_release_regions(pdev);
1755 pci_disable_device(pdev);
1756
1757 attach_count--;
1758}
1759
1760
1761
1762
1763
1764
1765static pci_ers_result_t sym2_io_error_detected(struct pci_dev *pdev,
1766 enum pci_channel_state state)
1767{
1768
1769 if (state == pci_channel_io_perm_failure) {
1770 sym2_remove(pdev);
1771 return PCI_ERS_RESULT_DISCONNECT;
1772 }
1773
1774 disable_irq(pdev->irq);
1775 pci_disable_device(pdev);
1776
1777
1778 return PCI_ERS_RESULT_CAN_RECOVER;
1779}
1780
1781
1782
1783
1784
1785static pci_ers_result_t sym2_io_slot_dump(struct pci_dev *pdev)
1786{
1787 struct Scsi_Host *shost = pci_get_drvdata(pdev);
1788
1789 sym_dump_registers(shost);
1790
1791
1792 return PCI_ERS_RESULT_NEED_RESET;
1793}
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803static void sym2_reset_workarounds(struct pci_dev *pdev)
1804{
1805 u_short status_reg;
1806 struct sym_chip *chip;
1807
1808 chip = sym_lookup_chip_table(pdev->device, pdev->revision);
1809
1810
1811
1812
1813 pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1814 if (!(chip->features & FE_66MHZ) && (status_reg & PCI_STATUS_66MHZ)) {
1815 status_reg = PCI_STATUS_66MHZ;
1816 pci_write_config_word(pdev, PCI_STATUS, status_reg);
1817 pci_read_config_word(pdev, PCI_STATUS, &status_reg);
1818 }
1819}
1820
1821
1822
1823
1824
1825
1826
1827static pci_ers_result_t sym2_io_slot_reset(struct pci_dev *pdev)
1828{
1829 struct Scsi_Host *shost = pci_get_drvdata(pdev);
1830 struct sym_hcb *np = sym_get_hcb(shost);
1831
1832 printk(KERN_INFO "%s: recovering from a PCI slot reset\n",
1833 sym_name(np));
1834
1835 if (pci_enable_device(pdev)) {
1836 printk(KERN_ERR "%s: Unable to enable after PCI reset\n",
1837 sym_name(np));
1838 return PCI_ERS_RESULT_DISCONNECT;
1839 }
1840
1841 pci_set_master(pdev);
1842 enable_irq(pdev->irq);
1843
1844
1845 if (np->features & FE_WRIE) {
1846 if (pci_set_mwi(pdev))
1847 return PCI_ERS_RESULT_DISCONNECT;
1848 }
1849
1850
1851 sym2_reset_workarounds(pdev);
1852
1853
1854 if (PCI_FUNC(pdev->devfn) == 0) {
1855 if (sym_reset_scsi_bus(np, 0)) {
1856 printk(KERN_ERR "%s: Unable to reset scsi host\n",
1857 sym_name(np));
1858 return PCI_ERS_RESULT_DISCONNECT;
1859 }
1860 sym_start_up(shost, 1);
1861 }
1862
1863 return PCI_ERS_RESULT_RECOVERED;
1864}
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874static void sym2_io_resume(struct pci_dev *pdev)
1875{
1876 struct Scsi_Host *shost = pci_get_drvdata(pdev);
1877 struct sym_data *sym_data = shost_priv(shost);
1878
1879 spin_lock_irq(shost->host_lock);
1880 if (sym_data->io_reset)
1881 complete_all(sym_data->io_reset);
1882 spin_unlock_irq(shost->host_lock);
1883}
1884
1885static void sym2_get_signalling(struct Scsi_Host *shost)
1886{
1887 struct sym_hcb *np = sym_get_hcb(shost);
1888 enum spi_signal_type type;
1889
1890 switch (np->scsi_mode) {
1891 case SMODE_SE:
1892 type = SPI_SIGNAL_SE;
1893 break;
1894 case SMODE_LVD:
1895 type = SPI_SIGNAL_LVD;
1896 break;
1897 case SMODE_HVD:
1898 type = SPI_SIGNAL_HVD;
1899 break;
1900 default:
1901 type = SPI_SIGNAL_UNKNOWN;
1902 break;
1903 }
1904 spi_signalling(shost) = type;
1905}
1906
1907static void sym2_set_offset(struct scsi_target *starget, int offset)
1908{
1909 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1910 struct sym_hcb *np = sym_get_hcb(shost);
1911 struct sym_tcb *tp = &np->target[starget->id];
1912
1913 tp->tgoal.offset = offset;
1914 tp->tgoal.check_nego = 1;
1915}
1916
1917static void sym2_set_period(struct scsi_target *starget, int period)
1918{
1919 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1920 struct sym_hcb *np = sym_get_hcb(shost);
1921 struct sym_tcb *tp = &np->target[starget->id];
1922
1923
1924
1925 if (period <= np->minsync && spi_width(starget))
1926 tp->tgoal.dt = 1;
1927
1928 tp->tgoal.period = period;
1929 tp->tgoal.check_nego = 1;
1930}
1931
1932static void sym2_set_width(struct scsi_target *starget, int width)
1933{
1934 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1935 struct sym_hcb *np = sym_get_hcb(shost);
1936 struct sym_tcb *tp = &np->target[starget->id];
1937
1938
1939
1940 if (width == 0)
1941 tp->tgoal.iu = tp->tgoal.dt = tp->tgoal.qas = 0;
1942
1943 tp->tgoal.width = width;
1944 tp->tgoal.check_nego = 1;
1945}
1946
1947static void sym2_set_dt(struct scsi_target *starget, int dt)
1948{
1949 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1950 struct sym_hcb *np = sym_get_hcb(shost);
1951 struct sym_tcb *tp = &np->target[starget->id];
1952
1953
1954 if (dt)
1955 tp->tgoal.dt = 1;
1956 else
1957 tp->tgoal.iu = tp->tgoal.dt = tp->tgoal.qas = 0;
1958 tp->tgoal.check_nego = 1;
1959}
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989static struct spi_function_template sym2_transport_functions = {
1990 .set_offset = sym2_set_offset,
1991 .show_offset = 1,
1992 .set_period = sym2_set_period,
1993 .show_period = 1,
1994 .set_width = sym2_set_width,
1995 .show_width = 1,
1996 .set_dt = sym2_set_dt,
1997 .show_dt = 1,
1998
1999
2000
2001
2002
2003
2004 .get_signalling = sym2_get_signalling,
2005};
2006
2007static struct pci_device_id sym2_id_table[] __devinitdata = {
2008 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C810,
2009 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2010 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C820,
2011 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2012 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C825,
2013 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2014 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C815,
2015 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2016 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C810AP,
2017 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2018 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C860,
2019 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2020 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1510,
2021 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_SCSI<<8, 0xffff00, 0UL },
2022 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C896,
2023 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2024 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C895,
2025 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2026 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C885,
2027 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2028 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C875,
2029 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2030 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C1510,
2031 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_STORAGE_SCSI<<8, 0xffff00, 0UL },
2032 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C895A,
2033 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2034 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C875A,
2035 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2036 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1010_33,
2037 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2038 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_53C1010_66,
2039 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2040 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_NCR_53C875J,
2041 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
2042 { 0, }
2043};
2044
2045MODULE_DEVICE_TABLE(pci, sym2_id_table);
2046
2047static struct pci_error_handlers sym2_err_handler = {
2048 .error_detected = sym2_io_error_detected,
2049 .mmio_enabled = sym2_io_slot_dump,
2050 .slot_reset = sym2_io_slot_reset,
2051 .resume = sym2_io_resume,
2052};
2053
2054static struct pci_driver sym2_driver = {
2055 .name = NAME53C8XX,
2056 .id_table = sym2_id_table,
2057 .probe = sym2_probe,
2058 .remove = sym2_remove,
2059 .err_handler = &sym2_err_handler,
2060};
2061
2062static int __init sym2_init(void)
2063{
2064 int error;
2065
2066 sym2_setup_params();
2067 sym2_transport_template = spi_attach_transport(&sym2_transport_functions);
2068 if (!sym2_transport_template)
2069 return -ENODEV;
2070
2071 error = pci_register_driver(&sym2_driver);
2072 if (error)
2073 spi_release_transport(sym2_transport_template);
2074 return error;
2075}
2076
2077static void __exit sym2_exit(void)
2078{
2079 pci_unregister_driver(&sym2_driver);
2080 spi_release_transport(sym2_transport_template);
2081}
2082
2083module_init(sym2_init);
2084module_exit(sym2_exit);