?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.9.237
[linux/fpc-iii.git] / drivers / scsi / g_NCR5380.c
blob596a75924d90210b092d93904c54521d1e903279
1 /*
2 * Generic Generic NCR5380 driver
3 *
4 * Copyright 1993, Drew Eckhardt
5 * Visionary Computing
6 * (Unix and Linux consulting and custom programming)
7 * drew@colorado.edu
8 * +1 (303) 440-4894
9 *
10 * NCR53C400 extensions (c) 1994,1995,1996, Kevin Lentin
11 * K.Lentin@cs.monash.edu.au
12 *
13 * NCR53C400A extensions (c) 1996, Ingmar Baumgart
14 * ingmar@gonzo.schwaben.de
15 *
16 * DTC3181E extensions (c) 1997, Ronald van Cuijlenborg
17 * ronald.van.cuijlenborg@tip.nl or nutty@dds.nl
18 *
19 * Added ISAPNP support for DTC436 adapters,
20 * Thomas Sailer, sailer@ife.ee.ethz.ch
21 *
22 * See Documentation/scsi/g_NCR5380.txt for more info.
23 */
24
25 #include <asm/io.h>
26 #include <linux/blkdev.h>
27 #include <linux/module.h>
28 #include <scsi/scsi_host.h>
29 #include "g_NCR5380.h"
30 #include "NCR5380.h"
31 #include <linux/init.h>
32 #include <linux/ioport.h>
33 #include <linux/isa.h>
34 #include <linux/pnp.h>
35 #include <linux/interrupt.h>
36
37 #define MAX_CARDS 8
38
39 /* old-style parameters for compatibility */
40 static int ncr_irq;
41 static int ncr_addr;
42 static int ncr_5380;
43 static int ncr_53c400;
44 static int ncr_53c400a;
45 static int dtc_3181e;
46 static int hp_c2502;
47 module_param(ncr_irq, int, 0);
48 module_param(ncr_addr, int, 0);
49 module_param(ncr_5380, int, 0);
50 module_param(ncr_53c400, int, 0);
51 module_param(ncr_53c400a, int, 0);
52 module_param(dtc_3181e, int, 0);
53 module_param(hp_c2502, int, 0);
54
55 static int irq[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
56 module_param_array(irq, int, NULL, 0);
57 MODULE_PARM_DESC(irq, "IRQ number(s)");
58
59 static int base[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
60 module_param_array(base, int, NULL, 0);
61 MODULE_PARM_DESC(base, "base address(es)");
62
63 static int card[] = { -1, -1, -1, -1, -1, -1, -1, -1 };
64 module_param_array(card, int, NULL, 0);
65 MODULE_PARM_DESC(card, "card type (0=NCR5380, 1=NCR53C400, 2=NCR53C400A, 3=DTC3181E, 4=HP C2502)");
66
67 MODULE_LICENSE("GPL");
68
69 #ifndef SCSI_G_NCR5380_MEM
70 /*
71 * Configure I/O address of 53C400A or DTC436 by writing magic numbers
72 * to ports 0x779 and 0x379.
73 */
74 static void magic_configure(int idx, u8 irq, u8 magic[])
75 {
76 u8 cfg = 0;
77
78 outb(magic[0], 0x779);
79 outb(magic[1], 0x379);
80 outb(magic[2], 0x379);
81 outb(magic[3], 0x379);
82 outb(magic[4], 0x379);
83
84 /* allowed IRQs for HP C2502 */
85 if (irq != 2 && irq != 3 && irq != 4 && irq != 5 && irq != 7)
86 irq = 0;
87 if (idx >= 0 && idx <= 7)
88 cfg = 0x80 | idx | (irq << 4);
89 outb(cfg, 0x379);
90 }
91 #endif
92
93 static int generic_NCR5380_init_one(struct scsi_host_template *tpnt,
94 struct device *pdev, int base, int irq, int board)
95 {
96 unsigned int *ports;
97 u8 *magic = NULL;
98 #ifndef SCSI_G_NCR5380_MEM
99 int i;
100 int port_idx = -1;
101 unsigned long region_size;
102 #endif
103 static unsigned int ncr_53c400a_ports[] = {
104 0x280, 0x290, 0x300, 0x310, 0x330, 0x340, 0x348, 0x350, 0
105 };
106 static unsigned int dtc_3181e_ports[] = {
107 0x220, 0x240, 0x280, 0x2a0, 0x2c0, 0x300, 0x320, 0x340, 0
108 };
109 static u8 ncr_53c400a_magic[] = { /* 53C400A & DTC436 */
110 0x59, 0xb9, 0xc5, 0xae, 0xa6
111 };
112 static u8 hp_c2502_magic[] = { /* HP C2502 */
113 0x0f, 0x22, 0xf0, 0x20, 0x80
114 };
115 int flags, ret;
116 struct Scsi_Host *instance;
117 struct NCR5380_hostdata *hostdata;
118 #ifdef SCSI_G_NCR5380_MEM
119 void __iomem *iomem;
120 resource_size_t iomem_size;
121 #endif
122
123 ports = NULL;
124 flags = 0;
125 switch (board) {
126 case BOARD_NCR5380:
127 flags = FLAG_NO_PSEUDO_DMA | FLAG_DMA_FIXUP;
128 break;
129 case BOARD_NCR53C400A:
130 ports = ncr_53c400a_ports;
131 magic = ncr_53c400a_magic;
132 break;
133 case BOARD_HP_C2502:
134 ports = ncr_53c400a_ports;
135 magic = hp_c2502_magic;
136 break;
137 case BOARD_DTC3181E:
138 ports = dtc_3181e_ports;
139 magic = ncr_53c400a_magic;
140 break;
141 }
142
143 #ifndef SCSI_G_NCR5380_MEM
144 if (ports && magic) {
145 /* wakeup sequence for the NCR53C400A and DTC3181E */
146
147 /* Disable the adapter and look for a free io port */
148 magic_configure(-1, 0, magic);
149
150 region_size = 16;
151 if (base)
152 for (i = 0; ports[i]; i++) {
153 if (base == ports[i]) { /* index found */
154 if (!request_region(ports[i],
155 region_size,
156 "ncr53c80"))
157 return -EBUSY;
158 break;
159 }
160 }
161 else
162 for (i = 0; ports[i]; i++) {
163 if (!request_region(ports[i], region_size,
164 "ncr53c80"))
165 continue;
166 if (inb(ports[i]) == 0xff)
167 break;
168 release_region(ports[i], region_size);
169 }
170 if (ports[i]) {
171 /* At this point we have our region reserved */
172 magic_configure(i, 0, magic); /* no IRQ yet */
173 base = ports[i];
174 outb(0xc0, base + 9);
175 if (inb(base + 9) != 0x80) {
176 ret = -ENODEV;
177 goto out_release;
178 }
179 port_idx = i;
180 } else
181 return -EINVAL;
182 }
183 else
184 {
185 /* NCR5380 - no configuration, just grab */
186 region_size = 8;
187 if (!base || !request_region(base, region_size, "ncr5380"))
188 return -EBUSY;
189 }
190 #else
191 iomem_size = NCR53C400_region_size;
192 if (!request_mem_region(base, iomem_size, "ncr5380"))
193 return -EBUSY;
194 iomem = ioremap(base, iomem_size);
195 if (!iomem) {
196 release_mem_region(base, iomem_size);
197 return -ENOMEM;
198 }
199 #endif
200 instance = scsi_host_alloc(tpnt, sizeof(struct NCR5380_hostdata));
201 if (instance == NULL) {
202 ret = -ENOMEM;
203 goto out_release;
204 }
205 hostdata = shost_priv(instance);
206
207 #ifndef SCSI_G_NCR5380_MEM
208 instance->io_port = base;
209 instance->n_io_port = region_size;
210 hostdata->io_width = 1; /* 8-bit PDMA by default */
211
212 /*
213 * On NCR53C400 boards, NCR5380 registers are mapped 8 past
214 * the base address.
215 */
216 switch (board) {
217 case BOARD_NCR53C400:
218 instance->io_port += 8;
219 hostdata->c400_ctl_status = 0;
220 hostdata->c400_blk_cnt = 1;
221 hostdata->c400_host_buf = 4;
222 break;
223 case BOARD_DTC3181E:
224 hostdata->io_width = 2; /* 16-bit PDMA */
225 /* fall through */
226 case BOARD_NCR53C400A:
227 case BOARD_HP_C2502:
228 hostdata->c400_ctl_status = 9;
229 hostdata->c400_blk_cnt = 10;
230 hostdata->c400_host_buf = 8;
231 break;
232 }
233 #else
234 instance->base = base;
235 hostdata->iomem = iomem;
236 hostdata->iomem_size = iomem_size;
237 switch (board) {
238 case BOARD_NCR53C400:
239 hostdata->c400_ctl_status = 0x100;
240 hostdata->c400_blk_cnt = 0x101;
241 hostdata->c400_host_buf = 0x104;
242 break;
243 case BOARD_DTC3181E:
244 case BOARD_NCR53C400A:
245 case BOARD_HP_C2502:
246 pr_err(DRV_MODULE_NAME ": unknown register offsets\n");
247 ret = -EINVAL;
248 goto out_unregister;
249 }
250 #endif
251
252 ret = NCR5380_init(instance, flags | FLAG_LATE_DMA_SETUP);
253 if (ret)
254 goto out_unregister;
255
256 switch (board) {
257 case BOARD_NCR53C400:
258 case BOARD_DTC3181E:
259 case BOARD_NCR53C400A:
260 case BOARD_HP_C2502:
261 NCR5380_write(hostdata->c400_ctl_status, CSR_BASE);
262 }
263
264 NCR5380_maybe_reset_bus(instance);
265
266 if (irq != IRQ_AUTO)
267 instance->irq = irq;
268 else
269 instance->irq = NCR5380_probe_irq(instance, 0xffff);
270
271 /* Compatibility with documented NCR5380 kernel parameters */
272 if (instance->irq == 255)
273 instance->irq = NO_IRQ;
274
275 if (instance->irq != NO_IRQ) {
276 #ifndef SCSI_G_NCR5380_MEM
277 /* set IRQ for HP C2502 */
278 if (board == BOARD_HP_C2502)
279 magic_configure(port_idx, instance->irq, magic);
280 #endif
281 if (request_irq(instance->irq, generic_NCR5380_intr,
282 0, "NCR5380", instance)) {
283 printk(KERN_WARNING "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq);
284 instance->irq = NO_IRQ;
285 }
286 }
287
288 if (instance->irq == NO_IRQ) {
289 printk(KERN_INFO "scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
290 printk(KERN_INFO "scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
291 }
292
293 ret = scsi_add_host(instance, pdev);
294 if (ret)
295 goto out_free_irq;
296 scsi_scan_host(instance);
297 dev_set_drvdata(pdev, instance);
298 return 0;
299
300 out_free_irq:
301 if (instance->irq != NO_IRQ)
302 free_irq(instance->irq, instance);
303 NCR5380_exit(instance);
304 out_unregister:
305 scsi_host_put(instance);
306 out_release:
307 #ifndef SCSI_G_NCR5380_MEM
308 release_region(base, region_size);
309 #else
310 iounmap(iomem);
311 release_mem_region(base, iomem_size);
312 #endif
313 return ret;
314 }
315
316 static void generic_NCR5380_release_resources(struct Scsi_Host *instance)
317 {
318 scsi_remove_host(instance);
319 if (instance->irq != NO_IRQ)
320 free_irq(instance->irq, instance);
321 NCR5380_exit(instance);
322 #ifndef SCSI_G_NCR5380_MEM
323 release_region(instance->io_port, instance->n_io_port);
324 #else
325 {
326 struct NCR5380_hostdata *hostdata = shost_priv(instance);
327
328 iounmap(hostdata->iomem);
329 release_mem_region(instance->base, hostdata->iomem_size);
330 }
331 #endif
332 scsi_host_put(instance);
333 }
334
335 /**
336 * generic_NCR5380_pread - pseudo DMA read
337 * @instance: adapter to read from
338 * @dst: buffer to read into
339 * @len: buffer length
340 *
341 * Perform a pseudo DMA mode read from an NCR53C400 or equivalent
342 * controller
343 */
344
345 static inline int generic_NCR5380_pread(struct Scsi_Host *instance,
346 unsigned char *dst, int len)
347 {
348 struct NCR5380_hostdata *hostdata = shost_priv(instance);
349 int blocks = len / 128;
350 int start = 0;
351
352 NCR5380_write(hostdata->c400_ctl_status, CSR_BASE | CSR_TRANS_DIR);
353 NCR5380_write(hostdata->c400_blk_cnt, blocks);
354 while (1) {
355 if (NCR5380_read(hostdata->c400_blk_cnt) == 0)
356 break;
357 if (NCR5380_read(hostdata->c400_ctl_status) & CSR_GATED_53C80_IRQ) {
358 printk(KERN_ERR "53C400r: Got 53C80_IRQ start=%d, blocks=%d\n", start, blocks);
359 return -1;
360 }
361 while (NCR5380_read(hostdata->c400_ctl_status) & CSR_HOST_BUF_NOT_RDY)
362 ; /* FIXME - no timeout */
363
364 #ifndef SCSI_G_NCR5380_MEM
365 if (hostdata->io_width == 2)
366 insw(instance->io_port + hostdata->c400_host_buf,
367 dst + start, 64);
368 else
369 insb(instance->io_port + hostdata->c400_host_buf,
370 dst + start, 128);
371 #else
372 /* implies SCSI_G_NCR5380_MEM */
373 memcpy_fromio(dst + start,
374 hostdata->iomem + NCR53C400_host_buffer, 128);
375 #endif
376 start += 128;
377 blocks--;
378 }
379
380 if (blocks) {
381 while (NCR5380_read(hostdata->c400_ctl_status) & CSR_HOST_BUF_NOT_RDY)
382 ; /* FIXME - no timeout */
383
384 #ifndef SCSI_G_NCR5380_MEM
385 if (hostdata->io_width == 2)
386 insw(instance->io_port + hostdata->c400_host_buf,
387 dst + start, 64);
388 else
389 insb(instance->io_port + hostdata->c400_host_buf,
390 dst + start, 128);
391 #else
392 /* implies SCSI_G_NCR5380_MEM */
393 memcpy_fromio(dst + start,
394 hostdata->iomem + NCR53C400_host_buffer, 128);
395 #endif
396 start += 128;
397 blocks--;
398 }
399
400 if (!(NCR5380_read(hostdata->c400_ctl_status) & CSR_GATED_53C80_IRQ))
401 printk("53C400r: no 53C80 gated irq after transfer");
402
403 /* wait for 53C80 registers to be available */
404 while (!(NCR5380_read(hostdata->c400_ctl_status) & CSR_53C80_REG))
405 ;
406
407 if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_END_DMA_TRANSFER))
408 printk(KERN_ERR "53C400r: no end dma signal\n");
409
410 return 0;
411 }
412
413 /**
414 * generic_NCR5380_pwrite - pseudo DMA write
415 * @instance: adapter to read from
416 * @dst: buffer to read into
417 * @len: buffer length
418 *
419 * Perform a pseudo DMA mode read from an NCR53C400 or equivalent
420 * controller
421 */
422
423 static inline int generic_NCR5380_pwrite(struct Scsi_Host *instance,
424 unsigned char *src, int len)
425 {
426 struct NCR5380_hostdata *hostdata = shost_priv(instance);
427 int blocks = len / 128;
428 int start = 0;
429
430 NCR5380_write(hostdata->c400_ctl_status, CSR_BASE);
431 NCR5380_write(hostdata->c400_blk_cnt, blocks);
432 while (1) {
433 if (NCR5380_read(hostdata->c400_ctl_status) & CSR_GATED_53C80_IRQ) {
434 printk(KERN_ERR "53C400w: Got 53C80_IRQ start=%d, blocks=%d\n", start, blocks);
435 return -1;
436 }
437
438 if (NCR5380_read(hostdata->c400_blk_cnt) == 0)
439 break;
440 while (NCR5380_read(hostdata->c400_ctl_status) & CSR_HOST_BUF_NOT_RDY)
441 ; // FIXME - timeout
442 #ifndef SCSI_G_NCR5380_MEM
443 if (hostdata->io_width == 2)
444 outsw(instance->io_port + hostdata->c400_host_buf,
445 src + start, 64);
446 else
447 outsb(instance->io_port + hostdata->c400_host_buf,
448 src + start, 128);
449 #else
450 /* implies SCSI_G_NCR5380_MEM */
451 memcpy_toio(hostdata->iomem + NCR53C400_host_buffer,
452 src + start, 128);
453 #endif
454 start += 128;
455 blocks--;
456 }
457 if (blocks) {
458 while (NCR5380_read(hostdata->c400_ctl_status) & CSR_HOST_BUF_NOT_RDY)
459 ; // FIXME - no timeout
460
461 #ifndef SCSI_G_NCR5380_MEM
462 if (hostdata->io_width == 2)
463 outsw(instance->io_port + hostdata->c400_host_buf,
464 src + start, 64);
465 else
466 outsb(instance->io_port + hostdata->c400_host_buf,
467 src + start, 128);
468 #else
469 /* implies SCSI_G_NCR5380_MEM */
470 memcpy_toio(hostdata->iomem + NCR53C400_host_buffer,
471 src + start, 128);
472 #endif
473 start += 128;
474 blocks--;
475 }
476
477 /* wait for 53C80 registers to be available */
478 while (!(NCR5380_read(hostdata->c400_ctl_status) & CSR_53C80_REG)) {
479 udelay(4); /* DTC436 chip hangs without this */
480 /* FIXME - no timeout */
481 }
482
483 if (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_END_DMA_TRANSFER)) {
484 printk(KERN_ERR "53C400w: no end dma signal\n");
485 }
486
487 while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT))
488 ; // TIMEOUT
489 return 0;
490 }
491
492 static int generic_NCR5380_dma_xfer_len(struct Scsi_Host *instance,
493 struct scsi_cmnd *cmd)
494 {
495 struct NCR5380_hostdata *hostdata = shost_priv(instance);
496 int transfersize = cmd->transfersize;
497
498 if (hostdata->flags & FLAG_NO_PSEUDO_DMA)
499 return 0;
500
501 /* Limit transfers to 32K, for xx400 & xx406
502 * pseudoDMA that transfers in 128 bytes blocks.
503 */
504 if (transfersize > 32 * 1024 && cmd->SCp.this_residual &&
505 !(cmd->SCp.this_residual % transfersize))
506 transfersize = 32 * 1024;
507
508 /* 53C400 datasheet: non-modulo-128-byte transfers should use PIO */
509 if (transfersize % 128)
510 transfersize = 0;
511
512 return transfersize;
513 }
514
515 /*
516 * Include the NCR5380 core code that we build our driver around
517 */
518
519 #include "NCR5380.c"
520
521 static struct scsi_host_template driver_template = {
522 .module = THIS_MODULE,
523 .proc_name = DRV_MODULE_NAME,
524 .name = "Generic NCR5380/NCR53C400 SCSI",
525 .info = generic_NCR5380_info,
526 .queuecommand = generic_NCR5380_queue_command,
527 .eh_abort_handler = generic_NCR5380_abort,
528 .eh_bus_reset_handler = generic_NCR5380_bus_reset,
529 .can_queue = 16,
530 .this_id = 7,
531 .sg_tablesize = SG_ALL,
532 .cmd_per_lun = 2,
533 .use_clustering = DISABLE_CLUSTERING,
534 .cmd_size = NCR5380_CMD_SIZE,
535 .max_sectors = 128,
536 };
537
538
539 static int generic_NCR5380_isa_match(struct device *pdev, unsigned int ndev)
540 {
541 int ret = generic_NCR5380_init_one(&driver_template, pdev, base[ndev],
542 irq[ndev], card[ndev]);
543 if (ret) {
544 if (base[ndev])
545 printk(KERN_WARNING "Card not found at address 0x%03x\n",
546 base[ndev]);
547 return 0;
548 }
549
550 return 1;
551 }
552
553 static int generic_NCR5380_isa_remove(struct device *pdev,
554 unsigned int ndev)
555 {
556 generic_NCR5380_release_resources(dev_get_drvdata(pdev));
557 dev_set_drvdata(pdev, NULL);
558 return 0;
559 }
560
561 static struct isa_driver generic_NCR5380_isa_driver = {
562 .match = generic_NCR5380_isa_match,
563 .remove = generic_NCR5380_isa_remove,
564 .driver = {
565 .name = DRV_MODULE_NAME
566 },
567 };
568
569 #if !defined(SCSI_G_NCR5380_MEM) && defined(CONFIG_PNP)
570 static struct pnp_device_id generic_NCR5380_pnp_ids[] = {
571 { .id = "DTC436e", .driver_data = BOARD_DTC3181E },
572 { .id = "" }
573 };
574 MODULE_DEVICE_TABLE(pnp, generic_NCR5380_pnp_ids);
575
576 static int generic_NCR5380_pnp_probe(struct pnp_dev *pdev,
577 const struct pnp_device_id *id)
578 {
579 int base, irq;
580
581 if (pnp_activate_dev(pdev) < 0)
582 return -EBUSY;
583
584 base = pnp_port_start(pdev, 0);
585 irq = pnp_irq(pdev, 0);
586
587 return generic_NCR5380_init_one(&driver_template, &pdev->dev, base, irq,
588 id->driver_data);
589 }
590
591 static void generic_NCR5380_pnp_remove(struct pnp_dev *pdev)
592 {
593 generic_NCR5380_release_resources(pnp_get_drvdata(pdev));
594 pnp_set_drvdata(pdev, NULL);
595 }
596
597 static struct pnp_driver generic_NCR5380_pnp_driver = {
598 .name = DRV_MODULE_NAME,
599 .id_table = generic_NCR5380_pnp_ids,
600 .probe = generic_NCR5380_pnp_probe,
601 .remove = generic_NCR5380_pnp_remove,
602 };
603 #endif /* !defined(SCSI_G_NCR5380_MEM) && defined(CONFIG_PNP) */
604
605 static int pnp_registered, isa_registered;
606
607 static int __init generic_NCR5380_init(void)
608 {
609 int ret = 0;
610
611 /* compatibility with old-style parameters */
612 if (irq[0] == 0 && base[0] == 0 && card[0] == -1) {
613 irq[0] = ncr_irq;
614 base[0] = ncr_addr;
615 if (ncr_5380)
616 card[0] = BOARD_NCR5380;
617 if (ncr_53c400)
618 card[0] = BOARD_NCR53C400;
619 if (ncr_53c400a)
620 card[0] = BOARD_NCR53C400A;
621 if (dtc_3181e)
622 card[0] = BOARD_DTC3181E;
623 if (hp_c2502)
624 card[0] = BOARD_HP_C2502;
625 }
626
627 #if !defined(SCSI_G_NCR5380_MEM) && defined(CONFIG_PNP)
628 if (!pnp_register_driver(&generic_NCR5380_pnp_driver))
629 pnp_registered = 1;
630 #endif
631 ret = isa_register_driver(&generic_NCR5380_isa_driver, MAX_CARDS);
632 if (!ret)
633 isa_registered = 1;
634
635 return (pnp_registered || isa_registered) ? 0 : ret;
636 }
637
638 static void __exit generic_NCR5380_exit(void)
639 {
640 #if !defined(SCSI_G_NCR5380_MEM) && defined(CONFIG_PNP)
641 if (pnp_registered)
642 pnp_unregister_driver(&generic_NCR5380_pnp_driver);
643 #endif
644 if (isa_registered)
645 isa_unregister_driver(&generic_NCR5380_isa_driver);
646 }
647
648 module_init(generic_NCR5380_init);
649 module_exit(generic_NCR5380_exit);
Linux with added FPC-III support