File: /usr/src/linux/drivers/scsi/sun3x_esp.c
1 /* sun3x_esp.c: EnhancedScsiProcessor Sun3x SCSI driver code.
2 *
3 * (C) 1999 Thomas Bogendoerfer (tsbogend@alpha.franken.de)
4 *
5 * Based on David S. Miller's esp driver
6 */
7
8 #include <linux/kernel.h>
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/slab.h>
12 #include <linux/blk.h>
13 #include <linux/proc_fs.h>
14 #include <linux/stat.h>
15 #include <linux/delay.h>
16
17 #include "scsi.h"
18 #include "hosts.h"
19 #include "NCR53C9x.h"
20
21 #include "sun3x_esp.h"
22 #include <asm/sun3x.h>
23 #include <asm/dvma.h>
24
25 extern struct NCR_ESP *espchain;
26
27 static void dma_barrier(struct NCR_ESP *esp);
28 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count);
29 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd *sp);
30 static void dma_drain(struct NCR_ESP *esp);
31 static void dma_dump_state(struct NCR_ESP *esp);
32 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length);
33 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length);
34 static void dma_ints_off(struct NCR_ESP *esp);
35 static void dma_ints_on(struct NCR_ESP *esp);
36 static int dma_irq_p(struct NCR_ESP *esp);
37 static void dma_poll(struct NCR_ESP *esp, unsigned char *vaddr);
38 static int dma_ports_p(struct NCR_ESP *esp);
39 static void dma_reset(struct NCR_ESP *esp);
40 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write);
41 static void dma_mmu_get_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp);
42 static void dma_mmu_get_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp);
43 static void dma_mmu_release_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp);
44 static void dma_mmu_release_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp);
45 static void dma_advance_sg (Scsi_Cmnd *sp);
46
47 volatile unsigned char cmd_buffer[16];
48 /* This is where all commands are put
49 * before they are trasfered to the ESP chip
50 * via PIO.
51 */
52
53 /* Detecting ESP chips on the machine. This is the simple and easy
54 * version.
55 */
56 int sun3x_esp_detect(Scsi_Host_Template *tpnt)
57 {
58 struct NCR_ESP *esp;
59 struct ConfigDev *esp_dev;
60
61 esp_dev = 0;
62 esp = esp_allocate(tpnt, (void *) esp_dev);
63
64 /* Do command transfer with DMA */
65 esp->do_pio_cmds = 0;
66
67 /* Required functions */
68 esp->dma_bytes_sent = &dma_bytes_sent;
69 esp->dma_can_transfer = &dma_can_transfer;
70 esp->dma_dump_state = &dma_dump_state;
71 esp->dma_init_read = &dma_init_read;
72 esp->dma_init_write = &dma_init_write;
73 esp->dma_ints_off = &dma_ints_off;
74 esp->dma_ints_on = &dma_ints_on;
75 esp->dma_irq_p = &dma_irq_p;
76 esp->dma_ports_p = &dma_ports_p;
77 esp->dma_setup = &dma_setup;
78
79 /* Optional functions */
80 esp->dma_barrier = &dma_barrier;
81 esp->dma_drain = &dma_drain;
82 esp->dma_irq_entry = &dma_ints_off;
83 esp->dma_irq_exit = &dma_ints_on;
84 esp->dma_led_on = 0;
85 esp->dma_led_off = 0;
86 esp->dma_poll = &dma_poll;
87 esp->dma_reset = &dma_reset;
88
89 /* virtual DMA functions */
90 esp->dma_mmu_get_scsi_one = &dma_mmu_get_scsi_one;
91 esp->dma_mmu_get_scsi_sgl = &dma_mmu_get_scsi_sgl;
92 esp->dma_mmu_release_scsi_one = &dma_mmu_release_scsi_one;
93 esp->dma_mmu_release_scsi_sgl = &dma_mmu_release_scsi_sgl;
94 esp->dma_advance_sg = &dma_advance_sg;
95
96 /* SCSI chip speed */
97 esp->cfreq = 20000000;
98 esp->eregs = (struct ESP_regs *)(SUN3X_ESP_BASE);
99 esp->dregs = (void *)SUN3X_ESP_DMA;
100
101 esp->esp_command = (volatile unsigned char *)cmd_buffer;
102 esp->esp_command_dvma = dvma_alloc(virt_to_phys(cmd_buffer),
103 sizeof (cmd_buffer));
104
105 esp->irq = 2;
106 if (request_irq(esp->irq, esp_intr, SA_INTERRUPT,
107 "SUN3X SCSI", NULL)) {
108 esp_deallocate(esp);
109 return 0;
110 }
111
112 esp->scsi_id = 7;
113 esp->diff = 0;
114
115 esp_initialize(esp);
116
117 printk("ESP: Total of %d ESP hosts found, %d actually in use.\n", nesps,
118 esps_in_use);
119 esps_running = esps_in_use;
120 return esps_in_use;
121 }
122
123 static void dma_barrier(struct NCR_ESP *esp)
124 {
125 struct sparc_dma_registers *dregs =
126 (struct sparc_dma_registers *) esp->dregs;
127
128 while(dregs->cond_reg & DMA_PEND_READ)
129 udelay(1);
130 dregs->cond_reg &= ~(DMA_ENABLE);
131 }
132
133 /* This uses various DMA csr fields and the fifo flags count value to
134 * determine how many bytes were successfully sent/received by the ESP.
135 */
136 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count)
137 {
138 struct sparc_dma_registers *dregs =
139 (struct sparc_dma_registers *) esp->dregs;
140
141 int rval = dregs->st_addr - esp->esp_command_dvma;
142
143 return rval - fifo_count;
144 }
145
146 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd *sp)
147 {
148 __u32 base, end, sz;
149
150 base = ((__u32)sp->SCp.ptr);
151 base &= (0x1000000 - 1);
152 end = (base + sp->SCp.this_residual);
153 if(end > 0x1000000)
154 end = 0x1000000;
155 sz = (end - base);
156 return sz;
157 }
158
159 static void dma_drain(struct NCR_ESP *esp)
160 {
161 struct sparc_dma_registers *dregs =
162 (struct sparc_dma_registers *) esp->dregs;
163
164 if(dregs->cond_reg & DMA_FIFO_ISDRAIN) {
165 dregs->cond_reg |= DMA_FIFO_STDRAIN;
166 while(dregs->cond_reg & DMA_FIFO_ISDRAIN)
167 udelay(1);
168 }
169 }
170
171 static void dma_dump_state(struct NCR_ESP *esp)
172 {
173 struct sparc_dma_registers *dregs =
174 (struct sparc_dma_registers *) esp->dregs;
175
176 ESPLOG(("esp%d: dma -- cond_reg<%08lx> addr<%p>\n",
177 esp->esp_id, dregs->cond_reg, dregs->st_addr));
178 }
179
180 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length)
181 {
182 struct sparc_dma_registers *dregs =
183 (struct sparc_dma_registers *) esp->dregs;
184
185 dregs->cond_reg |= (DMA_ST_WRITE | DMA_ENABLE);
186 dregs->st_addr = vaddress;
187 }
188
189 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length)
190 {
191 struct sparc_dma_registers *dregs =
192 (struct sparc_dma_registers *) esp->dregs;
193
194 /* Set up the DMA counters */
195 dregs->cond_reg = ((dregs->cond_reg & ~(DMA_ST_WRITE)) | DMA_ENABLE);
196 dregs->st_addr = vaddress;
197 }
198
199 static void dma_ints_off(struct NCR_ESP *esp)
200 {
201 DMA_INTSOFF((struct sparc_dma_registers *) esp->dregs);
202 }
203
204 static void dma_ints_on(struct NCR_ESP *esp)
205 {
206 DMA_INTSON((struct sparc_dma_registers *) esp->dregs);
207 }
208
209 static int dma_irq_p(struct NCR_ESP *esp)
210 {
211 return DMA_IRQ_P((struct sparc_dma_registers *) esp->dregs);
212 }
213
214 static void dma_poll(struct NCR_ESP *esp, unsigned char *vaddr)
215 {
216 dma_drain(esp);
217
218 /* Wait till the first bits settle. */
219 while(vaddr[0] == 0xff)
220 udelay(1);
221 }
222
223 static int dma_ports_p(struct NCR_ESP *esp)
224 {
225 return (((struct sparc_dma_registers *) esp->dregs)->cond_reg
226 & DMA_INT_ENAB);
227 }
228
229 /* Resetting various pieces of the ESP scsi driver chipset/buses. */
230 static void dma_reset(struct NCR_ESP *esp)
231 {
232 struct sparc_dma_registers *dregs =
233 (struct sparc_dma_registers *)esp->dregs;
234
235 /* Punt the DVMA into a known state. */
236 dregs->cond_reg |= DMA_RST_SCSI;
237 dregs->cond_reg &= ~(DMA_RST_SCSI);
238 DMA_INTSON(dregs);
239 }
240
241 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
242 {
243 struct sparc_dma_registers *dregs =
244 (struct sparc_dma_registers *) esp->dregs;
245 unsigned long nreg = dregs->cond_reg;
246
247 if(write)
248 nreg |= DMA_ST_WRITE;
249 else
250 nreg &= ~(DMA_ST_WRITE);
251 nreg |= DMA_ENABLE;
252 dregs->cond_reg = nreg;
253 dregs->st_addr = addr;
254 }
255
256 static void dma_mmu_get_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp)
257 {
258 sp->SCp.have_data_in = dvma_alloc(virt_to_phys(sp->SCp.buffer),
259 sp->SCp.this_residual);
260 sp->SCp.ptr = (char *)((unsigned long)sp->SCp.have_data_in);
261 }
262
263 static void dma_mmu_get_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp)
264 {
265 int sz = sp->SCp.buffers_residual;
266 struct mmu_sglist *sg = (struct mmu_sglist *) sp->SCp.buffer;
267
268 while (sz >= 0) {
269 sg[sz].dvma_addr = dvma_alloc(virt_to_phys(sg[sz].addr), sg[sz].len);
270 sz--;
271 }
272 sp->SCp.ptr=(char *)((unsigned long)sp->SCp.buffer->dvma_address);
273 }
274
275 static void dma_mmu_release_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp)
276 {
277 dvma_free(sp->SCp.have_data_in, sp->request_bufflen);
278 }
279
280 static void dma_mmu_release_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp)
281 {
282 int sz = sp->use_sg - 1;
283 struct mmu_sglist *sg = (struct mmu_sglist *)sp->buffer;
284
285 while(sz >= 0) {
286 dvma_free(sg[sz].dvma_addr,sg[sz].len);
287 sz--;
288 }
289 }
290
291 static void dma_advance_sg (Scsi_Cmnd *sp)
292 {
293 sp->SCp.ptr = (char *)((unsigned long)sp->SCp.buffer->dvma_address);
294 }
295
296 static Scsi_Host_Template driver_template = SCSI_SUN3X_ESP;
297
298 #include "scsi_module.c"
299