2 * SCSI low-level driver for the 53c94 SCSI bus adaptor found
3 * on Power Macintosh computers, controlling the external SCSI chain.
4 * We assume the 53c94 is connected to a DBDMA (descriptor-based DMA)
7 * Paul Mackerras, August 1996.
8 * Copyright (C) 1996 Paul Mackerras.
10 #include <linux/kernel.h>
11 #include <linux/delay.h>
12 #include <linux/types.h>
13 #include <linux/string.h>
14 #include <linux/slab.h>
15 #include <linux/blkdev.h>
16 #include <linux/proc_fs.h>
17 #include <linux/stat.h>
18 #include <linux/spinlock.h>
19 #include <linux/interrupt.h>
20 #include <asm/dbdma.h>
22 #include <asm/pgtable.h>
24 #include <asm/system.h>
25 #include <asm/pci-bridge.h>
26 #include <asm/macio.h>
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <scsi/scsi_device.h>
31 #include <scsi/scsi_host.h>
44 struct mac53c94_regs __iomem
*regs
;
46 struct dbdma_regs __iomem
*dma
;
49 struct Scsi_Host
*host
;
50 struct scsi_cmnd
*request_q
;
51 struct scsi_cmnd
*request_qtail
;
52 struct scsi_cmnd
*current_req
; /* req we're currently working on */
53 enum fsc_phase phase
; /* what we're currently trying to do */
54 struct dbdma_cmd
*dma_cmds
; /* space for dbdma commands, aligned */
58 struct macio_dev
*mdev
;
61 static void mac53c94_init(struct fsc_state
*);
62 static void mac53c94_start(struct fsc_state
*);
63 static void mac53c94_interrupt(int, void *, struct pt_regs
*);
64 static irqreturn_t
do_mac53c94_interrupt(int, void *, struct pt_regs
*);
65 static void cmd_done(struct fsc_state
*, int result
);
66 static void set_dma_cmds(struct fsc_state
*, struct scsi_cmnd
*);
69 static int mac53c94_queue(struct scsi_cmnd
*cmd
, void (*done
)(struct scsi_cmnd
*))
71 struct fsc_state
*state
;
74 if (cmd
->sc_data_direction
== DMA_TO_DEVICE
) {
76 printk(KERN_DEBUG
"mac53c94_queue %p: command is", cmd
);
77 for (i
= 0; i
< cmd
->cmd_len
; ++i
)
78 printk(" %.2x", cmd
->cmnd
[i
]);
79 printk("\n" KERN_DEBUG
"use_sg=%d request_bufflen=%d request_buffer=%p\n",
80 cmd
->use_sg
, cmd
->request_bufflen
, cmd
->request_buffer
);
84 cmd
->scsi_done
= done
;
85 cmd
->host_scribble
= NULL
;
87 state
= (struct fsc_state
*) cmd
->device
->host
->hostdata
;
89 if (state
->request_q
== NULL
)
90 state
->request_q
= cmd
;
92 state
->request_qtail
->host_scribble
= (void *) cmd
;
93 state
->request_qtail
= cmd
;
95 if (state
->phase
== idle
)
96 mac53c94_start(state
);
101 static int mac53c94_abort(struct scsi_cmnd
*cmd
)
106 static int mac53c94_host_reset(struct scsi_cmnd
*cmd
)
108 struct fsc_state
*state
= (struct fsc_state
*) cmd
->device
->host
->hostdata
;
109 struct mac53c94_regs __iomem
*regs
= state
->regs
;
110 struct dbdma_regs __iomem
*dma
= state
->dma
;
112 writel((RUN
|PAUSE
|FLUSH
|WAKE
) << 16, &dma
->control
);
113 writeb(CMD_SCSI_RESET
, ®s
->command
); /* assert RST */
114 udelay(100); /* leave it on for a while (>= 25us) */
115 writeb(CMD_RESET
, ®s
->command
);
117 mac53c94_init(state
);
118 writeb(CMD_NOP
, ®s
->command
);
122 static void mac53c94_init(struct fsc_state
*state
)
124 struct mac53c94_regs __iomem
*regs
= state
->regs
;
125 struct dbdma_regs __iomem
*dma
= state
->dma
;
128 writeb(state
->host
->this_id
| CF1_PAR_ENABLE
, ®s
->config1
);
129 writeb(TIMO_VAL(250), ®s
->sel_timeout
); /* 250ms */
130 writeb(CLKF_VAL(state
->clk_freq
), ®s
->clk_factor
);
131 writeb(CF2_FEATURE_EN
, ®s
->config2
);
132 writeb(0, ®s
->config3
);
133 writeb(0, ®s
->sync_period
);
134 writeb(0, ®s
->sync_offset
);
135 x
= readb(®s
->interrupt
);
136 writel((RUN
|PAUSE
|FLUSH
|WAKE
) << 16, &dma
->control
);
140 * Start the next command for a 53C94.
141 * Should be called with interrupts disabled.
143 static void mac53c94_start(struct fsc_state
*state
)
145 struct scsi_cmnd
*cmd
;
146 struct mac53c94_regs __iomem
*regs
= state
->regs
;
149 if (state
->phase
!= idle
|| state
->current_req
!= NULL
)
150 panic("inappropriate mac53c94_start (state=%p)", state
);
151 if (state
->request_q
== NULL
)
153 state
->current_req
= cmd
= state
->request_q
;
154 state
->request_q
= (struct scsi_cmnd
*) cmd
->host_scribble
;
157 writeb(0, ®s
->count_lo
);
158 writeb(0, ®s
->count_mid
);
159 writeb(0, ®s
->count_hi
);
160 writeb(CMD_NOP
+ CMD_DMA_MODE
, ®s
->command
);
162 writeb(CMD_FLUSH
, ®s
->command
);
164 writeb(cmd
->device
->id
, ®s
->dest_id
);
165 writeb(0, ®s
->sync_period
);
166 writeb(0, ®s
->sync_offset
);
168 /* load the command into the FIFO */
169 for (i
= 0; i
< cmd
->cmd_len
; ++i
)
170 writeb(cmd
->cmnd
[i
], ®s
->fifo
);
172 /* do select without ATN XXX */
173 writeb(CMD_SELECT
, ®s
->command
);
174 state
->phase
= selecting
;
176 if (cmd
->use_sg
> 0 || cmd
->request_bufflen
!= 0)
177 set_dma_cmds(state
, cmd
);
180 static irqreturn_t
do_mac53c94_interrupt(int irq
, void *dev_id
, struct pt_regs
*ptregs
)
183 struct Scsi_Host
*dev
= ((struct fsc_state
*) dev_id
)->current_req
->device
->host
;
185 spin_lock_irqsave(dev
->host_lock
, flags
);
186 mac53c94_interrupt(irq
, dev_id
, ptregs
);
187 spin_unlock_irqrestore(dev
->host_lock
, flags
);
191 static void mac53c94_interrupt(int irq
, void *dev_id
, struct pt_regs
*ptregs
)
193 struct fsc_state
*state
= (struct fsc_state
*) dev_id
;
194 struct mac53c94_regs __iomem
*regs
= state
->regs
;
195 struct dbdma_regs __iomem
*dma
= state
->dma
;
196 struct scsi_cmnd
*cmd
= state
->current_req
;
197 int nb
, stat
, seq
, intr
;
198 static int mac53c94_errors
;
201 * Apparently, reading the interrupt register unlatches
202 * the status and sequence step registers.
204 seq
= readb(®s
->seqstep
);
205 stat
= readb(®s
->status
);
206 intr
= readb(®s
->interrupt
);
209 printk(KERN_DEBUG
"mac53c94_intr, intr=%x stat=%x seq=%x phase=%d\n",
210 intr
, stat
, seq
, state
->phase
);
213 if (intr
& INTR_RESET
) {
214 /* SCSI bus was reset */
215 printk(KERN_INFO
"external SCSI bus reset detected\n");
216 writeb(CMD_NOP
, ®s
->command
);
217 writel(RUN
<< 16, &dma
->control
); /* stop dma */
218 cmd_done(state
, DID_RESET
<< 16);
221 if (intr
& INTR_ILL_CMD
) {
222 printk(KERN_ERR
"53c94: invalid cmd, intr=%x stat=%x seq=%x phase=%d\n",
223 intr
, stat
, seq
, state
->phase
);
224 cmd_done(state
, DID_ERROR
<< 16);
227 if (stat
& STAT_ERROR
) {
229 /* XXX these seem to be harmless? */
230 printk("53c94: bad error, intr=%x stat=%x seq=%x phase=%d\n",
231 intr
, stat
, seq
, state
->phase
);
234 writeb(CMD_NOP
+ CMD_DMA_MODE
, ®s
->command
);
237 printk(KERN_DEBUG
"53c94: interrupt with no command active?\n");
240 if (stat
& STAT_PARITY
) {
241 printk(KERN_ERR
"mac53c94: parity error\n");
242 cmd_done(state
, DID_PARITY
<< 16);
245 switch (state
->phase
) {
247 if (intr
& INTR_DISCONNECT
) {
248 /* selection timed out */
249 cmd_done(state
, DID_BAD_TARGET
<< 16);
252 if (intr
!= INTR_BUS_SERV
+ INTR_DONE
) {
253 printk(KERN_DEBUG
"got intr %x during selection\n", intr
);
254 cmd_done(state
, DID_ERROR
<< 16);
257 if ((seq
& SS_MASK
) != SS_DONE
) {
258 printk(KERN_DEBUG
"seq step %x after command\n", seq
);
259 cmd_done(state
, DID_ERROR
<< 16);
262 writeb(CMD_NOP
, ®s
->command
);
263 /* set DMA controller going if any data to transfer */
264 if ((stat
& (STAT_MSG
|STAT_CD
)) == 0
265 && (cmd
->use_sg
> 0 || cmd
->request_bufflen
!= 0)) {
266 nb
= cmd
->SCp
.this_residual
;
269 cmd
->SCp
.this_residual
-= nb
;
270 writeb(nb
, ®s
->count_lo
);
271 writeb(nb
>> 8, ®s
->count_mid
);
272 writeb(CMD_DMA_MODE
+ CMD_NOP
, ®s
->command
);
273 writel(virt_to_phys(state
->dma_cmds
), &dma
->cmdptr
);
274 writel((RUN
<< 16) | RUN
, &dma
->control
);
275 writeb(CMD_DMA_MODE
+ CMD_XFER_DATA
, ®s
->command
);
276 state
->phase
= dataing
;
278 } else if ((stat
& STAT_PHASE
) == STAT_CD
+ STAT_IO
) {
279 /* up to status phase already */
280 writeb(CMD_I_COMPLETE
, ®s
->command
);
281 state
->phase
= completing
;
283 printk(KERN_DEBUG
"in unexpected phase %x after cmd\n",
285 cmd_done(state
, DID_ERROR
<< 16);
291 if (intr
!= INTR_BUS_SERV
) {
292 printk(KERN_DEBUG
"got intr %x before status\n", intr
);
293 cmd_done(state
, DID_ERROR
<< 16);
296 if (cmd
->SCp
.this_residual
!= 0
297 && (stat
& (STAT_MSG
|STAT_CD
)) == 0) {
298 /* Set up the count regs to transfer more */
299 nb
= cmd
->SCp
.this_residual
;
302 cmd
->SCp
.this_residual
-= nb
;
303 writeb(nb
, ®s
->count_lo
);
304 writeb(nb
>> 8, ®s
->count_mid
);
305 writeb(CMD_DMA_MODE
+ CMD_NOP
, ®s
->command
);
306 writeb(CMD_DMA_MODE
+ CMD_XFER_DATA
, ®s
->command
);
309 if ((stat
& STAT_PHASE
) != STAT_CD
+ STAT_IO
) {
310 printk(KERN_DEBUG
"intr %x before data xfer complete\n", intr
);
312 writel(RUN
<< 16, &dma
->control
); /* stop dma */
313 if (cmd
->use_sg
!= 0) {
314 pci_unmap_sg(state
->pdev
,
315 (struct scatterlist
*)cmd
->request_buffer
,
316 cmd
->use_sg
, cmd
->sc_data_direction
);
318 pci_unmap_single(state
->pdev
, state
->dma_addr
,
319 cmd
->request_bufflen
, cmd
->sc_data_direction
);
321 /* should check dma status */
322 writeb(CMD_I_COMPLETE
, ®s
->command
);
323 state
->phase
= completing
;
326 if (intr
!= INTR_DONE
) {
327 printk(KERN_DEBUG
"got intr %x on completion\n", intr
);
328 cmd_done(state
, DID_ERROR
<< 16);
331 cmd
->SCp
.Status
= readb(®s
->fifo
);
332 cmd
->SCp
.Message
= readb(®s
->fifo
);
333 cmd
->result
= CMD_ACCEPT_MSG
;
334 writeb(CMD_ACCEPT_MSG
, ®s
->command
);
335 state
->phase
= busfreeing
;
338 if (intr
!= INTR_DISCONNECT
) {
339 printk(KERN_DEBUG
"got intr %x when expected disconnect\n", intr
);
341 cmd_done(state
, (DID_OK
<< 16) + (cmd
->SCp
.Message
<< 8)
345 printk(KERN_DEBUG
"don't know about phase %d\n", state
->phase
);
349 static void cmd_done(struct fsc_state
*state
, int result
)
351 struct scsi_cmnd
*cmd
;
353 cmd
= state
->current_req
;
355 cmd
->result
= result
;
356 (*cmd
->scsi_done
)(cmd
);
357 state
->current_req
= NULL
;
360 mac53c94_start(state
);
364 * Set up DMA commands for transferring data.
366 static void set_dma_cmds(struct fsc_state
*state
, struct scsi_cmnd
*cmd
)
368 int i
, dma_cmd
, total
;
369 struct scatterlist
*scl
;
370 struct dbdma_cmd
*dcmds
;
374 dma_cmd
= cmd
->sc_data_direction
== DMA_TO_DEVICE
?
375 OUTPUT_MORE
: INPUT_MORE
;
376 dcmds
= state
->dma_cmds
;
377 if (cmd
->use_sg
> 0) {
381 scl
= (struct scatterlist
*) cmd
->buffer
;
382 nseg
= pci_map_sg(state
->pdev
, scl
, cmd
->use_sg
,
383 cmd
->sc_data_direction
);
384 for (i
= 0; i
< nseg
; ++i
) {
385 dma_addr
= sg_dma_address(scl
);
386 dma_len
= sg_dma_len(scl
);
387 if (dma_len
> 0xffff)
388 panic("mac53c94: scatterlist element >= 64k");
390 st_le16(&dcmds
->req_count
, dma_len
);
391 st_le16(&dcmds
->command
, dma_cmd
);
392 st_le32(&dcmds
->phy_addr
, dma_addr
);
393 dcmds
->xfer_status
= 0;
398 total
= cmd
->request_bufflen
;
400 panic("mac53c94: transfer size >= 64k");
401 dma_addr
= pci_map_single(state
->pdev
, cmd
->request_buffer
,
402 total
, cmd
->sc_data_direction
);
403 state
->dma_addr
= dma_addr
;
404 st_le16(&dcmds
->req_count
, total
);
405 st_le32(&dcmds
->phy_addr
, dma_addr
);
406 dcmds
->xfer_status
= 0;
409 dma_cmd
+= OUTPUT_LAST
- OUTPUT_MORE
;
410 st_le16(&dcmds
[-1].command
, dma_cmd
);
411 st_le16(&dcmds
->command
, DBDMA_STOP
);
412 cmd
->SCp
.this_residual
= total
;
415 static struct scsi_host_template mac53c94_template
= {
416 .proc_name
= "53c94",
418 .queuecommand
= mac53c94_queue
,
419 .eh_abort_handler
= mac53c94_abort
,
420 .eh_host_reset_handler
= mac53c94_host_reset
,
423 .sg_tablesize
= SG_ALL
,
425 .use_clustering
= DISABLE_CLUSTERING
,
428 static int mac53c94_probe(struct macio_dev
*mdev
, const struct of_match
*match
)
430 struct device_node
*node
= macio_get_of_node(mdev
);
431 struct pci_dev
*pdev
= macio_get_pci_dev(mdev
);
432 struct fsc_state
*state
;
433 struct Scsi_Host
*host
;
435 unsigned char *clkprop
;
438 if (macio_resource_count(mdev
) != 2 || macio_irq_count(mdev
) != 2) {
439 printk(KERN_ERR
"mac53c94: expected 2 addrs and intrs (got %d/%d)\n",
440 node
->n_addrs
, node
->n_intrs
);
444 if (macio_request_resources(mdev
, "mac53c94") != 0) {
445 printk(KERN_ERR
"mac53c94: unable to request memory resources");
449 host
= scsi_host_alloc(&mac53c94_template
, sizeof(struct fsc_state
));
451 printk(KERN_ERR
"mac53c94: couldn't register host");
455 state
= (struct fsc_state
*) host
->hostdata
;
456 macio_set_drvdata(mdev
, state
);
461 state
->regs
= (struct mac53c94_regs __iomem
*)
462 ioremap(macio_resource_start(mdev
, 0), 0x1000);
463 state
->intr
= macio_irq(mdev
, 0);
464 state
->dma
= (struct dbdma_regs __iomem
*)
465 ioremap(macio_resource_start(mdev
, 1), 0x1000);
466 state
->dmaintr
= macio_irq(mdev
, 1);
467 if (state
->regs
== NULL
|| state
->dma
== NULL
) {
468 printk(KERN_ERR
"mac53c94: ioremap failed for %s\n",
473 clkprop
= get_property(node
, "clock-frequency", &proplen
);
474 if (clkprop
== NULL
|| proplen
!= sizeof(int)) {
475 printk(KERN_ERR
"%s: can't get clock frequency, "
476 "assuming 25MHz\n", node
->full_name
);
477 state
->clk_freq
= 25000000;
479 state
->clk_freq
= *(int *)clkprop
;
481 /* Space for dma command list: +1 for stop command,
482 * +1 to allow for aligning.
483 * XXX FIXME: Use DMA consistent routines
485 dma_cmd_space
= kmalloc((host
->sg_tablesize
+ 2) *
486 sizeof(struct dbdma_cmd
), GFP_KERNEL
);
487 if (dma_cmd_space
== 0) {
488 printk(KERN_ERR
"mac53c94: couldn't allocate dma "
489 "command space for %s\n", node
->full_name
);
492 state
->dma_cmds
= (struct dbdma_cmd
*)DBDMA_ALIGN(dma_cmd_space
);
493 memset(state
->dma_cmds
, 0, (host
->sg_tablesize
+ 1)
494 * sizeof(struct dbdma_cmd
));
495 state
->dma_cmd_space
= dma_cmd_space
;
497 mac53c94_init(state
);
499 if (request_irq(state
->intr
, do_mac53c94_interrupt
, 0, "53C94", state
)) {
500 printk(KERN_ERR
"mac53C94: can't get irq %d for %s\n",
501 state
->intr
, node
->full_name
);
505 /* XXX FIXME: handle failure */
506 scsi_add_host(host
, &mdev
->ofdev
.dev
);
507 scsi_scan_host(host
);
512 kfree(state
->dma_cmd_space
);
514 if (state
->dma
!= NULL
)
516 if (state
->regs
!= NULL
)
517 iounmap(state
->regs
);
520 macio_release_resources(mdev
);
525 static int mac53c94_remove(struct macio_dev
*mdev
)
527 struct fsc_state
*fp
= (struct fsc_state
*)macio_get_drvdata(mdev
);
528 struct Scsi_Host
*host
= fp
->host
;
530 scsi_remove_host(host
);
532 free_irq(fp
->intr
, fp
);
535 iounmap((void *) fp
->regs
);
537 iounmap((void *) fp
->dma
);
538 kfree(fp
->dma_cmd_space
);
542 macio_release_resources(mdev
);
548 static struct of_match mac53c94_match
[] =
552 .type
= OF_ANY_MATCH
,
553 .compatible
= OF_ANY_MATCH
558 static struct macio_driver mac53c94_driver
=
561 .match_table
= mac53c94_match
,
562 .probe
= mac53c94_probe
,
563 .remove
= mac53c94_remove
,
567 static int __init
init_mac53c94(void)
569 return macio_register_driver(&mac53c94_driver
);
572 static void __exit
exit_mac53c94(void)
574 return macio_unregister_driver(&mac53c94_driver
);
577 module_init(init_mac53c94
);
578 module_exit(exit_mac53c94
);
580 MODULE_DESCRIPTION("PowerMac 53c94 SCSI driver");
581 MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>");
582 MODULE_LICENSE("GPL");