?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kbuild: Fix instrumentation removal breakage on avr32
[wrt350n-kernel.git] / drivers / scsi / mca_53c9x.c
blobd693d0f213956bb2a5d9f9bfd4c0e4791a63d95a
1 /* mca_53c9x.c: Driver for the SCSI adapter found on NCR 35xx
2 * (and maybe some other) Microchannel machines
3 *
4 * Code taken mostly from Cyberstorm SCSI drivers
5 * Copyright (C) 1996 Jesper Skov (jskov@cygnus.co.uk)
6 *
7 * Hacked to work with the NCR MCA stuff by Tymm Twillman (tymm@computer.org)
8 *
9 * The CyberStorm SCSI driver (and this driver) is based on David S. Miller's
10 * ESP driver * for the Sparc computers.
11 *
12 * Special thanks to Ken Stewart at Symbios (LSI) for helping with info on
13 * the 86C01. I was on the brink of going ga-ga...
14 *
15 * Also thanks to Jesper Skov for helping me with info on how the Amiga
16 * does things...
17 */
18
19 /*
20 * This is currently only set up to use one 53c9x card at a time; it could be
21 * changed fairly easily to detect/use more than one, but I'm not too sure how
22 * many cards that use the 53c9x on MCA systems there are (if, in fact, there
23 * are cards that use them, other than the one built into some NCR systems)...
24 * If anyone requests this, I'll throw it in, otherwise it's not worth the
25 * effort.
26 */
27
28 /*
29 * Info on the 86C01 MCA interface chip at the bottom, if you care enough to
30 * look.
31 */
32
33 #include <linux/delay.h>
34 #include <linux/interrupt.h>
35 #include <linux/kernel.h>
36 #include <linux/mca.h>
37 #include <linux/types.h>
38 #include <linux/string.h>
39 #include <linux/slab.h>
40 #include <linux/blkdev.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/mca-legacy.h>
44
45 #include "scsi.h"
46 #include <scsi/scsi_host.h>
47 #include "NCR53C9x.h"
48
49 #include <asm/dma.h>
50 #include <asm/irq.h>
51 #include <asm/mca_dma.h>
52 #include <asm/pgtable.h>
53
54 /*
55 * From ibmmca.c (IBM scsi controller card driver) -- used for turning PS2 disk
56 * activity LED on and off
57 */
58
59 #define PS2_SYS_CTR 0x92
60
61 /* Ports the ncr's 53c94 can be put at; indexed by pos register value */
62
63 #define MCA_53C9X_IO_PORTS { \
64 0x0000, 0x0240, 0x0340, 0x0400, \
65 0x0420, 0x3240, 0x8240, 0xA240, \
66 }
67
68 /*
69 * Supposedly there were some cards put together with the 'c9x and 86c01. If
70 * they have different ID's from the ones on the 3500 series machines,
71 * you can add them here and hopefully things will work out.
72 */
73
74 #define MCA_53C9X_IDS { \
75 0x7F4C, \
76 0x0000, \
77 }
78
79 static int dma_bytes_sent(struct NCR_ESP *, int);
80 static int dma_can_transfer(struct NCR_ESP *, Scsi_Cmnd *);
81 static void dma_dump_state(struct NCR_ESP *);
82 static void dma_init_read(struct NCR_ESP *, __u32, int);
83 static void dma_init_write(struct NCR_ESP *, __u32, int);
84 static void dma_ints_off(struct NCR_ESP *);
85 static void dma_ints_on(struct NCR_ESP *);
86 static int dma_irq_p(struct NCR_ESP *);
87 static int dma_ports_p(struct NCR_ESP *);
88 static void dma_setup(struct NCR_ESP *, __u32, int, int);
89 static void dma_led_on(struct NCR_ESP *);
90 static void dma_led_off(struct NCR_ESP *);
91
92 /* This is where all commands are put before they are trasfered to the
93 * 53c9x via PIO.
94 */
95
96 static volatile unsigned char cmd_buffer[16];
97
98 /*
99 * We keep the structure that is used to access the registers on the 53c9x
100 * here.
101 */
102
103 static struct ESP_regs eregs;
104
105 /***************************************************************** Detection */
106 static int mca_esp_detect(struct scsi_host_template *tpnt)
107 {
108 struct NCR_ESP *esp;
109 static int io_port_by_pos[] = MCA_53C9X_IO_PORTS;
110 int mca_53c9x_ids[] = MCA_53C9X_IDS;
111 int *id_to_check = mca_53c9x_ids;
112 int slot;
113 int pos[3];
114 unsigned int tmp_io_addr;
115 unsigned char tmp_byte;
116
117
118 if (!MCA_bus)
119 return 0;
120
121 while (*id_to_check) {
122 if ((slot = mca_find_adapter(*id_to_check, 0)) !=
123 MCA_NOTFOUND)
124 {
125 esp = esp_allocate(tpnt, NULL, 0);
126
127 pos[0] = mca_read_stored_pos(slot, 2);
128 pos[1] = mca_read_stored_pos(slot, 3);
129 pos[2] = mca_read_stored_pos(slot, 4);
130
131 esp->eregs = &eregs;
132
133 /*
134 * IO port base is given in the first (non-ID) pos
135 * register, like so:
136 *
137 * Bits 3 2 1 IO base
138 * ----------------------------
139 * 0 0 0 <disabled>
140 * 0 0 1 0x0240
141 * 0 1 0 0x0340
142 * 0 1 1 0x0400
143 * 1 0 0 0x0420
144 * 1 0 1 0x3240
145 * 1 1 0 0x8240
146 * 1 1 1 0xA240
147 */
148
149 tmp_io_addr =
150 io_port_by_pos[(pos[0] & 0x0E) >> 1];
151
152 esp->eregs->io_addr = tmp_io_addr + 0x10;
153
154 if (esp->eregs->io_addr == 0x0000) {
155 printk("Adapter is disabled.\n");
156 break;
157 }
158
159 /*
160 * IRQ is specified in bits 4 and 5:
161 *
162 * Bits 4 5 IRQ
163 * -----------------------
164 * 0 0 3
165 * 0 1 5
166 * 1 0 7
167 * 1 1 9
168 */
169
170 esp->irq = ((pos[0] & 0x30) >> 3) + 3;
171
172 /*
173 * DMA channel is in the low 3 bits of the second
174 * POS register
175 */
176
177 esp->dma = pos[1] & 7;
178 esp->slot = slot;
179
180 if (request_irq(esp->irq, esp_intr, 0,
181 "NCR 53c9x SCSI", esp->ehost))
182 {
183 printk("Unable to request IRQ %d.\n", esp->irq);
184 esp_deallocate(esp);
185 scsi_unregister(esp->ehost);
186 return 0;
187 }
188
189 if (request_dma(esp->dma, "NCR 53c9x SCSI")) {
190 printk("Unable to request DMA channel %d.\n",
191 esp->dma);
192 free_irq(esp->irq, esp_intr);
193 esp_deallocate(esp);
194 scsi_unregister(esp->ehost);
195 return 0;
196 }
197
198 request_region(tmp_io_addr, 32, "NCR 53c9x SCSI");
199
200 /*
201 * 86C01 handles DMA, IO mode, from address
202 * (base + 0x0a)
203 */
204
205 mca_disable_dma(esp->dma);
206 mca_set_dma_io(esp->dma, tmp_io_addr + 0x0a);
207 mca_enable_dma(esp->dma);
208
209 /* Tell the 86C01 to give us interrupts */
210
211 tmp_byte = inb(tmp_io_addr + 0x02) | 0x40;
212 outb(tmp_byte, tmp_io_addr + 0x02);
213
214 /*
215 * Scsi ID -- general purpose register, hi
216 * 2 bits; add 4 to this number to get the
217 * ID
218 */
219
220 esp->scsi_id = ((pos[2] & 0xC0) >> 6) + 4;
221
222 /* Do command transfer with programmed I/O */
223
224 esp->do_pio_cmds = 1;
225
226 /* Required functions */
227
228 esp->dma_bytes_sent = &dma_bytes_sent;
229 esp->dma_can_transfer = &dma_can_transfer;
230 esp->dma_dump_state = &dma_dump_state;
231 esp->dma_init_read = &dma_init_read;
232 esp->dma_init_write = &dma_init_write;
233 esp->dma_ints_off = &dma_ints_off;
234 esp->dma_ints_on = &dma_ints_on;
235 esp->dma_irq_p = &dma_irq_p;
236 esp->dma_ports_p = &dma_ports_p;
237 esp->dma_setup = &dma_setup;
238
239 /* Optional functions */
240
241 esp->dma_barrier = NULL;
242 esp->dma_drain = NULL;
243 esp->dma_invalidate = NULL;
244 esp->dma_irq_entry = NULL;
245 esp->dma_irq_exit = NULL;
246 esp->dma_led_on = dma_led_on;
247 esp->dma_led_off = dma_led_off;
248 esp->dma_poll = NULL;
249 esp->dma_reset = NULL;
250
251 /* Set the command buffer */
252
253 esp->esp_command = (volatile unsigned char*)
254 cmd_buffer;
255 esp->esp_command_dvma = isa_virt_to_bus(cmd_buffer);
256
257 /* SCSI chip speed */
258
259 esp->cfreq = 25000000;
260
261 /* Differential SCSI? I think not. */
262
263 esp->diff = 0;
264
265 esp_initialize(esp);
266
267 printk(" Adapter found in slot %2d: io port 0x%x "
268 "irq %d dma channel %d\n", slot + 1, tmp_io_addr,
269 esp->irq, esp->dma);
270
271 mca_set_adapter_name(slot, "NCR 53C9X SCSI Adapter");
272 mca_mark_as_used(slot);
273
274 break;
275 }
276
277 id_to_check++;
278 }
279
280 return esps_in_use;
281 }
282
283
284 /******************************************************************* Release */
285
286 static int mca_esp_release(struct Scsi_Host *host)
287 {
288 struct NCR_ESP *esp = (struct NCR_ESP *)host->hostdata;
289 unsigned char tmp_byte;
290
291 esp_deallocate(esp);
292 /*
293 * Tell the 86C01 to stop sending interrupts
294 */
295
296 tmp_byte = inb(esp->eregs->io_addr - 0x0E);
297 tmp_byte &= ~0x40;
298 outb(tmp_byte, esp->eregs->io_addr - 0x0E);
299
300 free_irq(esp->irq, esp_intr);
301 free_dma(esp->dma);
302
303 mca_mark_as_unused(esp->slot);
304
305 return 0;
306 }
307
308 /************************************************************* DMA Functions */
309 static int dma_bytes_sent(struct NCR_ESP *esp, int fifo_count)
310 {
311 /* Ask the 53c9x. It knows. */
312
313 return fifo_count;
314 }
315
316 static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd *sp)
317 {
318 /*
319 * The MCA dma channels can only do up to 128K bytes at a time.
320 * (16 bit mode)
321 */
322
323 unsigned long sz = sp->SCp.this_residual;
324 if(sz > 0x20000)
325 sz = 0x20000;
326 return sz;
327 }
328
329 static void dma_dump_state(struct NCR_ESP *esp)
330 {
331 /*
332 * Doesn't quite match up to the other drivers, but we do what we
333 * can.
334 */
335
336 ESPLOG(("esp%d: dma channel <%d>\n", esp->esp_id, esp->dma));
337 ESPLOG(("bytes left to dma: %d\n", mca_get_dma_residue(esp->dma)));
338 }
339
340 static void dma_init_read(struct NCR_ESP *esp, __u32 addr, int length)
341 {
342 unsigned long flags;
343
344
345 save_flags(flags);
346 cli();
347
348 mca_disable_dma(esp->dma);
349 mca_set_dma_mode(esp->dma, MCA_DMA_MODE_XFER | MCA_DMA_MODE_16 |
350 MCA_DMA_MODE_IO);
351 mca_set_dma_addr(esp->dma, addr);
352 mca_set_dma_count(esp->dma, length / 2); /* !!! */
353 mca_enable_dma(esp->dma);
354
355 restore_flags(flags);
356 }
357
358 static void dma_init_write(struct NCR_ESP *esp, __u32 addr, int length)
359 {
360 unsigned long flags;
361
362
363 save_flags(flags);
364 cli();
365
366 mca_disable_dma(esp->dma);
367 mca_set_dma_mode(esp->dma, MCA_DMA_MODE_XFER | MCA_DMA_MODE_WRITE |
368 MCA_DMA_MODE_16 | MCA_DMA_MODE_IO);
369 mca_set_dma_addr(esp->dma, addr);
370 mca_set_dma_count(esp->dma, length / 2); /* !!! */
371 mca_enable_dma(esp->dma);
372
373 restore_flags(flags);
374 }
375
376 static void dma_ints_off(struct NCR_ESP *esp)
377 {
378 /*
379 * Tell the 'C01 to shut up. All interrupts are routed through it.
380 */
381
382 outb(inb(esp->eregs->io_addr - 0x0E) & ~0x40,
383 esp->eregs->io_addr - 0x0E);
384 }
385
386 static void dma_ints_on(struct NCR_ESP *esp)
387 {
388 /*
389 * Ok. You can speak again.
390 */
391
392 outb(inb(esp->eregs->io_addr - 0x0E) | 0x40,
393 esp->eregs->io_addr - 0x0E);
394 }
395
396 static int dma_irq_p(struct NCR_ESP *esp)
397 {
398 /*
399 * DaveM says that this should return a "yes" if there is an interrupt
400 * or a DMA error occurred. I copied the Amiga driver's semantics,
401 * though, because it seems to work and we can't really tell if
402 * a DMA error happened. This gives the "yes" if the scsi chip
403 * is sending an interrupt and no DMA activity is taking place
404 */
405
406 return (!(inb(esp->eregs->io_addr - 0x04) & 1) &&
407 !(inb(esp->eregs->io_addr - 0x04) & 2) );
408 }
409
410 static int dma_ports_p(struct NCR_ESP *esp)
411 {
412 /*
413 * Check to see if interrupts are enabled on the 'C01 (in case abort
414 * is entered multiple times, so we only do the abort once)
415 */
416
417 return (inb(esp->eregs->io_addr - 0x0E) & 0x40) ? 1:0;
418 }
419
420 static void dma_setup(struct NCR_ESP *esp, __u32 addr, int count, int write)
421 {
422 if(write){
423 dma_init_write(esp, addr, count);
424 } else {
425 dma_init_read(esp, addr, count);
426 }
427 }
428
429 /*
430 * These will not play nicely with other disk controllers that try to use the
431 * disk active LED... but what can you do? Don't answer that.
432 *
433 * Stolen shamelessly from ibmmca.c -- IBM Microchannel SCSI adapter driver
434 *
435 */
436
437 static void dma_led_on(struct NCR_ESP *esp)
438 {
439 outb(inb(PS2_SYS_CTR) | 0xc0, PS2_SYS_CTR);
440 }
441
442 static void dma_led_off(struct NCR_ESP *esp)
443 {
444 outb(inb(PS2_SYS_CTR) & 0x3f, PS2_SYS_CTR);
445 }
446
447 static struct scsi_host_template driver_template = {
448 .proc_name = "mca_53c9x",
449 .name = "NCR 53c9x SCSI",
450 .detect = mca_esp_detect,
451 .slave_alloc = esp_slave_alloc,
452 .slave_destroy = esp_slave_destroy,
453 .release = mca_esp_release,
454 .queuecommand = esp_queue,
455 .eh_abort_handler = esp_abort,
456 .eh_bus_reset_handler = esp_reset,
457 .can_queue = 7,
458 .sg_tablesize = SG_ALL,
459 .cmd_per_lun = 1,
460 .unchecked_isa_dma = 1,
461 .use_clustering = DISABLE_CLUSTERING
462 };
463
464
465 #include "scsi_module.c"
466
467 /*
468 * OK, here's the goods I promised. The NCR 86C01 is an MCA interface chip
469 * that handles enabling/diabling IRQ, dma interfacing, IO port selection
470 * and other fun stuff. It takes up 16 addresses, and the chip it is
471 * connnected to gets the following 16. Registers are as follows:
472 *
473 * Offsets 0-1 : Card ID
474 *
475 * Offset 2 : Mode enable register --
476 * Bit 7 : Data Word width (1 = 16, 0 = 8)
477 * Bit 6 : IRQ enable (1 = enabled)
478 * Bits 5,4 : IRQ select
479 * 0 0 : IRQ 3
480 * 0 1 : IRQ 5
481 * 1 0 : IRQ 7
482 * 1 1 : IRQ 9
483 * Bits 3-1 : Base Address
484 * 0 0 0 : <disabled>
485 * 0 0 1 : 0x0240
486 * 0 1 0 : 0x0340
487 * 0 1 1 : 0x0400
488 * 1 0 0 : 0x0420
489 * 1 0 1 : 0x3240
490 * 1 1 0 : 0x8240
491 * 1 1 1 : 0xA240
492 * Bit 0 : Card enable (1 = enabled)
493 *
494 * Offset 3 : DMA control register --
495 * Bit 7 : DMA enable (1 = enabled)
496 * Bits 6,5 : Preemt Count Select (transfers to complete after
497 * 'C01 has been preempted on MCA bus)
498 * 0 0 : 0
499 * 0 1 : 1
500 * 1 0 : 3
501 * 1 1 : 7
502 * (all these wacky numbers; I'm sure there's a reason somewhere)
503 * Bit 4 : Fairness enable (1 = fair bus priority)
504 * Bits 3-0 : Arbitration level (0-15 consecutive)
505 *
506 * Offset 4 : General purpose register
507 * Bits 7-3 : User definable (here, 7,6 are SCSI ID)
508 * Bits 2-0 : reserved
509 *
510 * Offset 10 : DMA decode register (used for IO based DMA; also can do
511 * PIO through this port)
512 *
513 * Offset 12 : Status
514 * Bits 7-2 : reserved
515 * Bit 1 : DMA pending (1 = pending)
516 * Bit 0 : IRQ pending (0 = pending)
517 *
518 * Exciting, huh?
519 *
520 */
WRT350N Kernel Patches