?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / scsi / dec_esp.c
blobf4bdec16d02a7423abfc01e8aed31554cfb3221e
1 /*
2 * dec_esp.c: Driver for SCSI chips on IOASIC based TURBOchannel DECstations
3 * and TURBOchannel PMAZ-A cards
4 *
5 * TURBOchannel changes by Harald Koerfgen
6 * PMAZ-A support by David Airlie
7 *
8 * based on jazz_esp.c:
9 * Copyright (C) 1997 Thomas Bogendoerfer (tsbogend@alpha.franken.de)
10 *
11 * jazz_esp is based on David S. Miller's ESP driver and cyber_esp
12 *
13 * 20000819 - Small PMAZ-AA fixes by Florian Lohoff <flo@rfc822.org>
14 * Be warned the PMAZ-AA works currently as a single card.
15 * Dont try to put multiple cards in one machine - They are
16 * both detected but it may crash under high load garbling your
17 * data.
18 * 20001005 - Initialization fixes for 2.4.0-test9
19 * Florian Lohoff <flo@rfc822.org>
20 */
21
22 #include <linux/kernel.h>
23 #include <linux/delay.h>
24 #include <linux/types.h>
25 #include <linux/string.h>
26 #include <linux/slab.h>
27 #include <linux/blkdev.h>
28 #include <linux/proc_fs.h>
29 #include <linux/stat.h>
30
31 #include "scsi.h"
32 #include <scsi/scsi_host.h>
33 #include "NCR53C9x.h"
34
35 #include <asm/irq.h>
36 #include <asm/jazz.h>
37 #include <asm/jazzdma.h>
38 #include <asm/dma.h>
39
40 #include <asm/pgtable.h>
41
42 #include <asm/dec/tc.h>
43 #include <asm/dec/interrupts.h>
44 #include <asm/dec/ioasic_addrs.h>
45 #include <asm/dec/ioasic_ints.h>
46 #include <asm/dec/machtype.h>
47
48 #define DEC_SCSI_SREG 0
49 #define DEC_SCSI_DMAREG 0x40000
50 #define DEC_SCSI_SRAM 0x80000
51 #define DEC_SCSI_DIAG 0xC0000
52
53 /*
54 * Once upon a time the pmaz code used to be working but
55 * it hasn't been maintained for quite some time.
56 * It isn't working anymore but I'll leave here as a
57 * starting point. #define this an be prepared for tons
58 * of warnings and errors :)
59 */
60 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count);
61 static void dma_drain(struct NCR_ESP *esp);
62 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd * sp);
63 static void dma_dump_state(struct NCR_ESP *esp);
64 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length);
65 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length);
66 static void dma_ints_off(struct NCR_ESP *esp);
67 static void dma_ints_on(struct NCR_ESP *esp);
68 static int dma_irq_p(struct NCR_ESP *esp);
69 static int dma_ports_p(struct NCR_ESP *esp);
70 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write);
71 static void dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp);
72 static void dma_mmu_get_scsi_sgl(struct NCR_ESP *esp, Scsi_Cmnd * sp);
73 static void dma_advance_sg(Scsi_Cmnd * sp);
74
75 static void pmaz_dma_drain(struct NCR_ESP *esp);
76 static void pmaz_dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length);
77 static void pmaz_dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length);
78 static void pmaz_dma_ints_off(struct NCR_ESP *esp);
79 static void pmaz_dma_ints_on(struct NCR_ESP *esp);
80 static void pmaz_dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write);
81 static void pmaz_dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp);
82
83 #define TC_ESP_RAM_SIZE 0x20000
84 #define ESP_TGT_DMA_SIZE ((TC_ESP_RAM_SIZE/7) & ~(sizeof(int)-1))
85 #define ESP_NCMD 7
86
87 #define TC_ESP_DMAR_MASK 0x1ffff
88 #define TC_ESP_DMAR_WRITE 0x80000000
89 #define TC_ESP_DMA_ADDR(x) ((unsigned)(x) & TC_ESP_DMAR_MASK)
90
91 __u32 esp_virt_buffer;
92 int scsi_current_length;
93
94 volatile unsigned char cmd_buffer[16];
95 volatile unsigned char pmaz_cmd_buffer[16];
96 /* This is where all commands are put
97 * before they are trasfered to the ESP chip
98 * via PIO.
99 */
100
101 volatile unsigned long *scsi_dma_ptr;
102 volatile unsigned long *scsi_next_ptr;
103 volatile unsigned long *scsi_scr;
104 volatile unsigned long *ioasic_ssr;
105 volatile unsigned long *scsi_sdr0;
106 volatile unsigned long *scsi_sdr1;
107
108 static void scsi_dma_int(int, void *, struct pt_regs *);
109
110 int dec_esp_detect(Scsi_Host_Template * tpnt);
111
112 static int dec_esp_release(struct Scsi_Host *shost)
113 {
114 if (shost->irq)
115 free_irq(shost->irq, NULL);
116 if (shost->io_port && shost->n_io_port)
117 release_region(shost->io_port, shost->n_io_port);
118 scsi_unregister(shost);
119 return 0;
120 }
121
122 static Scsi_Host_Template driver_template = {
123 .proc_name = "esp",
124 .proc_info = &esp_proc_info,
125 .name = "NCR53C94",
126 .detect = dec_esp_detect,
127 .slave_alloc = esp_slave_alloc,
128 .slave_destroy = esp_slave_destroy,
129 .release = dec_esp_release,
130 .info = esp_info,
131 .queuecommand = esp_queue,
132 .eh_abort_handler = esp_abort,
133 .eh_bus_reset_handler = esp_reset,
134 .can_queue = 7,
135 .this_id = 7,
136 .sg_tablesize = SG_ALL,
137 .cmd_per_lun = 1,
138 .use_clustering = DISABLE_CLUSTERING,
139 };
140
141
142 #include "scsi_module.c"
143
144 /***************************************************************** Detection */
145 int dec_esp_detect(Scsi_Host_Template * tpnt)
146 {
147 struct NCR_ESP *esp;
148 struct ConfigDev *esp_dev;
149 int slot;
150 unsigned long mem_start;
151
152 if (IOASIC) {
153 esp_dev = 0;
154 esp = esp_allocate(tpnt, (void *) esp_dev);
155
156 scsi_dma_ptr = (unsigned long *) (system_base + IOCTL + SCSI_DMA_P);
157 scsi_next_ptr = (unsigned long *) (system_base + IOCTL + SCSI_DMA_BP);
158 scsi_scr = (unsigned long *) (system_base + IOCTL + SCSI_SCR);
159 ioasic_ssr = (unsigned long *) (system_base + IOCTL + SSR);
160 scsi_sdr0 = (unsigned long *) (system_base + IOCTL + SCSI_SDR0);
161 scsi_sdr1 = (unsigned long *) (system_base + IOCTL + SCSI_SDR1);
162
163 /* Do command transfer with programmed I/O */
164 esp->do_pio_cmds = 1;
165
166 /* Required functions */
167 esp->dma_bytes_sent = &dma_bytes_sent;
168 esp->dma_can_transfer = &dma_can_transfer;
169 esp->dma_dump_state = &dma_dump_state;
170 esp->dma_init_read = &dma_init_read;
171 esp->dma_init_write = &dma_init_write;
172 esp->dma_ints_off = &dma_ints_off;
173 esp->dma_ints_on = &dma_ints_on;
174 esp->dma_irq_p = &dma_irq_p;
175 esp->dma_ports_p = &dma_ports_p;
176 esp->dma_setup = &dma_setup;
177
178 /* Optional functions */
179 esp->dma_barrier = 0;
180 esp->dma_drain = &dma_drain;
181 esp->dma_invalidate = 0;
182 esp->dma_irq_entry = 0;
183 esp->dma_irq_exit = 0;
184 esp->dma_poll = 0;
185 esp->dma_reset = 0;
186 esp->dma_led_off = 0;
187 esp->dma_led_on = 0;
188
189 /* virtual DMA functions */
190 esp->dma_mmu_get_scsi_one = &dma_mmu_get_scsi_one;
191 esp->dma_mmu_get_scsi_sgl = &dma_mmu_get_scsi_sgl;
192 esp->dma_mmu_release_scsi_one = 0;
193 esp->dma_mmu_release_scsi_sgl = 0;
194 esp->dma_advance_sg = &dma_advance_sg;
195
196
197 /* SCSI chip speed */
198 esp->cfreq = 25000000;
199
200 /*
201 * we don't give the address of DMA channel, but the number
202 * of DMA channel, so we can use the jazz DMA functions
203 *
204 */
205 esp->dregs = JAZZ_SCSI_DMA;
206
207 /* ESP register base */
208 esp->eregs = (struct ESP_regs *) (system_base + SCSI);
209
210 /* Set the command buffer */
211 esp->esp_command = (volatile unsigned char *) cmd_buffer;
212
213 /* get virtual dma address for command buffer */
214 esp->esp_command_dvma = (__u32) KSEG1ADDR((volatile unsigned char *) cmd_buffer);
215
216 esp->irq = SCSI_INT;
217
218 esp->scsi_id = 7;
219
220 /* Check for differential SCSI-bus */
221 esp->diff = 0;
222
223 esp_initialize(esp);
224
225 if (request_irq(esp->irq, esp_intr, SA_INTERRUPT,
226 "NCR 53C94 SCSI", esp->ehost))
227 goto err_dealloc;
228 if (request_irq(SCSI_DMA_INT, scsi_dma_int, SA_INTERRUPT,
229 "JUNKIO SCSI DMA", esp->ehost))
230 goto err_free_irq;
231
232 }
233
234 if (TURBOCHANNEL) {
235 while ((slot = search_tc_card("PMAZ-AA")) >= 0) {
236 claim_tc_card(slot);
237
238 esp_dev = 0;
239 esp = esp_allocate(tpnt, (void *) esp_dev);
240
241 mem_start = get_tc_base_addr(slot);
242
243 /* Store base addr into esp struct */
244 esp->slot = mem_start;
245
246 esp->dregs = 0;
247 esp->eregs = (struct ESP_regs *) (mem_start + DEC_SCSI_SREG);
248 esp->do_pio_cmds = 1;
249
250 /* Set the command buffer */
251 esp->esp_command = (volatile unsigned char *) pmaz_cmd_buffer;
252
253 /* get virtual dma address for command buffer */
254 esp->esp_command_dvma = (__u32) KSEG0ADDR((volatile unsigned char *) pmaz_cmd_buffer);
255
256 esp->cfreq = get_tc_speed();
257
258 esp->irq = get_tc_irq_nr(slot);
259
260 /* Required functions */
261 esp->dma_bytes_sent = &dma_bytes_sent;
262 esp->dma_can_transfer = &dma_can_transfer;
263 esp->dma_dump_state = &dma_dump_state;
264 esp->dma_init_read = &pmaz_dma_init_read;
265 esp->dma_init_write = &pmaz_dma_init_write;
266 esp->dma_ints_off = &pmaz_dma_ints_off;
267 esp->dma_ints_on = &pmaz_dma_ints_on;
268 esp->dma_irq_p = &dma_irq_p;
269 esp->dma_ports_p = &dma_ports_p;
270 esp->dma_setup = &pmaz_dma_setup;
271
272 /* Optional functions */
273 esp->dma_barrier = 0;
274 esp->dma_drain = &pmaz_dma_drain;
275 esp->dma_invalidate = 0;
276 esp->dma_irq_entry = 0;
277 esp->dma_irq_exit = 0;
278 esp->dma_poll = 0;
279 esp->dma_reset = 0;
280 esp->dma_led_off = 0;
281 esp->dma_led_on = 0;
282
283 esp->dma_mmu_get_scsi_one = pmaz_dma_mmu_get_scsi_one;
284 esp->dma_mmu_get_scsi_sgl = 0;
285 esp->dma_mmu_release_scsi_one = 0;
286 esp->dma_mmu_release_scsi_sgl = 0;
287 esp->dma_advance_sg = 0;
288
289 if (request_irq(esp->irq, esp_intr, SA_INTERRUPT,
290 "PMAZ_AA", esp->ehost)) {
291 esp_deallocate(esp);
292 release_tc_card(slot);
293 continue;
294 }
295 esp->scsi_id = 7;
296 esp->diff = 0;
297 esp_initialize(esp);
298 }
299 }
300
301 if(nesps) {
302 printk("ESP: Total of %d ESP hosts found, %d actually in use.\n", nesps, esps_in_use);
303 esps_running = esps_in_use;
304 return esps_in_use;
305 }
306 return 0;
307
308 err_free_irq:
309 free_irq(esp->irq, esp_intr);
310 err_dealloc:
311 esp_deallocate(esp);
312 return 0;
313 }
314
315 /************************************************************* DMA Functions */
316 static void scsi_dma_int(int irq, void *dev_id, struct pt_regs *regs)
317 {
318 extern volatile unsigned int *isr;
319 unsigned int dummy;
320
321 if (*isr & SCSI_PTR_LOADED) {
322 /* next page */
323 *scsi_next_ptr = ((*scsi_dma_ptr + PAGE_SIZE) & PAGE_MASK) << 3;
324 *isr &= ~SCSI_PTR_LOADED;
325 } else {
326 if (*isr & SCSI_PAGOVRRUN)
327 *isr &= ~SCSI_PAGOVRRUN;
328 if (*isr & SCSI_DMA_MEMRDERR) {
329 printk("Got unexpected SCSI DMA Interrupt! < ");
330 printk("SCSI_DMA_MEMRDERR ");
331 printk(">\n");
332 *isr &= ~SCSI_DMA_MEMRDERR;
333 }
334 }
335
336 /*
337 * This routine will only work on IOASIC machines
338 * so we can avoid an indirect function call here
339 * and flush the writeback buffer the fast way
340 */
341 dummy = *isr;
342 dummy = *isr;
343 }
344
345 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count)
346 {
347 return fifo_count;
348 }
349
350 static void dma_drain(struct NCR_ESP *esp)
351 {
352 unsigned long nw = *scsi_scr;
353 unsigned short *p = (unsigned short *)KSEG1ADDR((*scsi_dma_ptr) >> 3);
354
355 /*
356 * Is there something in the dma buffers left?
357 */
358 if (nw) {
359 switch (nw) {
360 case 1:
361 *p = (unsigned short) *scsi_sdr0;
362 break;
363 case 2:
364 *p++ = (unsigned short) (*scsi_sdr0);
365 *p = (unsigned short) ((*scsi_sdr0) >> 16);
366 break;
367 case 3:
368 *p++ = (unsigned short) (*scsi_sdr0);
369 *p++ = (unsigned short) ((*scsi_sdr0) >> 16);
370 *p = (unsigned short) (*scsi_sdr1);
371 break;
372 default:
373 printk("Strange: %d words in dma buffer left\n", (int) nw);
374 break;
375 }
376 }
377 }
378
379 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd * sp)
380 {
381 return sp->SCp.this_residual;
382 }
383
384 static void dma_dump_state(struct NCR_ESP *esp)
385 {
386 /*
387 ESPLOG(("esp%d: dma -- enable <%08x> residue <%08x\n",
388 esp->esp_id, vdma_get_enable((int)esp->dregs), vdma_get_resdiue((int)esp->dregs)));
389 */
390 }
391
392 static void dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length)
393 {
394 extern volatile unsigned int *isr;
395 unsigned int dummy;
396
397 if (vaddress & 3)
398 panic("dec_efs.c: unable to handle partial word transfers, yet...");
399
400 dma_cache_wback_inv((unsigned long) phys_to_virt(vaddress), length);
401
402 *ioasic_ssr &= ~SCSI_DMA_EN;
403 *scsi_scr = 0;
404 *scsi_dma_ptr = vaddress << 3;
405
406 /* prepare for next page */
407 *scsi_next_ptr = ((vaddress + PAGE_SIZE) & PAGE_MASK) << 3;
408 *ioasic_ssr |= (SCSI_DMA_DIR | SCSI_DMA_EN);
409
410 /*
411 * see above
412 */
413 dummy = *isr;
414 dummy = *isr;
415 }
416
417 static void dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length)
418 {
419 extern volatile unsigned int *isr;
420 unsigned int dummy;
421
422 if (vaddress & 3)
423 panic("dec_efs.c: unable to handle partial word transfers, yet...");
424
425 dma_cache_wback_inv((unsigned long) phys_to_virt(vaddress), length);
426
427 *ioasic_ssr &= ~(SCSI_DMA_DIR | SCSI_DMA_EN);
428 *scsi_scr = 0;
429 *scsi_dma_ptr = vaddress << 3;
430
431 /* prepare for next page */
432 *scsi_next_ptr = ((vaddress + PAGE_SIZE) & PAGE_MASK) << 3;
433 *ioasic_ssr |= SCSI_DMA_EN;
434
435 /*
436 * see above
437 */
438 dummy = *isr;
439 dummy = *isr;
440 }
441
442 static void dma_ints_off(struct NCR_ESP *esp)
443 {
444 disable_irq(SCSI_DMA_INT);
445 }
446
447 static void dma_ints_on(struct NCR_ESP *esp)
448 {
449 enable_irq(SCSI_DMA_INT);
450 }
451
452 static int dma_irq_p(struct NCR_ESP *esp)
453 {
454 return (esp->eregs->esp_status & ESP_STAT_INTR);
455 }
456
457 static int dma_ports_p(struct NCR_ESP *esp)
458 {
459 /*
460 * FIXME: what's this good for?
461 */
462 return 1;
463 }
464
465 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
466 {
467 /*
468 * On the Sparc, DMA_ST_WRITE means "move data from device to memory"
469 * so when (write) is true, it actually means READ!
470 */
471 if (write) {
472 dma_init_read(esp, addr, count);
473 } else {
474 dma_init_write(esp, addr, count);
475 }
476 }
477
478 /*
479 * These aren't used yet
480 */
481 static void dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp)
482 {
483 sp->SCp.ptr = (char *)PHYSADDR(sp->SCp.buffer);
484 }
485
486 static void dma_mmu_get_scsi_sgl(struct NCR_ESP *esp, Scsi_Cmnd * sp)
487 {
488 int sz = sp->SCp.buffers_residual;
489 struct mmu_sglist *sg = (struct mmu_sglist *) sp->SCp.buffer;
490
491 while (sz >= 0) {
492 sg[sz].dvma_addr = PHYSADDR(sg[sz].addr);
493 sz--;
494 }
495 sp->SCp.ptr = (char *) ((unsigned long) sp->SCp.buffer->dvma_address);
496 }
497
498 static void dma_advance_sg(Scsi_Cmnd * sp)
499 {
500 sp->SCp.ptr = (char *) ((unsigned long) sp->SCp.buffer->dvma_address);
501 }
502
503 static void pmaz_dma_drain(struct NCR_ESP *esp)
504 {
505 memcpy((void *) (KSEG0ADDR(esp_virt_buffer)),
506 (void *) ( esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE),
507 scsi_current_length);
508 }
509
510 static void pmaz_dma_init_read(struct NCR_ESP *esp, __u32 vaddress, int length)
511 {
512 volatile int *dmareg = (volatile int *) (esp->slot + DEC_SCSI_DMAREG);
513
514 if (length > ESP_TGT_DMA_SIZE)
515 length = ESP_TGT_DMA_SIZE;
516
517 *dmareg = TC_ESP_DMA_ADDR(esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE);
518
519 esp_virt_buffer = vaddress;
520 scsi_current_length = length;
521 }
522
523 static void pmaz_dma_init_write(struct NCR_ESP *esp, __u32 vaddress, int length)
524 {
525 volatile int *dmareg = (volatile int *) ( esp->slot + DEC_SCSI_DMAREG );
526
527 memcpy((void *)(esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE),
528 (void *)KSEG0ADDR(vaddress), length);
529
530 *dmareg = TC_ESP_DMAR_WRITE |
531 TC_ESP_DMA_ADDR(esp->slot + DEC_SCSI_SRAM + ESP_TGT_DMA_SIZE);
532
533 }
534
535 static void pmaz_dma_ints_off(struct NCR_ESP *esp)
536 {
537 }
538
539 static void pmaz_dma_ints_on(struct NCR_ESP *esp)
540 {
541 }
542
543 static void pmaz_dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
544 {
545 /*
546 * On the Sparc, DMA_ST_WRITE means "move data from device to memory"
547 * so when (write) is true, it actually means READ!
548 */
549 if (write) {
550 pmaz_dma_init_read(esp, addr, count);
551 } else {
552 pmaz_dma_init_write(esp, addr, count);
553 }
554 }
555
556 static void pmaz_dma_mmu_get_scsi_one(struct NCR_ESP *esp, Scsi_Cmnd * sp)
557 {
558 sp->SCp.ptr = (char *)KSEG0ADDR((sp->request_buffer));
559 }
MOXA 2.6.9 from sdlinux-moxaart.tgz