1 /* esp_scsi.c: ESP SCSI driver.
3 * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
6 #include <linux/kernel.h>
7 #include <linux/types.h>
8 #include <linux/slab.h>
9 #include <linux/delay.h>
10 #include <linux/list.h>
11 #include <linux/completion.h>
12 #include <linux/kallsyms.h>
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/init.h>
16 #include <linux/irqreturn.h>
22 #include <scsi/scsi.h>
23 #include <scsi/scsi_host.h>
24 #include <scsi/scsi_cmnd.h>
25 #include <scsi/scsi_device.h>
26 #include <scsi/scsi_tcq.h>
27 #include <scsi/scsi_dbg.h>
28 #include <scsi/scsi_transport_spi.h>
32 #define DRV_MODULE_NAME "esp"
33 #define PFX DRV_MODULE_NAME ": "
34 #define DRV_VERSION "2.000"
35 #define DRV_MODULE_RELDATE "April 19, 2007"
37 /* SCSI bus reset settle time in seconds. */
38 static int esp_bus_reset_settle
= 3;
41 #define ESP_DEBUG_INTR 0x00000001
42 #define ESP_DEBUG_SCSICMD 0x00000002
43 #define ESP_DEBUG_RESET 0x00000004
44 #define ESP_DEBUG_MSGIN 0x00000008
45 #define ESP_DEBUG_MSGOUT 0x00000010
46 #define ESP_DEBUG_CMDDONE 0x00000020
47 #define ESP_DEBUG_DISCONNECT 0x00000040
48 #define ESP_DEBUG_DATASTART 0x00000080
49 #define ESP_DEBUG_DATADONE 0x00000100
50 #define ESP_DEBUG_RECONNECT 0x00000200
51 #define ESP_DEBUG_AUTOSENSE 0x00000400
53 #define esp_log_intr(f, a...) \
54 do { if (esp_debug & ESP_DEBUG_INTR) \
58 #define esp_log_reset(f, a...) \
59 do { if (esp_debug & ESP_DEBUG_RESET) \
63 #define esp_log_msgin(f, a...) \
64 do { if (esp_debug & ESP_DEBUG_MSGIN) \
68 #define esp_log_msgout(f, a...) \
69 do { if (esp_debug & ESP_DEBUG_MSGOUT) \
73 #define esp_log_cmddone(f, a...) \
74 do { if (esp_debug & ESP_DEBUG_CMDDONE) \
78 #define esp_log_disconnect(f, a...) \
79 do { if (esp_debug & ESP_DEBUG_DISCONNECT) \
83 #define esp_log_datastart(f, a...) \
84 do { if (esp_debug & ESP_DEBUG_DATASTART) \
88 #define esp_log_datadone(f, a...) \
89 do { if (esp_debug & ESP_DEBUG_DATADONE) \
93 #define esp_log_reconnect(f, a...) \
94 do { if (esp_debug & ESP_DEBUG_RECONNECT) \
98 #define esp_log_autosense(f, a...) \
99 do { if (esp_debug & ESP_DEBUG_AUTOSENSE) \
103 #define esp_read8(REG) esp->ops->esp_read8(esp, REG)
104 #define esp_write8(VAL,REG) esp->ops->esp_write8(esp, VAL, REG)
106 static void esp_log_fill_regs(struct esp
*esp
,
107 struct esp_event_ent
*p
)
110 p
->seqreg
= esp
->seqreg
;
111 p
->sreg2
= esp
->sreg2
;
113 p
->select_state
= esp
->select_state
;
114 p
->event
= esp
->event
;
117 void scsi_esp_cmd(struct esp
*esp
, u8 val
)
119 struct esp_event_ent
*p
;
120 int idx
= esp
->esp_event_cur
;
122 p
= &esp
->esp_event_log
[idx
];
123 p
->type
= ESP_EVENT_TYPE_CMD
;
125 esp_log_fill_regs(esp
, p
);
127 esp
->esp_event_cur
= (idx
+ 1) & (ESP_EVENT_LOG_SZ
- 1);
129 esp_write8(val
, ESP_CMD
);
131 EXPORT_SYMBOL(scsi_esp_cmd
);
133 static void esp_event(struct esp
*esp
, u8 val
)
135 struct esp_event_ent
*p
;
136 int idx
= esp
->esp_event_cur
;
138 p
= &esp
->esp_event_log
[idx
];
139 p
->type
= ESP_EVENT_TYPE_EVENT
;
141 esp_log_fill_regs(esp
, p
);
143 esp
->esp_event_cur
= (idx
+ 1) & (ESP_EVENT_LOG_SZ
- 1);
148 static void esp_dump_cmd_log(struct esp
*esp
)
150 int idx
= esp
->esp_event_cur
;
153 printk(KERN_INFO PFX
"esp%d: Dumping command log\n",
154 esp
->host
->unique_id
);
156 struct esp_event_ent
*p
= &esp
->esp_event_log
[idx
];
158 printk(KERN_INFO PFX
"esp%d: ent[%d] %s ",
159 esp
->host
->unique_id
, idx
,
160 p
->type
== ESP_EVENT_TYPE_CMD
? "CMD" : "EVENT");
162 printk("val[%02x] sreg[%02x] seqreg[%02x] "
163 "sreg2[%02x] ireg[%02x] ss[%02x] event[%02x]\n",
164 p
->val
, p
->sreg
, p
->seqreg
,
165 p
->sreg2
, p
->ireg
, p
->select_state
, p
->event
);
167 idx
= (idx
+ 1) & (ESP_EVENT_LOG_SZ
- 1);
168 } while (idx
!= stop
);
171 static void esp_flush_fifo(struct esp
*esp
)
173 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
174 if (esp
->rev
== ESP236
) {
177 while (esp_read8(ESP_FFLAGS
) & ESP_FF_FBYTES
) {
179 printk(KERN_ALERT PFX
"esp%d: ESP_FF_BYTES "
181 esp
->host
->unique_id
);
189 static void hme_read_fifo(struct esp
*esp
)
191 int fcnt
= esp_read8(ESP_FFLAGS
) & ESP_FF_FBYTES
;
195 esp
->fifo
[idx
++] = esp_read8(ESP_FDATA
);
196 esp
->fifo
[idx
++] = esp_read8(ESP_FDATA
);
198 if (esp
->sreg2
& ESP_STAT2_F1BYTE
) {
199 esp_write8(0, ESP_FDATA
);
200 esp
->fifo
[idx
++] = esp_read8(ESP_FDATA
);
201 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
206 static void esp_set_all_config3(struct esp
*esp
, u8 val
)
210 for (i
= 0; i
< ESP_MAX_TARGET
; i
++)
211 esp
->target
[i
].esp_config3
= val
;
214 /* Reset the ESP chip, _not_ the SCSI bus. */
215 static void esp_reset_esp(struct esp
*esp
)
217 u8 family_code
, version
;
219 /* Now reset the ESP chip */
220 scsi_esp_cmd(esp
, ESP_CMD_RC
);
221 scsi_esp_cmd(esp
, ESP_CMD_NULL
| ESP_CMD_DMA
);
222 if (esp
->rev
== FAST
)
223 esp_write8(ESP_CONFIG2_FENAB
, ESP_CFG2
);
224 scsi_esp_cmd(esp
, ESP_CMD_NULL
| ESP_CMD_DMA
);
226 /* This is the only point at which it is reliable to read
227 * the ID-code for a fast ESP chip variants.
229 esp
->max_period
= ((35 * esp
->ccycle
) / 1000);
230 if (esp
->rev
== FAST
) {
231 version
= esp_read8(ESP_UID
);
232 family_code
= (version
& 0xf8) >> 3;
233 if (family_code
== 0x02)
235 else if (family_code
== 0x0a)
236 esp
->rev
= FASHME
; /* Version is usually '5'. */
239 esp
->min_period
= ((4 * esp
->ccycle
) / 1000);
241 esp
->min_period
= ((5 * esp
->ccycle
) / 1000);
243 esp
->max_period
= (esp
->max_period
+ 3)>>2;
244 esp
->min_period
= (esp
->min_period
+ 3)>>2;
246 esp_write8(esp
->config1
, ESP_CFG1
);
253 esp_write8(esp
->config2
, ESP_CFG2
);
258 esp_write8(esp
->config2
, ESP_CFG2
);
259 esp
->prev_cfg3
= esp
->target
[0].esp_config3
;
260 esp_write8(esp
->prev_cfg3
, ESP_CFG3
);
264 esp
->config2
|= (ESP_CONFIG2_HME32
| ESP_CONFIG2_HMEFENAB
);
268 /* Fast 236 or HME */
269 esp_write8(esp
->config2
, ESP_CFG2
);
270 if (esp
->rev
== FASHME
) {
271 u8 cfg3
= esp
->target
[0].esp_config3
;
273 cfg3
|= ESP_CONFIG3_FCLOCK
| ESP_CONFIG3_OBPUSH
;
274 if (esp
->scsi_id
>= 8)
275 cfg3
|= ESP_CONFIG3_IDBIT3
;
276 esp_set_all_config3(esp
, cfg3
);
278 u32 cfg3
= esp
->target
[0].esp_config3
;
280 cfg3
|= ESP_CONFIG3_FCLK
;
281 esp_set_all_config3(esp
, cfg3
);
283 esp
->prev_cfg3
= esp
->target
[0].esp_config3
;
284 esp_write8(esp
->prev_cfg3
, ESP_CFG3
);
285 if (esp
->rev
== FASHME
) {
288 if (esp
->flags
& ESP_FLAG_DIFFERENTIAL
)
297 esp_write8(esp
->config2
, ESP_CFG2
);
298 esp_set_all_config3(esp
,
299 (esp
->target
[0].esp_config3
|
300 ESP_CONFIG3_FCLOCK
));
301 esp
->prev_cfg3
= esp
->target
[0].esp_config3
;
302 esp_write8(esp
->prev_cfg3
, ESP_CFG3
);
310 /* Reload the configuration registers */
311 esp_write8(esp
->cfact
, ESP_CFACT
);
314 esp_write8(esp
->prev_stp
, ESP_STP
);
317 esp_write8(esp
->prev_soff
, ESP_SOFF
);
319 esp_write8(esp
->neg_defp
, ESP_TIMEO
);
321 /* Eat any bitrot in the chip */
322 esp_read8(ESP_INTRPT
);
326 static void esp_map_dma(struct esp
*esp
, struct scsi_cmnd
*cmd
)
328 struct esp_cmd_priv
*spriv
= ESP_CMD_PRIV(cmd
);
329 struct scatterlist
*sg
= scsi_sglist(cmd
);
330 int dir
= cmd
->sc_data_direction
;
336 spriv
->u
.num_sg
= esp
->ops
->map_sg(esp
, sg
, scsi_sg_count(cmd
), dir
);
337 spriv
->cur_residue
= sg_dma_len(sg
);
341 for (i
= 0; i
< spriv
->u
.num_sg
; i
++)
342 total
+= sg_dma_len(&sg
[i
]);
343 spriv
->tot_residue
= total
;
346 static dma_addr_t
esp_cur_dma_addr(struct esp_cmd_entry
*ent
,
347 struct scsi_cmnd
*cmd
)
349 struct esp_cmd_priv
*p
= ESP_CMD_PRIV(cmd
);
351 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
352 return ent
->sense_dma
+
353 (ent
->sense_ptr
- cmd
->sense_buffer
);
356 return sg_dma_address(p
->cur_sg
) +
357 (sg_dma_len(p
->cur_sg
) -
361 static unsigned int esp_cur_dma_len(struct esp_cmd_entry
*ent
,
362 struct scsi_cmnd
*cmd
)
364 struct esp_cmd_priv
*p
= ESP_CMD_PRIV(cmd
);
366 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
367 return SCSI_SENSE_BUFFERSIZE
-
368 (ent
->sense_ptr
- cmd
->sense_buffer
);
370 return p
->cur_residue
;
373 static void esp_advance_dma(struct esp
*esp
, struct esp_cmd_entry
*ent
,
374 struct scsi_cmnd
*cmd
, unsigned int len
)
376 struct esp_cmd_priv
*p
= ESP_CMD_PRIV(cmd
);
378 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
379 ent
->sense_ptr
+= len
;
383 p
->cur_residue
-= len
;
384 p
->tot_residue
-= len
;
385 if (p
->cur_residue
< 0 || p
->tot_residue
< 0) {
386 printk(KERN_ERR PFX
"esp%d: Data transfer overflow.\n",
387 esp
->host
->unique_id
);
388 printk(KERN_ERR PFX
"esp%d: cur_residue[%d] tot_residue[%d] "
390 esp
->host
->unique_id
,
391 p
->cur_residue
, p
->tot_residue
, len
);
395 if (!p
->cur_residue
&& p
->tot_residue
) {
397 p
->cur_residue
= sg_dma_len(p
->cur_sg
);
401 static void esp_unmap_dma(struct esp
*esp
, struct scsi_cmnd
*cmd
)
403 struct esp_cmd_priv
*spriv
= ESP_CMD_PRIV(cmd
);
404 int dir
= cmd
->sc_data_direction
;
409 esp
->ops
->unmap_sg(esp
, scsi_sglist(cmd
), spriv
->u
.num_sg
, dir
);
412 static void esp_save_pointers(struct esp
*esp
, struct esp_cmd_entry
*ent
)
414 struct scsi_cmnd
*cmd
= ent
->cmd
;
415 struct esp_cmd_priv
*spriv
= ESP_CMD_PRIV(cmd
);
417 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
418 ent
->saved_sense_ptr
= ent
->sense_ptr
;
421 ent
->saved_cur_residue
= spriv
->cur_residue
;
422 ent
->saved_cur_sg
= spriv
->cur_sg
;
423 ent
->saved_tot_residue
= spriv
->tot_residue
;
426 static void esp_restore_pointers(struct esp
*esp
, struct esp_cmd_entry
*ent
)
428 struct scsi_cmnd
*cmd
= ent
->cmd
;
429 struct esp_cmd_priv
*spriv
= ESP_CMD_PRIV(cmd
);
431 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
432 ent
->sense_ptr
= ent
->saved_sense_ptr
;
435 spriv
->cur_residue
= ent
->saved_cur_residue
;
436 spriv
->cur_sg
= ent
->saved_cur_sg
;
437 spriv
->tot_residue
= ent
->saved_tot_residue
;
440 static void esp_check_command_len(struct esp
*esp
, struct scsi_cmnd
*cmd
)
442 if (cmd
->cmd_len
== 6 ||
443 cmd
->cmd_len
== 10 ||
444 cmd
->cmd_len
== 12) {
445 esp
->flags
&= ~ESP_FLAG_DOING_SLOWCMD
;
447 esp
->flags
|= ESP_FLAG_DOING_SLOWCMD
;
451 static void esp_write_tgt_config3(struct esp
*esp
, int tgt
)
453 if (esp
->rev
> ESP100A
) {
454 u8 val
= esp
->target
[tgt
].esp_config3
;
456 if (val
!= esp
->prev_cfg3
) {
457 esp
->prev_cfg3
= val
;
458 esp_write8(val
, ESP_CFG3
);
463 static void esp_write_tgt_sync(struct esp
*esp
, int tgt
)
465 u8 off
= esp
->target
[tgt
].esp_offset
;
466 u8 per
= esp
->target
[tgt
].esp_period
;
468 if (off
!= esp
->prev_soff
) {
469 esp
->prev_soff
= off
;
470 esp_write8(off
, ESP_SOFF
);
472 if (per
!= esp
->prev_stp
) {
474 esp_write8(per
, ESP_STP
);
478 static u32
esp_dma_length_limit(struct esp
*esp
, u32 dma_addr
, u32 dma_len
)
480 if (esp
->rev
== FASHME
) {
481 /* Arbitrary segment boundaries, 24-bit counts. */
482 if (dma_len
> (1U << 24))
483 dma_len
= (1U << 24);
487 /* ESP chip limits other variants by 16-bits of transfer
488 * count. Actually on FAS100A and FAS236 we could get
489 * 24-bits of transfer count by enabling ESP_CONFIG2_FENAB
490 * in the ESP_CFG2 register but that causes other unwanted
491 * changes so we don't use it currently.
493 if (dma_len
> (1U << 16))
494 dma_len
= (1U << 16);
496 /* All of the DMA variants hooked up to these chips
497 * cannot handle crossing a 24-bit address boundary.
499 base
= dma_addr
& ((1U << 24) - 1U);
500 end
= base
+ dma_len
;
501 if (end
> (1U << 24))
503 dma_len
= end
- base
;
508 static int esp_need_to_nego_wide(struct esp_target_data
*tp
)
510 struct scsi_target
*target
= tp
->starget
;
512 return spi_width(target
) != tp
->nego_goal_width
;
515 static int esp_need_to_nego_sync(struct esp_target_data
*tp
)
517 struct scsi_target
*target
= tp
->starget
;
519 /* When offset is zero, period is "don't care". */
520 if (!spi_offset(target
) && !tp
->nego_goal_offset
)
523 if (spi_offset(target
) == tp
->nego_goal_offset
&&
524 spi_period(target
) == tp
->nego_goal_period
)
530 static int esp_alloc_lun_tag(struct esp_cmd_entry
*ent
,
531 struct esp_lun_data
*lp
)
534 /* Non-tagged, slot already taken? */
535 if (lp
->non_tagged_cmd
)
539 /* We are being held by active tagged
545 /* Tagged commands completed, we can unplug
546 * the queue and run this untagged command.
549 } else if (lp
->num_tagged
) {
550 /* Plug the queue until num_tagged decreases
551 * to zero in esp_free_lun_tag.
557 lp
->non_tagged_cmd
= ent
;
560 /* Tagged command, see if blocked by a
563 if (lp
->non_tagged_cmd
|| lp
->hold
)
567 BUG_ON(lp
->tagged_cmds
[ent
->tag
[1]]);
569 lp
->tagged_cmds
[ent
->tag
[1]] = ent
;
575 static void esp_free_lun_tag(struct esp_cmd_entry
*ent
,
576 struct esp_lun_data
*lp
)
579 BUG_ON(lp
->tagged_cmds
[ent
->tag
[1]] != ent
);
580 lp
->tagged_cmds
[ent
->tag
[1]] = NULL
;
583 BUG_ON(lp
->non_tagged_cmd
!= ent
);
584 lp
->non_tagged_cmd
= NULL
;
588 /* When a contingent allegiance conditon is created, we force feed a
589 * REQUEST_SENSE command to the device to fetch the sense data. I
590 * tried many other schemes, relying on the scsi error handling layer
591 * to send out the REQUEST_SENSE automatically, but this was difficult
592 * to get right especially in the presence of applications like smartd
593 * which use SG_IO to send out their own REQUEST_SENSE commands.
595 static void esp_autosense(struct esp
*esp
, struct esp_cmd_entry
*ent
)
597 struct scsi_cmnd
*cmd
= ent
->cmd
;
598 struct scsi_device
*dev
= cmd
->device
;
606 if (!ent
->sense_ptr
) {
607 esp_log_autosense("esp%d: Doing auto-sense for "
609 esp
->host
->unique_id
, tgt
, lun
);
611 ent
->sense_ptr
= cmd
->sense_buffer
;
612 ent
->sense_dma
= esp
->ops
->map_single(esp
,
614 SCSI_SENSE_BUFFERSIZE
,
617 ent
->saved_sense_ptr
= ent
->sense_ptr
;
619 esp
->active_cmd
= ent
;
621 p
= esp
->command_block
;
622 esp
->msg_out_len
= 0;
624 *p
++ = IDENTIFY(0, lun
);
625 *p
++ = REQUEST_SENSE
;
626 *p
++ = ((dev
->scsi_level
<= SCSI_2
) ?
630 *p
++ = SCSI_SENSE_BUFFERSIZE
;
633 esp
->select_state
= ESP_SELECT_BASIC
;
636 if (esp
->rev
== FASHME
)
637 val
|= ESP_BUSID_RESELID
| ESP_BUSID_CTR32BIT
;
638 esp_write8(val
, ESP_BUSID
);
640 esp_write_tgt_sync(esp
, tgt
);
641 esp_write_tgt_config3(esp
, tgt
);
643 val
= (p
- esp
->command_block
);
645 if (esp
->rev
== FASHME
)
646 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
647 esp
->ops
->send_dma_cmd(esp
, esp
->command_block_dma
,
648 val
, 16, 0, ESP_CMD_DMA
| ESP_CMD_SELA
);
651 static struct esp_cmd_entry
*find_and_prep_issuable_command(struct esp
*esp
)
653 struct esp_cmd_entry
*ent
;
655 list_for_each_entry(ent
, &esp
->queued_cmds
, list
) {
656 struct scsi_cmnd
*cmd
= ent
->cmd
;
657 struct scsi_device
*dev
= cmd
->device
;
658 struct esp_lun_data
*lp
= dev
->hostdata
;
660 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
666 if (!scsi_populate_tag_msg(cmd
, &ent
->tag
[0])) {
671 if (esp_alloc_lun_tag(ent
, lp
) < 0)
680 static void esp_maybe_execute_command(struct esp
*esp
)
682 struct esp_target_data
*tp
;
683 struct esp_lun_data
*lp
;
684 struct scsi_device
*dev
;
685 struct scsi_cmnd
*cmd
;
686 struct esp_cmd_entry
*ent
;
691 if (esp
->active_cmd
||
692 (esp
->flags
& ESP_FLAG_RESETTING
))
695 ent
= find_and_prep_issuable_command(esp
);
699 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
700 esp_autosense(esp
, ent
);
708 tp
= &esp
->target
[tgt
];
711 list_del(&ent
->list
);
712 list_add(&ent
->list
, &esp
->active_cmds
);
714 esp
->active_cmd
= ent
;
716 esp_map_dma(esp
, cmd
);
717 esp_save_pointers(esp
, ent
);
719 esp_check_command_len(esp
, cmd
);
721 p
= esp
->command_block
;
723 esp
->msg_out_len
= 0;
724 if (tp
->flags
& ESP_TGT_CHECK_NEGO
) {
725 /* Need to negotiate. If the target is broken
726 * go for synchronous transfers and non-wide.
728 if (tp
->flags
& ESP_TGT_BROKEN
) {
729 tp
->flags
&= ~ESP_TGT_DISCONNECT
;
730 tp
->nego_goal_period
= 0;
731 tp
->nego_goal_offset
= 0;
732 tp
->nego_goal_width
= 0;
733 tp
->nego_goal_tags
= 0;
736 /* If the settings are not changing, skip this. */
737 if (spi_width(tp
->starget
) == tp
->nego_goal_width
&&
738 spi_period(tp
->starget
) == tp
->nego_goal_period
&&
739 spi_offset(tp
->starget
) == tp
->nego_goal_offset
) {
740 tp
->flags
&= ~ESP_TGT_CHECK_NEGO
;
744 if (esp
->rev
== FASHME
&& esp_need_to_nego_wide(tp
)) {
746 spi_populate_width_msg(&esp
->msg_out
[0],
747 (tp
->nego_goal_width
?
749 tp
->flags
|= ESP_TGT_NEGO_WIDE
;
750 } else if (esp_need_to_nego_sync(tp
)) {
752 spi_populate_sync_msg(&esp
->msg_out
[0],
753 tp
->nego_goal_period
,
754 tp
->nego_goal_offset
);
755 tp
->flags
|= ESP_TGT_NEGO_SYNC
;
757 tp
->flags
&= ~ESP_TGT_CHECK_NEGO
;
760 /* Process it like a slow command. */
761 if (tp
->flags
& (ESP_TGT_NEGO_WIDE
| ESP_TGT_NEGO_SYNC
))
762 esp
->flags
|= ESP_FLAG_DOING_SLOWCMD
;
766 /* If we don't have a lun-data struct yet, we're probing
767 * so do not disconnect. Also, do not disconnect unless
768 * we have a tag on this command.
770 if (lp
&& (tp
->flags
& ESP_TGT_DISCONNECT
) && ent
->tag
[0])
771 *p
++ = IDENTIFY(1, lun
);
773 *p
++ = IDENTIFY(0, lun
);
775 if (ent
->tag
[0] && esp
->rev
== ESP100
) {
776 /* ESP100 lacks select w/atn3 command, use select
779 esp
->flags
|= ESP_FLAG_DOING_SLOWCMD
;
782 if (!(esp
->flags
& ESP_FLAG_DOING_SLOWCMD
)) {
783 start_cmd
= ESP_CMD_DMA
| ESP_CMD_SELA
;
788 start_cmd
= ESP_CMD_DMA
| ESP_CMD_SA3
;
791 for (i
= 0; i
< cmd
->cmd_len
; i
++)
794 esp
->select_state
= ESP_SELECT_BASIC
;
796 esp
->cmd_bytes_left
= cmd
->cmd_len
;
797 esp
->cmd_bytes_ptr
= &cmd
->cmnd
[0];
800 for (i
= esp
->msg_out_len
- 1;
802 esp
->msg_out
[i
+ 2] = esp
->msg_out
[i
];
803 esp
->msg_out
[0] = ent
->tag
[0];
804 esp
->msg_out
[1] = ent
->tag
[1];
805 esp
->msg_out_len
+= 2;
808 start_cmd
= ESP_CMD_DMA
| ESP_CMD_SELAS
;
809 esp
->select_state
= ESP_SELECT_MSGOUT
;
812 if (esp
->rev
== FASHME
)
813 val
|= ESP_BUSID_RESELID
| ESP_BUSID_CTR32BIT
;
814 esp_write8(val
, ESP_BUSID
);
816 esp_write_tgt_sync(esp
, tgt
);
817 esp_write_tgt_config3(esp
, tgt
);
819 val
= (p
- esp
->command_block
);
821 if (esp_debug
& ESP_DEBUG_SCSICMD
) {
822 printk("ESP: tgt[%d] lun[%d] scsi_cmd [ ", tgt
, lun
);
823 for (i
= 0; i
< cmd
->cmd_len
; i
++)
824 printk("%02x ", cmd
->cmnd
[i
]);
828 if (esp
->rev
== FASHME
)
829 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
830 esp
->ops
->send_dma_cmd(esp
, esp
->command_block_dma
,
831 val
, 16, 0, start_cmd
);
834 static struct esp_cmd_entry
*esp_get_ent(struct esp
*esp
)
836 struct list_head
*head
= &esp
->esp_cmd_pool
;
837 struct esp_cmd_entry
*ret
;
839 if (list_empty(head
)) {
840 ret
= kzalloc(sizeof(struct esp_cmd_entry
), GFP_ATOMIC
);
842 ret
= list_entry(head
->next
, struct esp_cmd_entry
, list
);
843 list_del(&ret
->list
);
844 memset(ret
, 0, sizeof(*ret
));
849 static void esp_put_ent(struct esp
*esp
, struct esp_cmd_entry
*ent
)
851 list_add(&ent
->list
, &esp
->esp_cmd_pool
);
854 static void esp_cmd_is_done(struct esp
*esp
, struct esp_cmd_entry
*ent
,
855 struct scsi_cmnd
*cmd
, unsigned int result
)
857 struct scsi_device
*dev
= cmd
->device
;
861 esp
->active_cmd
= NULL
;
862 esp_unmap_dma(esp
, cmd
);
863 esp_free_lun_tag(ent
, dev
->hostdata
);
864 cmd
->result
= result
;
867 complete(ent
->eh_done
);
871 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
872 esp
->ops
->unmap_single(esp
, ent
->sense_dma
,
873 SCSI_SENSE_BUFFERSIZE
, DMA_FROM_DEVICE
);
874 ent
->sense_ptr
= NULL
;
876 /* Restore the message/status bytes to what we actually
877 * saw originally. Also, report that we are providing
880 cmd
->result
= ((DRIVER_SENSE
<< 24) |
882 (COMMAND_COMPLETE
<< 8) |
883 (SAM_STAT_CHECK_CONDITION
<< 0));
885 ent
->flags
&= ~ESP_CMD_FLAG_AUTOSENSE
;
886 if (esp_debug
& ESP_DEBUG_AUTOSENSE
) {
889 printk("esp%d: tgt[%d] lun[%d] AUTO SENSE[ ",
890 esp
->host
->unique_id
, tgt
, lun
);
891 for (i
= 0; i
< 18; i
++)
892 printk("%02x ", cmd
->sense_buffer
[i
]);
899 list_del(&ent
->list
);
900 esp_put_ent(esp
, ent
);
902 esp_maybe_execute_command(esp
);
905 static unsigned int compose_result(unsigned int status
, unsigned int message
,
906 unsigned int driver_code
)
908 return (status
| (message
<< 8) | (driver_code
<< 16));
911 static void esp_event_queue_full(struct esp
*esp
, struct esp_cmd_entry
*ent
)
913 struct scsi_device
*dev
= ent
->cmd
->device
;
914 struct esp_lun_data
*lp
= dev
->hostdata
;
916 scsi_track_queue_full(dev
, lp
->num_tagged
- 1);
919 static int esp_queuecommand(struct scsi_cmnd
*cmd
, void (*done
)(struct scsi_cmnd
*))
921 struct scsi_device
*dev
= cmd
->device
;
922 struct esp
*esp
= shost_priv(dev
->host
);
923 struct esp_cmd_priv
*spriv
;
924 struct esp_cmd_entry
*ent
;
926 ent
= esp_get_ent(esp
);
928 return SCSI_MLQUEUE_HOST_BUSY
;
932 cmd
->scsi_done
= done
;
934 spriv
= ESP_CMD_PRIV(cmd
);
935 spriv
->u
.dma_addr
= ~(dma_addr_t
)0x0;
937 list_add_tail(&ent
->list
, &esp
->queued_cmds
);
939 esp_maybe_execute_command(esp
);
944 static int esp_check_gross_error(struct esp
*esp
)
946 if (esp
->sreg
& ESP_STAT_SPAM
) {
947 /* Gross Error, could be one of:
948 * - top of fifo overwritten
949 * - top of command register overwritten
950 * - DMA programmed with wrong direction
951 * - improper phase change
953 printk(KERN_ERR PFX
"esp%d: Gross error sreg[%02x]\n",
954 esp
->host
->unique_id
, esp
->sreg
);
955 /* XXX Reset the chip. XXX */
961 static int esp_check_spur_intr(struct esp
*esp
)
966 /* The interrupt pending bit of the status register cannot
967 * be trusted on these revisions.
969 esp
->sreg
&= ~ESP_STAT_INTR
;
973 if (!(esp
->sreg
& ESP_STAT_INTR
)) {
974 esp
->ireg
= esp_read8(ESP_INTRPT
);
975 if (esp
->ireg
& ESP_INTR_SR
)
978 /* If the DMA is indicating interrupt pending and the
979 * ESP is not, the only possibility is a DMA error.
981 if (!esp
->ops
->dma_error(esp
)) {
982 printk(KERN_ERR PFX
"esp%d: Spurious irq, "
984 esp
->host
->unique_id
, esp
->sreg
);
988 printk(KERN_ERR PFX
"esp%d: DMA error\n",
989 esp
->host
->unique_id
);
991 /* XXX Reset the chip. XXX */
1000 static void esp_schedule_reset(struct esp
*esp
)
1002 esp_log_reset("ESP: esp_schedule_reset() from %p\n",
1003 __builtin_return_address(0));
1004 esp
->flags
|= ESP_FLAG_RESETTING
;
1005 esp_event(esp
, ESP_EVENT_RESET
);
1008 /* In order to avoid having to add a special half-reconnected state
1009 * into the driver we just sit here and poll through the rest of
1010 * the reselection process to get the tag message bytes.
1012 static struct esp_cmd_entry
*esp_reconnect_with_tag(struct esp
*esp
,
1013 struct esp_lun_data
*lp
)
1015 struct esp_cmd_entry
*ent
;
1018 if (!lp
->num_tagged
) {
1019 printk(KERN_ERR PFX
"esp%d: Reconnect w/num_tagged==0\n",
1020 esp
->host
->unique_id
);
1024 esp_log_reconnect("ESP: reconnect tag, ");
1026 for (i
= 0; i
< ESP_QUICKIRQ_LIMIT
; i
++) {
1027 if (esp
->ops
->irq_pending(esp
))
1030 if (i
== ESP_QUICKIRQ_LIMIT
) {
1031 printk(KERN_ERR PFX
"esp%d: Reconnect IRQ1 timeout\n",
1032 esp
->host
->unique_id
);
1036 esp
->sreg
= esp_read8(ESP_STATUS
);
1037 esp
->ireg
= esp_read8(ESP_INTRPT
);
1039 esp_log_reconnect("IRQ(%d:%x:%x), ",
1040 i
, esp
->ireg
, esp
->sreg
);
1042 if (esp
->ireg
& ESP_INTR_DC
) {
1043 printk(KERN_ERR PFX
"esp%d: Reconnect, got disconnect.\n",
1044 esp
->host
->unique_id
);
1048 if ((esp
->sreg
& ESP_STAT_PMASK
) != ESP_MIP
) {
1049 printk(KERN_ERR PFX
"esp%d: Reconnect, not MIP sreg[%02x].\n",
1050 esp
->host
->unique_id
, esp
->sreg
);
1054 /* DMA in the tag bytes... */
1055 esp
->command_block
[0] = 0xff;
1056 esp
->command_block
[1] = 0xff;
1057 esp
->ops
->send_dma_cmd(esp
, esp
->command_block_dma
,
1058 2, 2, 1, ESP_CMD_DMA
| ESP_CMD_TI
);
1060 /* ACK the msssage. */
1061 scsi_esp_cmd(esp
, ESP_CMD_MOK
);
1063 for (i
= 0; i
< ESP_RESELECT_TAG_LIMIT
; i
++) {
1064 if (esp
->ops
->irq_pending(esp
)) {
1065 esp
->sreg
= esp_read8(ESP_STATUS
);
1066 esp
->ireg
= esp_read8(ESP_INTRPT
);
1067 if (esp
->ireg
& ESP_INTR_FDONE
)
1072 if (i
== ESP_RESELECT_TAG_LIMIT
) {
1073 printk(KERN_ERR PFX
"esp%d: Reconnect IRQ2 timeout\n",
1074 esp
->host
->unique_id
);
1077 esp
->ops
->dma_drain(esp
);
1078 esp
->ops
->dma_invalidate(esp
);
1080 esp_log_reconnect("IRQ2(%d:%x:%x) tag[%x:%x]\n",
1081 i
, esp
->ireg
, esp
->sreg
,
1082 esp
->command_block
[0],
1083 esp
->command_block
[1]);
1085 if (esp
->command_block
[0] < SIMPLE_QUEUE_TAG
||
1086 esp
->command_block
[0] > ORDERED_QUEUE_TAG
) {
1087 printk(KERN_ERR PFX
"esp%d: Reconnect, bad tag "
1089 esp
->host
->unique_id
, esp
->command_block
[0]);
1093 ent
= lp
->tagged_cmds
[esp
->command_block
[1]];
1095 printk(KERN_ERR PFX
"esp%d: Reconnect, no entry for "
1097 esp
->host
->unique_id
, esp
->command_block
[1]);
1104 static int esp_reconnect(struct esp
*esp
)
1106 struct esp_cmd_entry
*ent
;
1107 struct esp_target_data
*tp
;
1108 struct esp_lun_data
*lp
;
1109 struct scsi_device
*dev
;
1112 BUG_ON(esp
->active_cmd
);
1113 if (esp
->rev
== FASHME
) {
1114 /* FASHME puts the target and lun numbers directly
1117 target
= esp
->fifo
[0];
1118 lun
= esp
->fifo
[1] & 0x7;
1120 u8 bits
= esp_read8(ESP_FDATA
);
1122 /* Older chips put the lun directly into the fifo, but
1123 * the target is given as a sample of the arbitration
1124 * lines on the bus at reselection time. So we should
1125 * see the ID of the ESP and the one reconnecting target
1126 * set in the bitmap.
1128 if (!(bits
& esp
->scsi_id_mask
))
1130 bits
&= ~esp
->scsi_id_mask
;
1131 if (!bits
|| (bits
& (bits
- 1)))
1134 target
= ffs(bits
) - 1;
1135 lun
= (esp_read8(ESP_FDATA
) & 0x7);
1137 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1138 if (esp
->rev
== ESP100
) {
1139 u8 ireg
= esp_read8(ESP_INTRPT
);
1140 /* This chip has a bug during reselection that can
1141 * cause a spurious illegal-command interrupt, which
1142 * we simply ACK here. Another possibility is a bus
1143 * reset so we must check for that.
1145 if (ireg
& ESP_INTR_SR
)
1148 scsi_esp_cmd(esp
, ESP_CMD_NULL
);
1151 esp_write_tgt_sync(esp
, target
);
1152 esp_write_tgt_config3(esp
, target
);
1154 scsi_esp_cmd(esp
, ESP_CMD_MOK
);
1156 if (esp
->rev
== FASHME
)
1157 esp_write8(target
| ESP_BUSID_RESELID
| ESP_BUSID_CTR32BIT
,
1160 tp
= &esp
->target
[target
];
1161 dev
= __scsi_device_lookup_by_target(tp
->starget
, lun
);
1163 printk(KERN_ERR PFX
"esp%d: Reconnect, no lp "
1164 "tgt[%u] lun[%u]\n",
1165 esp
->host
->unique_id
, target
, lun
);
1170 ent
= lp
->non_tagged_cmd
;
1172 ent
= esp_reconnect_with_tag(esp
, lp
);
1177 esp
->active_cmd
= ent
;
1179 if (ent
->flags
& ESP_CMD_FLAG_ABORT
) {
1180 esp
->msg_out
[0] = ABORT_TASK_SET
;
1181 esp
->msg_out_len
= 1;
1182 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1185 esp_event(esp
, ESP_EVENT_CHECK_PHASE
);
1186 esp_restore_pointers(esp
, ent
);
1187 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1191 esp_schedule_reset(esp
);
1195 static int esp_finish_select(struct esp
*esp
)
1197 struct esp_cmd_entry
*ent
;
1198 struct scsi_cmnd
*cmd
;
1199 u8 orig_select_state
;
1201 orig_select_state
= esp
->select_state
;
1203 /* No longer selecting. */
1204 esp
->select_state
= ESP_SELECT_NONE
;
1206 esp
->seqreg
= esp_read8(ESP_SSTEP
) & ESP_STEP_VBITS
;
1207 ent
= esp
->active_cmd
;
1210 if (esp
->ops
->dma_error(esp
)) {
1211 /* If we see a DMA error during or as a result of selection,
1214 esp_schedule_reset(esp
);
1215 esp_cmd_is_done(esp
, ent
, cmd
, (DID_ERROR
<< 16));
1219 esp
->ops
->dma_invalidate(esp
);
1221 if (esp
->ireg
== (ESP_INTR_RSEL
| ESP_INTR_FDONE
)) {
1222 struct esp_target_data
*tp
= &esp
->target
[cmd
->device
->id
];
1224 /* Carefully back out of the selection attempt. Release
1225 * resources (such as DMA mapping & TAG) and reset state (such
1226 * as message out and command delivery variables).
1228 if (!(ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
)) {
1229 esp_unmap_dma(esp
, cmd
);
1230 esp_free_lun_tag(ent
, cmd
->device
->hostdata
);
1231 tp
->flags
&= ~(ESP_TGT_NEGO_SYNC
| ESP_TGT_NEGO_WIDE
);
1232 esp
->flags
&= ~ESP_FLAG_DOING_SLOWCMD
;
1233 esp
->cmd_bytes_ptr
= NULL
;
1234 esp
->cmd_bytes_left
= 0;
1236 esp
->ops
->unmap_single(esp
, ent
->sense_dma
,
1237 SCSI_SENSE_BUFFERSIZE
,
1239 ent
->sense_ptr
= NULL
;
1242 /* Now that the state is unwound properly, put back onto
1243 * the issue queue. This command is no longer active.
1245 list_del(&ent
->list
);
1246 list_add(&ent
->list
, &esp
->queued_cmds
);
1247 esp
->active_cmd
= NULL
;
1249 /* Return value ignored by caller, it directly invokes
1255 if (esp
->ireg
== ESP_INTR_DC
) {
1256 struct scsi_device
*dev
= cmd
->device
;
1258 /* Disconnect. Make sure we re-negotiate sync and
1259 * wide parameters if this target starts responding
1260 * again in the future.
1262 esp
->target
[dev
->id
].flags
|= ESP_TGT_CHECK_NEGO
;
1264 scsi_esp_cmd(esp
, ESP_CMD_ESEL
);
1265 esp_cmd_is_done(esp
, ent
, cmd
, (DID_BAD_TARGET
<< 16));
1269 if (esp
->ireg
== (ESP_INTR_FDONE
| ESP_INTR_BSERV
)) {
1270 /* Selection successful. On pre-FAST chips we have
1271 * to do a NOP and possibly clean out the FIFO.
1273 if (esp
->rev
<= ESP236
) {
1274 int fcnt
= esp_read8(ESP_FFLAGS
) & ESP_FF_FBYTES
;
1276 scsi_esp_cmd(esp
, ESP_CMD_NULL
);
1280 ((esp
->sreg
& ESP_STAT_PMASK
) != ESP_DIP
)))
1281 esp_flush_fifo(esp
);
1284 /* If we are doing a slow command, negotiation, etc.
1285 * we'll do the right thing as we transition to the
1288 esp_event(esp
, ESP_EVENT_CHECK_PHASE
);
1292 printk("ESP: Unexpected selection completion ireg[%x].\n",
1294 esp_schedule_reset(esp
);
1298 static int esp_data_bytes_sent(struct esp
*esp
, struct esp_cmd_entry
*ent
,
1299 struct scsi_cmnd
*cmd
)
1301 int fifo_cnt
, ecount
, bytes_sent
, flush_fifo
;
1303 fifo_cnt
= esp_read8(ESP_FFLAGS
) & ESP_FF_FBYTES
;
1304 if (esp
->prev_cfg3
& ESP_CONFIG3_EWIDE
)
1308 if (!(esp
->sreg
& ESP_STAT_TCNT
)) {
1309 ecount
= ((unsigned int)esp_read8(ESP_TCLOW
) |
1310 (((unsigned int)esp_read8(ESP_TCMED
)) << 8));
1311 if (esp
->rev
== FASHME
)
1312 ecount
|= ((unsigned int)esp_read8(FAS_RLO
)) << 16;
1315 bytes_sent
= esp
->data_dma_len
;
1316 bytes_sent
-= ecount
;
1318 if (!(ent
->flags
& ESP_CMD_FLAG_WRITE
))
1319 bytes_sent
-= fifo_cnt
;
1322 if (!esp
->prev_soff
) {
1323 /* Synchronous data transfer, always flush fifo. */
1326 if (esp
->rev
== ESP100
) {
1329 /* ESP100 has a chip bug where in the synchronous data
1330 * phase it can mistake a final long REQ pulse from the
1331 * target as an extra data byte. Fun.
1333 * To detect this case we resample the status register
1334 * and fifo flags. If we're still in a data phase and
1335 * we see spurious chunks in the fifo, we return error
1336 * to the caller which should reset and set things up
1337 * such that we only try future transfers to this
1338 * target in synchronous mode.
1340 esp
->sreg
= esp_read8(ESP_STATUS
);
1341 phase
= esp
->sreg
& ESP_STAT_PMASK
;
1342 fflags
= esp_read8(ESP_FFLAGS
);
1344 if ((phase
== ESP_DOP
&&
1345 (fflags
& ESP_FF_ONOTZERO
)) ||
1346 (phase
== ESP_DIP
&&
1347 (fflags
& ESP_FF_FBYTES
)))
1350 if (!(ent
->flags
& ESP_CMD_FLAG_WRITE
))
1355 esp_flush_fifo(esp
);
1360 static void esp_setsync(struct esp
*esp
, struct esp_target_data
*tp
,
1361 u8 scsi_period
, u8 scsi_offset
,
1362 u8 esp_stp
, u8 esp_soff
)
1364 spi_period(tp
->starget
) = scsi_period
;
1365 spi_offset(tp
->starget
) = scsi_offset
;
1366 spi_width(tp
->starget
) = (tp
->flags
& ESP_TGT_WIDE
) ? 1 : 0;
1370 esp_soff
|= esp
->radelay
;
1371 if (esp
->rev
>= FAS236
) {
1372 u8 bit
= ESP_CONFIG3_FSCSI
;
1373 if (esp
->rev
>= FAS100A
)
1374 bit
= ESP_CONFIG3_FAST
;
1376 if (scsi_period
< 50) {
1377 if (esp
->rev
== FASHME
)
1378 esp_soff
&= ~esp
->radelay
;
1379 tp
->esp_config3
|= bit
;
1381 tp
->esp_config3
&= ~bit
;
1383 esp
->prev_cfg3
= tp
->esp_config3
;
1384 esp_write8(esp
->prev_cfg3
, ESP_CFG3
);
1388 tp
->esp_period
= esp
->prev_stp
= esp_stp
;
1389 tp
->esp_offset
= esp
->prev_soff
= esp_soff
;
1391 esp_write8(esp_soff
, ESP_SOFF
);
1392 esp_write8(esp_stp
, ESP_STP
);
1394 tp
->flags
&= ~(ESP_TGT_NEGO_SYNC
| ESP_TGT_CHECK_NEGO
);
1396 spi_display_xfer_agreement(tp
->starget
);
1399 static void esp_msgin_reject(struct esp
*esp
)
1401 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1402 struct scsi_cmnd
*cmd
= ent
->cmd
;
1403 struct esp_target_data
*tp
;
1406 tgt
= cmd
->device
->id
;
1407 tp
= &esp
->target
[tgt
];
1409 if (tp
->flags
& ESP_TGT_NEGO_WIDE
) {
1410 tp
->flags
&= ~(ESP_TGT_NEGO_WIDE
| ESP_TGT_WIDE
);
1412 if (!esp_need_to_nego_sync(tp
)) {
1413 tp
->flags
&= ~ESP_TGT_CHECK_NEGO
;
1414 scsi_esp_cmd(esp
, ESP_CMD_RATN
);
1417 spi_populate_sync_msg(&esp
->msg_out
[0],
1418 tp
->nego_goal_period
,
1419 tp
->nego_goal_offset
);
1420 tp
->flags
|= ESP_TGT_NEGO_SYNC
;
1421 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1426 if (tp
->flags
& ESP_TGT_NEGO_SYNC
) {
1427 tp
->flags
&= ~(ESP_TGT_NEGO_SYNC
| ESP_TGT_CHECK_NEGO
);
1430 esp_setsync(esp
, tp
, 0, 0, 0, 0);
1431 scsi_esp_cmd(esp
, ESP_CMD_RATN
);
1435 esp
->msg_out
[0] = ABORT_TASK_SET
;
1436 esp
->msg_out_len
= 1;
1437 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1440 static void esp_msgin_sdtr(struct esp
*esp
, struct esp_target_data
*tp
)
1442 u8 period
= esp
->msg_in
[3];
1443 u8 offset
= esp
->msg_in
[4];
1446 if (!(tp
->flags
& ESP_TGT_NEGO_SYNC
))
1452 if (esp
->flags
& ESP_FLAG_DISABLE_SYNC
)
1456 int rounded_up
, one_clock
;
1458 if (period
> esp
->max_period
) {
1459 period
= offset
= 0;
1462 if (period
< esp
->min_period
)
1465 one_clock
= esp
->ccycle
/ 1000;
1466 rounded_up
= (period
<< 2);
1467 rounded_up
= (rounded_up
+ one_clock
- 1) / one_clock
;
1469 if (stp
&& esp
->rev
>= FAS236
) {
1477 esp_setsync(esp
, tp
, period
, offset
, stp
, offset
);
1481 esp
->msg_out
[0] = MESSAGE_REJECT
;
1482 esp
->msg_out_len
= 1;
1483 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1487 tp
->nego_goal_period
= period
;
1488 tp
->nego_goal_offset
= offset
;
1490 spi_populate_sync_msg(&esp
->msg_out
[0],
1491 tp
->nego_goal_period
,
1492 tp
->nego_goal_offset
);
1493 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1496 static void esp_msgin_wdtr(struct esp
*esp
, struct esp_target_data
*tp
)
1498 int size
= 8 << esp
->msg_in
[3];
1501 if (esp
->rev
!= FASHME
)
1504 if (size
!= 8 && size
!= 16)
1507 if (!(tp
->flags
& ESP_TGT_NEGO_WIDE
))
1510 cfg3
= tp
->esp_config3
;
1512 tp
->flags
|= ESP_TGT_WIDE
;
1513 cfg3
|= ESP_CONFIG3_EWIDE
;
1515 tp
->flags
&= ~ESP_TGT_WIDE
;
1516 cfg3
&= ~ESP_CONFIG3_EWIDE
;
1518 tp
->esp_config3
= cfg3
;
1519 esp
->prev_cfg3
= cfg3
;
1520 esp_write8(cfg3
, ESP_CFG3
);
1522 tp
->flags
&= ~ESP_TGT_NEGO_WIDE
;
1524 spi_period(tp
->starget
) = 0;
1525 spi_offset(tp
->starget
) = 0;
1526 if (!esp_need_to_nego_sync(tp
)) {
1527 tp
->flags
&= ~ESP_TGT_CHECK_NEGO
;
1528 scsi_esp_cmd(esp
, ESP_CMD_RATN
);
1531 spi_populate_sync_msg(&esp
->msg_out
[0],
1532 tp
->nego_goal_period
,
1533 tp
->nego_goal_offset
);
1534 tp
->flags
|= ESP_TGT_NEGO_SYNC
;
1535 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1540 esp
->msg_out
[0] = MESSAGE_REJECT
;
1541 esp
->msg_out_len
= 1;
1542 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1545 static void esp_msgin_extended(struct esp
*esp
)
1547 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1548 struct scsi_cmnd
*cmd
= ent
->cmd
;
1549 struct esp_target_data
*tp
;
1550 int tgt
= cmd
->device
->id
;
1552 tp
= &esp
->target
[tgt
];
1553 if (esp
->msg_in
[2] == EXTENDED_SDTR
) {
1554 esp_msgin_sdtr(esp
, tp
);
1557 if (esp
->msg_in
[2] == EXTENDED_WDTR
) {
1558 esp_msgin_wdtr(esp
, tp
);
1562 printk("ESP: Unexpected extended msg type %x\n",
1565 esp
->msg_out
[0] = ABORT_TASK_SET
;
1566 esp
->msg_out_len
= 1;
1567 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1570 /* Analyze msgin bytes received from target so far. Return non-zero
1571 * if there are more bytes needed to complete the message.
1573 static int esp_msgin_process(struct esp
*esp
)
1575 u8 msg0
= esp
->msg_in
[0];
1576 int len
= esp
->msg_in_len
;
1580 printk("ESP: Unexpected msgin identify\n");
1585 case EXTENDED_MESSAGE
:
1588 if (len
< esp
->msg_in
[1] + 2)
1590 esp_msgin_extended(esp
);
1593 case IGNORE_WIDE_RESIDUE
: {
1594 struct esp_cmd_entry
*ent
;
1595 struct esp_cmd_priv
*spriv
;
1599 if (esp
->msg_in
[1] != 1)
1602 ent
= esp
->active_cmd
;
1603 spriv
= ESP_CMD_PRIV(ent
->cmd
);
1605 if (spriv
->cur_residue
== sg_dma_len(spriv
->cur_sg
)) {
1607 spriv
->cur_residue
= 1;
1609 spriv
->cur_residue
++;
1610 spriv
->tot_residue
++;
1615 case RESTORE_POINTERS
:
1616 esp_restore_pointers(esp
, esp
->active_cmd
);
1619 esp_save_pointers(esp
, esp
->active_cmd
);
1622 case COMMAND_COMPLETE
:
1624 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1626 ent
->message
= msg0
;
1627 esp_event(esp
, ESP_EVENT_FREE_BUS
);
1628 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1631 case MESSAGE_REJECT
:
1632 esp_msgin_reject(esp
);
1637 esp
->msg_out
[0] = MESSAGE_REJECT
;
1638 esp
->msg_out_len
= 1;
1639 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
1644 static int esp_process_event(struct esp
*esp
)
1650 switch (esp
->event
) {
1651 case ESP_EVENT_CHECK_PHASE
:
1652 switch (esp
->sreg
& ESP_STAT_PMASK
) {
1654 esp_event(esp
, ESP_EVENT_DATA_OUT
);
1657 esp_event(esp
, ESP_EVENT_DATA_IN
);
1660 esp_flush_fifo(esp
);
1661 scsi_esp_cmd(esp
, ESP_CMD_ICCSEQ
);
1662 esp_event(esp
, ESP_EVENT_STATUS
);
1663 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1667 esp_event(esp
, ESP_EVENT_MSGOUT
);
1671 esp_event(esp
, ESP_EVENT_MSGIN
);
1675 esp_event(esp
, ESP_EVENT_CMD_START
);
1679 printk("ESP: Unexpected phase, sreg=%02x\n",
1681 esp_schedule_reset(esp
);
1687 case ESP_EVENT_DATA_IN
:
1691 case ESP_EVENT_DATA_OUT
: {
1692 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1693 struct scsi_cmnd
*cmd
= ent
->cmd
;
1694 dma_addr_t dma_addr
= esp_cur_dma_addr(ent
, cmd
);
1695 unsigned int dma_len
= esp_cur_dma_len(ent
, cmd
);
1697 if (esp
->rev
== ESP100
)
1698 scsi_esp_cmd(esp
, ESP_CMD_NULL
);
1701 ent
->flags
|= ESP_CMD_FLAG_WRITE
;
1703 ent
->flags
&= ~ESP_CMD_FLAG_WRITE
;
1705 if (esp
->ops
->dma_length_limit
)
1706 dma_len
= esp
->ops
->dma_length_limit(esp
, dma_addr
,
1709 dma_len
= esp_dma_length_limit(esp
, dma_addr
, dma_len
);
1711 esp
->data_dma_len
= dma_len
;
1714 printk(KERN_ERR PFX
"esp%d: DMA length is zero!\n",
1715 esp
->host
->unique_id
);
1716 printk(KERN_ERR PFX
"esp%d: cur adr[%08llx] len[%08x]\n",
1717 esp
->host
->unique_id
,
1718 (unsigned long long)esp_cur_dma_addr(ent
, cmd
),
1719 esp_cur_dma_len(ent
, cmd
));
1720 esp_schedule_reset(esp
);
1724 esp_log_datastart("ESP: start data addr[%08llx] len[%u] "
1726 (unsigned long long)dma_addr
, dma_len
, write
);
1728 esp
->ops
->send_dma_cmd(esp
, dma_addr
, dma_len
, dma_len
,
1729 write
, ESP_CMD_DMA
| ESP_CMD_TI
);
1730 esp_event(esp
, ESP_EVENT_DATA_DONE
);
1733 case ESP_EVENT_DATA_DONE
: {
1734 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1735 struct scsi_cmnd
*cmd
= ent
->cmd
;
1738 if (esp
->ops
->dma_error(esp
)) {
1739 printk("ESP: data done, DMA error, resetting\n");
1740 esp_schedule_reset(esp
);
1744 if (ent
->flags
& ESP_CMD_FLAG_WRITE
) {
1745 /* XXX parity errors, etc. XXX */
1747 esp
->ops
->dma_drain(esp
);
1749 esp
->ops
->dma_invalidate(esp
);
1751 if (esp
->ireg
!= ESP_INTR_BSERV
) {
1752 /* We should always see exactly a bus-service
1753 * interrupt at the end of a successful transfer.
1755 printk("ESP: data done, not BSERV, resetting\n");
1756 esp_schedule_reset(esp
);
1760 bytes_sent
= esp_data_bytes_sent(esp
, ent
, cmd
);
1762 esp_log_datadone("ESP: data done flgs[%x] sent[%d]\n",
1763 ent
->flags
, bytes_sent
);
1765 if (bytes_sent
< 0) {
1766 /* XXX force sync mode for this target XXX */
1767 esp_schedule_reset(esp
);
1771 esp_advance_dma(esp
, ent
, cmd
, bytes_sent
);
1772 esp_event(esp
, ESP_EVENT_CHECK_PHASE
);
1776 case ESP_EVENT_STATUS
: {
1777 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1779 if (esp
->ireg
& ESP_INTR_FDONE
) {
1780 ent
->status
= esp_read8(ESP_FDATA
);
1781 ent
->message
= esp_read8(ESP_FDATA
);
1782 scsi_esp_cmd(esp
, ESP_CMD_MOK
);
1783 } else if (esp
->ireg
== ESP_INTR_BSERV
) {
1784 ent
->status
= esp_read8(ESP_FDATA
);
1785 ent
->message
= 0xff;
1786 esp_event(esp
, ESP_EVENT_MSGIN
);
1790 if (ent
->message
!= COMMAND_COMPLETE
) {
1791 printk("ESP: Unexpected message %x in status\n",
1793 esp_schedule_reset(esp
);
1797 esp_event(esp
, ESP_EVENT_FREE_BUS
);
1798 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1801 case ESP_EVENT_FREE_BUS
: {
1802 struct esp_cmd_entry
*ent
= esp
->active_cmd
;
1803 struct scsi_cmnd
*cmd
= ent
->cmd
;
1805 if (ent
->message
== COMMAND_COMPLETE
||
1806 ent
->message
== DISCONNECT
)
1807 scsi_esp_cmd(esp
, ESP_CMD_ESEL
);
1809 if (ent
->message
== COMMAND_COMPLETE
) {
1810 esp_log_cmddone("ESP: Command done status[%x] "
1812 ent
->status
, ent
->message
);
1813 if (ent
->status
== SAM_STAT_TASK_SET_FULL
)
1814 esp_event_queue_full(esp
, ent
);
1816 if (ent
->status
== SAM_STAT_CHECK_CONDITION
&&
1817 !(ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
)) {
1818 ent
->flags
|= ESP_CMD_FLAG_AUTOSENSE
;
1819 esp_autosense(esp
, ent
);
1821 esp_cmd_is_done(esp
, ent
, cmd
,
1822 compose_result(ent
->status
,
1826 } else if (ent
->message
== DISCONNECT
) {
1827 esp_log_disconnect("ESP: Disconnecting tgt[%d] "
1830 ent
->tag
[0], ent
->tag
[1]);
1832 esp
->active_cmd
= NULL
;
1833 esp_maybe_execute_command(esp
);
1835 printk("ESP: Unexpected message %x in freebus\n",
1837 esp_schedule_reset(esp
);
1840 if (esp
->active_cmd
)
1841 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1844 case ESP_EVENT_MSGOUT
: {
1845 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1847 if (esp_debug
& ESP_DEBUG_MSGOUT
) {
1849 printk("ESP: Sending message [ ");
1850 for (i
= 0; i
< esp
->msg_out_len
; i
++)
1851 printk("%02x ", esp
->msg_out
[i
]);
1855 if (esp
->rev
== FASHME
) {
1858 /* Always use the fifo. */
1859 for (i
= 0; i
< esp
->msg_out_len
; i
++) {
1860 esp_write8(esp
->msg_out
[i
], ESP_FDATA
);
1861 esp_write8(0, ESP_FDATA
);
1863 scsi_esp_cmd(esp
, ESP_CMD_TI
);
1865 if (esp
->msg_out_len
== 1) {
1866 esp_write8(esp
->msg_out
[0], ESP_FDATA
);
1867 scsi_esp_cmd(esp
, ESP_CMD_TI
);
1870 memcpy(esp
->command_block
,
1874 esp
->ops
->send_dma_cmd(esp
,
1875 esp
->command_block_dma
,
1879 ESP_CMD_DMA
|ESP_CMD_TI
);
1882 esp_event(esp
, ESP_EVENT_MSGOUT_DONE
);
1885 case ESP_EVENT_MSGOUT_DONE
:
1886 if (esp
->rev
== FASHME
) {
1887 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1889 if (esp
->msg_out_len
> 1)
1890 esp
->ops
->dma_invalidate(esp
);
1893 if (!(esp
->ireg
& ESP_INTR_DC
)) {
1894 if (esp
->rev
!= FASHME
)
1895 scsi_esp_cmd(esp
, ESP_CMD_NULL
);
1897 esp_event(esp
, ESP_EVENT_CHECK_PHASE
);
1899 case ESP_EVENT_MSGIN
:
1900 if (esp
->ireg
& ESP_INTR_BSERV
) {
1901 if (esp
->rev
== FASHME
) {
1902 if (!(esp_read8(ESP_STATUS2
) &
1904 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1906 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1907 if (esp
->rev
== ESP100
)
1908 scsi_esp_cmd(esp
, ESP_CMD_NULL
);
1910 scsi_esp_cmd(esp
, ESP_CMD_TI
);
1911 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1914 if (esp
->ireg
& ESP_INTR_FDONE
) {
1917 if (esp
->rev
== FASHME
)
1920 val
= esp_read8(ESP_FDATA
);
1921 esp
->msg_in
[esp
->msg_in_len
++] = val
;
1923 esp_log_msgin("ESP: Got msgin byte %x\n", val
);
1925 if (!esp_msgin_process(esp
))
1926 esp
->msg_in_len
= 0;
1928 if (esp
->rev
== FASHME
)
1929 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1931 scsi_esp_cmd(esp
, ESP_CMD_MOK
);
1933 if (esp
->event
!= ESP_EVENT_FREE_BUS
)
1934 esp_event(esp
, ESP_EVENT_CHECK_PHASE
);
1936 printk("ESP: MSGIN neither BSERV not FDON, resetting");
1937 esp_schedule_reset(esp
);
1941 case ESP_EVENT_CMD_START
:
1942 memcpy(esp
->command_block
, esp
->cmd_bytes_ptr
,
1943 esp
->cmd_bytes_left
);
1944 if (esp
->rev
== FASHME
)
1945 scsi_esp_cmd(esp
, ESP_CMD_FLUSH
);
1946 esp
->ops
->send_dma_cmd(esp
, esp
->command_block_dma
,
1947 esp
->cmd_bytes_left
, 16, 0,
1948 ESP_CMD_DMA
| ESP_CMD_TI
);
1949 esp_event(esp
, ESP_EVENT_CMD_DONE
);
1950 esp
->flags
|= ESP_FLAG_QUICKIRQ_CHECK
;
1952 case ESP_EVENT_CMD_DONE
:
1953 esp
->ops
->dma_invalidate(esp
);
1954 if (esp
->ireg
& ESP_INTR_BSERV
) {
1955 esp_event(esp
, ESP_EVENT_CHECK_PHASE
);
1958 esp_schedule_reset(esp
);
1962 case ESP_EVENT_RESET
:
1963 scsi_esp_cmd(esp
, ESP_CMD_RS
);
1967 printk("ESP: Unexpected event %x, resetting\n",
1969 esp_schedule_reset(esp
);
1976 static void esp_reset_cleanup_one(struct esp
*esp
, struct esp_cmd_entry
*ent
)
1978 struct scsi_cmnd
*cmd
= ent
->cmd
;
1980 esp_unmap_dma(esp
, cmd
);
1981 esp_free_lun_tag(ent
, cmd
->device
->hostdata
);
1982 cmd
->result
= DID_RESET
<< 16;
1984 if (ent
->flags
& ESP_CMD_FLAG_AUTOSENSE
) {
1985 esp
->ops
->unmap_single(esp
, ent
->sense_dma
,
1986 SCSI_SENSE_BUFFERSIZE
, DMA_FROM_DEVICE
);
1987 ent
->sense_ptr
= NULL
;
1990 cmd
->scsi_done(cmd
);
1991 list_del(&ent
->list
);
1992 esp_put_ent(esp
, ent
);
1995 static void esp_clear_hold(struct scsi_device
*dev
, void *data
)
1997 struct esp_lun_data
*lp
= dev
->hostdata
;
1999 BUG_ON(lp
->num_tagged
);
2003 static void esp_reset_cleanup(struct esp
*esp
)
2005 struct esp_cmd_entry
*ent
, *tmp
;
2008 list_for_each_entry_safe(ent
, tmp
, &esp
->queued_cmds
, list
) {
2009 struct scsi_cmnd
*cmd
= ent
->cmd
;
2011 list_del(&ent
->list
);
2012 cmd
->result
= DID_RESET
<< 16;
2013 cmd
->scsi_done(cmd
);
2014 esp_put_ent(esp
, ent
);
2017 list_for_each_entry_safe(ent
, tmp
, &esp
->active_cmds
, list
) {
2018 if (ent
== esp
->active_cmd
)
2019 esp
->active_cmd
= NULL
;
2020 esp_reset_cleanup_one(esp
, ent
);
2023 BUG_ON(esp
->active_cmd
!= NULL
);
2025 /* Force renegotiation of sync/wide transfers. */
2026 for (i
= 0; i
< ESP_MAX_TARGET
; i
++) {
2027 struct esp_target_data
*tp
= &esp
->target
[i
];
2031 tp
->esp_config3
&= ~(ESP_CONFIG3_EWIDE
|
2034 tp
->flags
&= ~ESP_TGT_WIDE
;
2035 tp
->flags
|= ESP_TGT_CHECK_NEGO
;
2038 __starget_for_each_device(tp
->starget
, NULL
,
2041 esp
->flags
&= ~ESP_FLAG_RESETTING
;
2044 /* Runs under host->lock */
2045 static void __esp_interrupt(struct esp
*esp
)
2047 int finish_reset
, intr_done
;
2050 esp
->sreg
= esp_read8(ESP_STATUS
);
2052 if (esp
->flags
& ESP_FLAG_RESETTING
) {
2055 if (esp_check_gross_error(esp
))
2058 finish_reset
= esp_check_spur_intr(esp
);
2059 if (finish_reset
< 0)
2063 esp
->ireg
= esp_read8(ESP_INTRPT
);
2065 if (esp
->ireg
& ESP_INTR_SR
)
2069 esp_reset_cleanup(esp
);
2070 if (esp
->eh_reset
) {
2071 complete(esp
->eh_reset
);
2072 esp
->eh_reset
= NULL
;
2077 phase
= (esp
->sreg
& ESP_STAT_PMASK
);
2078 if (esp
->rev
== FASHME
) {
2079 if (((phase
!= ESP_DIP
&& phase
!= ESP_DOP
) &&
2080 esp
->select_state
== ESP_SELECT_NONE
&&
2081 esp
->event
!= ESP_EVENT_STATUS
&&
2082 esp
->event
!= ESP_EVENT_DATA_DONE
) ||
2083 (esp
->ireg
& ESP_INTR_RSEL
)) {
2084 esp
->sreg2
= esp_read8(ESP_STATUS2
);
2085 if (!(esp
->sreg2
& ESP_STAT2_FEMPTY
) ||
2086 (esp
->sreg2
& ESP_STAT2_F1BYTE
))
2091 esp_log_intr("ESP: intr sreg[%02x] seqreg[%02x] "
2092 "sreg2[%02x] ireg[%02x]\n",
2093 esp
->sreg
, esp
->seqreg
, esp
->sreg2
, esp
->ireg
);
2097 if (esp
->ireg
& (ESP_INTR_S
| ESP_INTR_SATN
| ESP_INTR_IC
)) {
2098 printk("ESP: unexpected IREG %02x\n", esp
->ireg
);
2099 if (esp
->ireg
& ESP_INTR_IC
)
2100 esp_dump_cmd_log(esp
);
2102 esp_schedule_reset(esp
);
2104 if (!(esp
->ireg
& ESP_INTR_RSEL
)) {
2105 /* Some combination of FDONE, BSERV, DC. */
2106 if (esp
->select_state
!= ESP_SELECT_NONE
)
2107 intr_done
= esp_finish_select(esp
);
2108 } else if (esp
->ireg
& ESP_INTR_RSEL
) {
2109 if (esp
->active_cmd
)
2110 (void) esp_finish_select(esp
);
2111 intr_done
= esp_reconnect(esp
);
2115 intr_done
= esp_process_event(esp
);
2118 irqreturn_t
scsi_esp_intr(int irq
, void *dev_id
)
2120 struct esp
*esp
= dev_id
;
2121 unsigned long flags
;
2124 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2126 if (esp
->ops
->irq_pending(esp
)) {
2131 __esp_interrupt(esp
);
2132 if (!(esp
->flags
& ESP_FLAG_QUICKIRQ_CHECK
))
2134 esp
->flags
&= ~ESP_FLAG_QUICKIRQ_CHECK
;
2136 for (i
= 0; i
< ESP_QUICKIRQ_LIMIT
; i
++) {
2137 if (esp
->ops
->irq_pending(esp
))
2140 if (i
== ESP_QUICKIRQ_LIMIT
)
2144 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2148 EXPORT_SYMBOL(scsi_esp_intr
);
2150 static void esp_get_revision(struct esp
*esp
)
2154 esp
->config1
= (ESP_CONFIG1_PENABLE
| (esp
->scsi_id
& 7));
2155 esp
->config2
= (ESP_CONFIG2_SCSI2ENAB
| ESP_CONFIG2_REGPARITY
);
2156 esp_write8(esp
->config2
, ESP_CFG2
);
2158 val
= esp_read8(ESP_CFG2
);
2159 val
&= ~ESP_CONFIG2_MAGIC
;
2160 if (val
!= (ESP_CONFIG2_SCSI2ENAB
| ESP_CONFIG2_REGPARITY
)) {
2161 /* If what we write to cfg2 does not come back, cfg2 is not
2162 * implemented, therefore this must be a plain esp100.
2167 esp_set_all_config3(esp
, 5);
2169 esp_write8(esp
->config2
, ESP_CFG2
);
2170 esp_write8(0, ESP_CFG3
);
2171 esp_write8(esp
->prev_cfg3
, ESP_CFG3
);
2173 val
= esp_read8(ESP_CFG3
);
2175 /* The cfg2 register is implemented, however
2176 * cfg3 is not, must be esp100a.
2180 esp_set_all_config3(esp
, 0);
2182 esp_write8(esp
->prev_cfg3
, ESP_CFG3
);
2184 /* All of cfg{1,2,3} implemented, must be one of
2185 * the fas variants, figure out which one.
2187 if (esp
->cfact
== 0 || esp
->cfact
> ESP_CCF_F5
) {
2189 esp
->sync_defp
= SYNC_DEFP_FAST
;
2194 esp_write8(esp
->config2
, ESP_CFG2
);
2199 static void esp_init_swstate(struct esp
*esp
)
2203 INIT_LIST_HEAD(&esp
->queued_cmds
);
2204 INIT_LIST_HEAD(&esp
->active_cmds
);
2205 INIT_LIST_HEAD(&esp
->esp_cmd_pool
);
2207 /* Start with a clear state, domain validation (via ->slave_configure,
2208 * spi_dv_device()) will attempt to enable SYNC, WIDE, and tagged
2211 for (i
= 0 ; i
< ESP_MAX_TARGET
; i
++) {
2212 esp
->target
[i
].flags
= 0;
2213 esp
->target
[i
].nego_goal_period
= 0;
2214 esp
->target
[i
].nego_goal_offset
= 0;
2215 esp
->target
[i
].nego_goal_width
= 0;
2216 esp
->target
[i
].nego_goal_tags
= 0;
2220 /* This places the ESP into a known state at boot time. */
2221 static void esp_bootup_reset(struct esp
*esp
)
2226 esp
->ops
->reset_dma(esp
);
2231 /* Reset the SCSI bus, but tell ESP not to generate an irq */
2232 val
= esp_read8(ESP_CFG1
);
2233 val
|= ESP_CONFIG1_SRRDISAB
;
2234 esp_write8(val
, ESP_CFG1
);
2236 scsi_esp_cmd(esp
, ESP_CMD_RS
);
2239 esp_write8(esp
->config1
, ESP_CFG1
);
2241 /* Eat any bitrot in the chip and we are done... */
2242 esp_read8(ESP_INTRPT
);
2245 static void esp_set_clock_params(struct esp
*esp
)
2250 /* This is getting messy but it has to be done correctly or else
2251 * you get weird behavior all over the place. We are trying to
2252 * basically figure out three pieces of information.
2254 * a) Clock Conversion Factor
2256 * This is a representation of the input crystal clock frequency
2257 * going into the ESP on this machine. Any operation whose timing
2258 * is longer than 400ns depends on this value being correct. For
2259 * example, you'll get blips for arbitration/selection during high
2260 * load or with multiple targets if this is not set correctly.
2262 * b) Selection Time-Out
2264 * The ESP isn't very bright and will arbitrate for the bus and try
2265 * to select a target forever if you let it. This value tells the
2266 * ESP when it has taken too long to negotiate and that it should
2267 * interrupt the CPU so we can see what happened. The value is
2268 * computed as follows (from NCR/Symbios chip docs).
2270 * (Time Out Period) * (Input Clock)
2271 * STO = ----------------------------------
2272 * (8192) * (Clock Conversion Factor)
2274 * We use a time out period of 250ms (ESP_BUS_TIMEOUT).
2276 * c) Imperical constants for synchronous offset and transfer period
2279 * This entails the smallest and largest sync period we could ever
2280 * handle on this ESP.
2284 ccf
= ((fhz
/ 1000000) + 4) / 5;
2288 /* If we can't find anything reasonable, just assume 20MHZ.
2289 * This is the clock frequency of the older sun4c's where I've
2290 * been unable to find the clock-frequency PROM property. All
2291 * other machines provide useful values it seems.
2293 if (fhz
<= 5000000 || ccf
< 1 || ccf
> 8) {
2298 esp
->cfact
= (ccf
== 8 ? 0 : ccf
);
2300 esp
->ccycle
= ESP_HZ_TO_CYCLE(fhz
);
2301 esp
->ctick
= ESP_TICK(ccf
, esp
->ccycle
);
2302 esp
->neg_defp
= ESP_NEG_DEFP(fhz
, ccf
);
2303 esp
->sync_defp
= SYNC_DEFP_SLOW
;
2306 static const char *esp_chip_names
[] = {
2316 static struct scsi_transport_template
*esp_transport_template
;
2318 int scsi_esp_register(struct esp
*esp
, struct device
*dev
)
2320 static int instance
;
2323 esp
->host
->transportt
= esp_transport_template
;
2324 esp
->host
->max_lun
= ESP_MAX_LUN
;
2325 esp
->host
->cmd_per_lun
= 2;
2326 esp
->host
->unique_id
= instance
;
2328 esp_set_clock_params(esp
);
2330 esp_get_revision(esp
);
2332 esp_init_swstate(esp
);
2334 esp_bootup_reset(esp
);
2336 printk(KERN_INFO PFX
"esp%u, regs[%1p:%1p] irq[%u]\n",
2337 esp
->host
->unique_id
, esp
->regs
, esp
->dma_regs
,
2339 printk(KERN_INFO PFX
"esp%u is a %s, %u MHz (ccf=%u), SCSI ID %u\n",
2340 esp
->host
->unique_id
, esp_chip_names
[esp
->rev
],
2341 esp
->cfreq
/ 1000000, esp
->cfact
, esp
->scsi_id
);
2343 /* Let the SCSI bus reset settle. */
2344 ssleep(esp_bus_reset_settle
);
2346 err
= scsi_add_host(esp
->host
, dev
);
2352 scsi_scan_host(esp
->host
);
2356 EXPORT_SYMBOL(scsi_esp_register
);
2358 void scsi_esp_unregister(struct esp
*esp
)
2360 scsi_remove_host(esp
->host
);
2362 EXPORT_SYMBOL(scsi_esp_unregister
);
2364 static int esp_target_alloc(struct scsi_target
*starget
)
2366 struct esp
*esp
= shost_priv(dev_to_shost(&starget
->dev
));
2367 struct esp_target_data
*tp
= &esp
->target
[starget
->id
];
2369 tp
->starget
= starget
;
2374 static void esp_target_destroy(struct scsi_target
*starget
)
2376 struct esp
*esp
= shost_priv(dev_to_shost(&starget
->dev
));
2377 struct esp_target_data
*tp
= &esp
->target
[starget
->id
];
2382 static int esp_slave_alloc(struct scsi_device
*dev
)
2384 struct esp
*esp
= shost_priv(dev
->host
);
2385 struct esp_target_data
*tp
= &esp
->target
[dev
->id
];
2386 struct esp_lun_data
*lp
;
2388 lp
= kzalloc(sizeof(*lp
), GFP_KERNEL
);
2393 spi_min_period(tp
->starget
) = esp
->min_period
;
2394 spi_max_offset(tp
->starget
) = 15;
2396 if (esp
->flags
& ESP_FLAG_WIDE_CAPABLE
)
2397 spi_max_width(tp
->starget
) = 1;
2399 spi_max_width(tp
->starget
) = 0;
2404 static int esp_slave_configure(struct scsi_device
*dev
)
2406 struct esp
*esp
= shost_priv(dev
->host
);
2407 struct esp_target_data
*tp
= &esp
->target
[dev
->id
];
2408 int goal_tags
, queue_depth
;
2410 if (esp
->flags
& ESP_FLAG_DISABLE_SYNC
) {
2411 /* Bypass async domain validation */
2418 if (dev
->tagged_supported
) {
2419 /* XXX make this configurable somehow XXX */
2420 goal_tags
= ESP_DEFAULT_TAGS
;
2422 if (goal_tags
> ESP_MAX_TAG
)
2423 goal_tags
= ESP_MAX_TAG
;
2426 queue_depth
= goal_tags
;
2427 if (queue_depth
< dev
->host
->cmd_per_lun
)
2428 queue_depth
= dev
->host
->cmd_per_lun
;
2431 scsi_set_tag_type(dev
, MSG_ORDERED_TAG
);
2432 scsi_activate_tcq(dev
, queue_depth
);
2434 scsi_deactivate_tcq(dev
, queue_depth
);
2436 tp
->flags
|= ESP_TGT_DISCONNECT
;
2438 if (!spi_initial_dv(dev
->sdev_target
))
2444 static void esp_slave_destroy(struct scsi_device
*dev
)
2446 struct esp_lun_data
*lp
= dev
->hostdata
;
2449 dev
->hostdata
= NULL
;
2452 static int esp_eh_abort_handler(struct scsi_cmnd
*cmd
)
2454 struct esp
*esp
= shost_priv(cmd
->device
->host
);
2455 struct esp_cmd_entry
*ent
, *tmp
;
2456 struct completion eh_done
;
2457 unsigned long flags
;
2459 /* XXX This helps a lot with debugging but might be a bit
2460 * XXX much for the final driver.
2462 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2463 printk(KERN_ERR PFX
"esp%d: Aborting command [%p:%02x]\n",
2464 esp
->host
->unique_id
, cmd
, cmd
->cmnd
[0]);
2465 ent
= esp
->active_cmd
;
2467 printk(KERN_ERR PFX
"esp%d: Current command [%p:%02x]\n",
2468 esp
->host
->unique_id
, ent
->cmd
, ent
->cmd
->cmnd
[0]);
2469 list_for_each_entry(ent
, &esp
->queued_cmds
, list
) {
2470 printk(KERN_ERR PFX
"esp%d: Queued command [%p:%02x]\n",
2471 esp
->host
->unique_id
, ent
->cmd
, ent
->cmd
->cmnd
[0]);
2473 list_for_each_entry(ent
, &esp
->active_cmds
, list
) {
2474 printk(KERN_ERR PFX
"esp%d: Active command [%p:%02x]\n",
2475 esp
->host
->unique_id
, ent
->cmd
, ent
->cmd
->cmnd
[0]);
2477 esp_dump_cmd_log(esp
);
2478 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2480 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2483 list_for_each_entry(tmp
, &esp
->queued_cmds
, list
) {
2484 if (tmp
->cmd
== cmd
) {
2491 /* Easiest case, we didn't even issue the command
2492 * yet so it is trivial to abort.
2494 list_del(&ent
->list
);
2496 cmd
->result
= DID_ABORT
<< 16;
2497 cmd
->scsi_done(cmd
);
2499 esp_put_ent(esp
, ent
);
2504 init_completion(&eh_done
);
2506 ent
= esp
->active_cmd
;
2507 if (ent
&& ent
->cmd
== cmd
) {
2508 /* Command is the currently active command on
2509 * the bus. If we already have an output message
2512 if (esp
->msg_out_len
)
2515 /* Send out an abort, encouraging the target to
2516 * go to MSGOUT phase by asserting ATN.
2518 esp
->msg_out
[0] = ABORT_TASK_SET
;
2519 esp
->msg_out_len
= 1;
2520 ent
->eh_done
= &eh_done
;
2522 scsi_esp_cmd(esp
, ESP_CMD_SATN
);
2524 /* The command is disconnected. This is not easy to
2525 * abort. For now we fail and let the scsi error
2526 * handling layer go try a scsi bus reset or host
2529 * What we could do is put together a scsi command
2530 * solely for the purpose of sending an abort message
2531 * to the target. Coming up with all the code to
2532 * cook up scsi commands, special case them everywhere,
2533 * etc. is for questionable gain and it would be better
2534 * if the generic scsi error handling layer could do at
2535 * least some of that for us.
2537 * Anyways this is an area for potential future improvement
2543 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2545 if (!wait_for_completion_timeout(&eh_done
, 5 * HZ
)) {
2546 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2547 ent
->eh_done
= NULL
;
2548 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2556 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2560 /* XXX This might be a good location to set ESP_TGT_BROKEN
2561 * XXX since we know which target/lun in particular is
2562 * XXX causing trouble.
2564 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2568 static int esp_eh_bus_reset_handler(struct scsi_cmnd
*cmd
)
2570 struct esp
*esp
= shost_priv(cmd
->device
->host
);
2571 struct completion eh_reset
;
2572 unsigned long flags
;
2574 init_completion(&eh_reset
);
2576 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2578 esp
->eh_reset
= &eh_reset
;
2580 /* XXX This is too simple... We should add lots of
2581 * XXX checks here so that if we find that the chip is
2582 * XXX very wedged we return failure immediately so
2583 * XXX that we can perform a full chip reset.
2585 esp
->flags
|= ESP_FLAG_RESETTING
;
2586 scsi_esp_cmd(esp
, ESP_CMD_RS
);
2588 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2590 ssleep(esp_bus_reset_settle
);
2592 if (!wait_for_completion_timeout(&eh_reset
, 5 * HZ
)) {
2593 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2594 esp
->eh_reset
= NULL
;
2595 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2603 /* All bets are off, reset the entire device. */
2604 static int esp_eh_host_reset_handler(struct scsi_cmnd
*cmd
)
2606 struct esp
*esp
= shost_priv(cmd
->device
->host
);
2607 unsigned long flags
;
2609 spin_lock_irqsave(esp
->host
->host_lock
, flags
);
2610 esp_bootup_reset(esp
);
2611 esp_reset_cleanup(esp
);
2612 spin_unlock_irqrestore(esp
->host
->host_lock
, flags
);
2614 ssleep(esp_bus_reset_settle
);
2619 static const char *esp_info(struct Scsi_Host
*host
)
2624 struct scsi_host_template scsi_esp_template
= {
2625 .module
= THIS_MODULE
,
2628 .queuecommand
= esp_queuecommand
,
2629 .target_alloc
= esp_target_alloc
,
2630 .target_destroy
= esp_target_destroy
,
2631 .slave_alloc
= esp_slave_alloc
,
2632 .slave_configure
= esp_slave_configure
,
2633 .slave_destroy
= esp_slave_destroy
,
2634 .eh_abort_handler
= esp_eh_abort_handler
,
2635 .eh_bus_reset_handler
= esp_eh_bus_reset_handler
,
2636 .eh_host_reset_handler
= esp_eh_host_reset_handler
,
2639 .sg_tablesize
= SG_ALL
,
2640 .use_clustering
= ENABLE_CLUSTERING
,
2641 .max_sectors
= 0xffff,
2642 .skip_settle_delay
= 1,
2644 EXPORT_SYMBOL(scsi_esp_template
);
2646 static void esp_get_signalling(struct Scsi_Host
*host
)
2648 struct esp
*esp
= shost_priv(host
);
2649 enum spi_signal_type type
;
2651 if (esp
->flags
& ESP_FLAG_DIFFERENTIAL
)
2652 type
= SPI_SIGNAL_HVD
;
2654 type
= SPI_SIGNAL_SE
;
2656 spi_signalling(host
) = type
;
2659 static void esp_set_offset(struct scsi_target
*target
, int offset
)
2661 struct Scsi_Host
*host
= dev_to_shost(target
->dev
.parent
);
2662 struct esp
*esp
= shost_priv(host
);
2663 struct esp_target_data
*tp
= &esp
->target
[target
->id
];
2665 tp
->nego_goal_offset
= offset
;
2666 tp
->flags
|= ESP_TGT_CHECK_NEGO
;
2669 static void esp_set_period(struct scsi_target
*target
, int period
)
2671 struct Scsi_Host
*host
= dev_to_shost(target
->dev
.parent
);
2672 struct esp
*esp
= shost_priv(host
);
2673 struct esp_target_data
*tp
= &esp
->target
[target
->id
];
2675 tp
->nego_goal_period
= period
;
2676 tp
->flags
|= ESP_TGT_CHECK_NEGO
;
2679 static void esp_set_width(struct scsi_target
*target
, int width
)
2681 struct Scsi_Host
*host
= dev_to_shost(target
->dev
.parent
);
2682 struct esp
*esp
= shost_priv(host
);
2683 struct esp_target_data
*tp
= &esp
->target
[target
->id
];
2685 tp
->nego_goal_width
= (width
? 1 : 0);
2686 tp
->flags
|= ESP_TGT_CHECK_NEGO
;
2689 static struct spi_function_template esp_transport_ops
= {
2690 .set_offset
= esp_set_offset
,
2692 .set_period
= esp_set_period
,
2694 .set_width
= esp_set_width
,
2696 .get_signalling
= esp_get_signalling
,
2699 static int __init
esp_init(void)
2701 BUILD_BUG_ON(sizeof(struct scsi_pointer
) <
2702 sizeof(struct esp_cmd_priv
));
2704 esp_transport_template
= spi_attach_transport(&esp_transport_ops
);
2705 if (!esp_transport_template
)
2711 static void __exit
esp_exit(void)
2713 spi_release_transport(esp_transport_template
);
2716 MODULE_DESCRIPTION("ESP SCSI driver core");
2717 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
2718 MODULE_LICENSE("GPL");
2719 MODULE_VERSION(DRV_VERSION
);
2721 module_param(esp_bus_reset_settle
, int, 0);
2722 MODULE_PARM_DESC(esp_bus_reset_settle
,
2723 "ESP scsi bus reset delay in seconds");
2725 module_param(esp_debug
, int, 0);
2726 MODULE_PARM_DESC(esp_debug
,
2727 "ESP bitmapped debugging message enable value:\n"
2728 " 0x00000001 Log interrupt events\n"
2729 " 0x00000002 Log scsi commands\n"
2730 " 0x00000004 Log resets\n"
2731 " 0x00000008 Log message in events\n"
2732 " 0x00000010 Log message out events\n"
2733 " 0x00000020 Log command completion\n"
2734 " 0x00000040 Log disconnects\n"
2735 " 0x00000080 Log data start\n"
2736 " 0x00000100 Log data done\n"
2737 " 0x00000200 Log reconnects\n"
2738 " 0x00000400 Log auto-sense data\n"
2741 module_init(esp_init
);
2742 module_exit(esp_exit
);