atari_scsi.c 26.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * atari_scsi.c -- Device dependent functions for the Atari generic SCSI port
 *
 * Copyright 1994 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
 *
 *   Loosely based on the work of Robert De Vries' team and added:
 *    - working real DMA
 *    - Falcon support (untested yet!)   ++bjoern fixed and now it works
 *    - lots of extensions and bug fixes.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive
 * for more details.
 *
 */

17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
/*
 * Notes for Falcon SCSI DMA
 *
 * The 5380 device is one of several that all share the DMA chip. Hence
 * "locking" and "unlocking" access to this chip is required.
 *
 * Two possible schemes for ST DMA acquisition by atari_scsi are:
 * 1) The lock is taken for each command separately (i.e. can_queue == 1).
 * 2) The lock is taken when the first command arrives and released
 * when the last command is finished (i.e. can_queue > 1).
 *
 * The first alternative limits SCSI bus utilization, since interleaving
 * commands is not possible. The second gives better performance but is
 * unfair to other drivers needing to use the ST DMA chip. In order to
 * allow the IDE and floppy drivers equal access to the ST DMA chip
 * the default is can_queue == 1.
 */
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37 38 39 40 41

#include <linux/module.h>
#include <linux/types.h>
#include <linux/blkdev.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/nvram.h>
#include <linux/bitops.h>
42
#include <linux/wait.h>
43
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed
44 45 46 47 48 49 50 51

#include <asm/setup.h>
#include <asm/atarihw.h>
#include <asm/atariints.h>
#include <asm/atari_stdma.h>
#include <asm/atari_stram.h>
#include <asm/io.h>

52 53
#include <scsi/scsi_host.h>

54 55
#define DMA_MIN_SIZE                    32

Finn Thain's avatar
Finn Thain committed
56 57 58 59
/* Definitions for the core NCR5380 driver. */

#define NCR5380_implementation_fields   /* none */

60 61 62
static u8 (*atari_scsi_reg_read)(unsigned int);
static void (*atari_scsi_reg_write)(unsigned int, u8);

Finn Thain's avatar
Finn Thain committed
63 64 65 66 67 68 69
#define NCR5380_read(reg)               atari_scsi_reg_read(reg)
#define NCR5380_write(reg, value)       atari_scsi_reg_write(reg, value)

#define NCR5380_queue_command           atari_scsi_queue_command
#define NCR5380_abort                   atari_scsi_abort
#define NCR5380_info                    atari_scsi_info

70 71 72 73
#define NCR5380_dma_xfer_len            atari_scsi_dma_xfer_len
#define NCR5380_dma_recv_setup          atari_scsi_dma_recv_setup
#define NCR5380_dma_send_setup          atari_scsi_dma_send_setup
#define NCR5380_dma_residual            atari_scsi_dma_residual
Finn Thain's avatar
Finn Thain committed
74

75
#define NCR5380_acquire_dma_irq(instance)      falcon_get_lock(instance)
76 77
#define NCR5380_release_dma_irq(instance)      falcon_release_lock()

78
#include "NCR5380.h"
Linus Torvalds's avatar
Linus Torvalds committed
79

Finn Thain's avatar
Finn Thain committed
80

Linus Torvalds's avatar
Linus Torvalds committed
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
#define	IS_A_TT()	ATARIHW_PRESENT(TT_SCSI)

#define	SCSI_DMA_WRITE_P(elt,val)				\
	do {							\
		unsigned long v = val;				\
		tt_scsi_dma.elt##_lo = v & 0xff;		\
		v >>= 8;					\
		tt_scsi_dma.elt##_lmd = v & 0xff;		\
		v >>= 8;					\
		tt_scsi_dma.elt##_hmd = v & 0xff;		\
		v >>= 8;					\
		tt_scsi_dma.elt##_hi = v & 0xff;		\
	} while(0)

#define	SCSI_DMA_READ_P(elt)					\
	(((((((unsigned long)tt_scsi_dma.elt##_hi << 8) |	\
	     (unsigned long)tt_scsi_dma.elt##_hmd) << 8) |	\
	   (unsigned long)tt_scsi_dma.elt##_lmd) << 8) |	\
	 (unsigned long)tt_scsi_dma.elt##_lo)


static inline void SCSI_DMA_SETADR(unsigned long adr)
{
	st_dma.dma_lo = (unsigned char)adr;
	MFPDELAY();
	adr >>= 8;
	st_dma.dma_md = (unsigned char)adr;
	MFPDELAY();
	adr >>= 8;
	st_dma.dma_hi = (unsigned char)adr;
	MFPDELAY();
}

static inline unsigned long SCSI_DMA_GETADR(void)
{
	unsigned long adr;
	adr = st_dma.dma_lo;
	MFPDELAY();
	adr |= (st_dma.dma_md & 0xff) << 8;
	MFPDELAY();
	adr |= (st_dma.dma_hi & 0xff) << 16;
	MFPDELAY();
	return adr;
}

126
static void atari_scsi_fetch_restbytes(void);
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130

static unsigned long	atari_dma_residual, atari_dma_startaddr;
static short		atari_dma_active;
/* pointer to the dribble buffer */
131
static char		*atari_dma_buffer;
Linus Torvalds's avatar
Linus Torvalds committed
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
/* precalculated physical address of the dribble buffer */
static unsigned long	atari_dma_phys_buffer;
/* != 0 tells the Falcon int handler to copy data from the dribble buffer */
static char		*atari_dma_orig_addr;
/* size of the dribble buffer; 4k seems enough, since the Falcon cannot use
 * scatter-gather anyway, so most transfers are 1024 byte only. In the rare
 * cases where requests to physical contiguous buffers have been merged, this
 * request is <= 4k (one page). So I don't think we have to split transfers
 * just due to this buffer size...
 */
#define	STRAM_BUFFER_SIZE	(4096)
/* mask for address bits that can't be used with the ST-DMA */
static unsigned long	atari_dma_stram_mask;
#define STRAM_ADDR(a)	(((a) & atari_dma_stram_mask) == 0)

static int setup_can_queue = -1;
Rusty Russell's avatar
Rusty Russell committed
148
module_param(setup_can_queue, int, 0);
Linus Torvalds's avatar
Linus Torvalds committed
149
static int setup_cmd_per_lun = -1;
Rusty Russell's avatar
Rusty Russell committed
150
module_param(setup_cmd_per_lun, int, 0);
Linus Torvalds's avatar
Linus Torvalds committed
151
static int setup_sg_tablesize = -1;
Rusty Russell's avatar
Rusty Russell committed
152
module_param(setup_sg_tablesize, int, 0);
Linus Torvalds's avatar
Linus Torvalds committed
153
static int setup_hostid = -1;
Rusty Russell's avatar
Rusty Russell committed
154
module_param(setup_hostid, int, 0);
155 156
static int setup_toshiba_delay = -1;
module_param(setup_toshiba_delay, int, 0);
Linus Torvalds's avatar
Linus Torvalds committed
157 158


159
static int scsi_dma_is_ignored_buserr(unsigned char dma_stat)
Linus Torvalds's avatar
Linus Torvalds committed
160 161
{
	int i;
162
	unsigned long addr = SCSI_DMA_READ_P(dma_addr), end_addr;
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165 166 167 168 169

	if (dma_stat & 0x01) {

		/* A bus error happens when DMA-ing from the last page of a
		 * physical memory chunk (DMA prefetch!), but that doesn't hurt.
		 * Check for this case:
		 */
170 171 172

		for (i = 0; i < m68k_num_memory; ++i) {
			end_addr = m68k_memory[i].addr + m68k_memory[i].size;
Linus Torvalds's avatar
Linus Torvalds committed
173
			if (end_addr <= addr && addr <= end_addr + 4)
174
				return 1;
Linus Torvalds's avatar
Linus Torvalds committed
175 176
		}
	}
177
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180
}


181
static irqreturn_t scsi_tt_intr(int irq, void *dev)
Linus Torvalds's avatar
Linus Torvalds committed
182
{
183 184
	struct Scsi_Host *instance = dev;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188
	int dma_stat;

	dma_stat = tt_scsi_dma.dma_ctrl;

189 190
	dsprintk(NDEBUG_INTR, instance, "NCR5380 interrupt, DMA status = %02x\n",
	         dma_stat & 0xff);
Linus Torvalds's avatar
Linus Torvalds committed
191 192 193 194 195

	/* Look if it was the DMA that has interrupted: First possibility
	 * is that a bus error occurred...
	 */
	if (dma_stat & 0x80) {
196
		if (!scsi_dma_is_ignored_buserr(dma_stat)) {
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
			printk(KERN_ERR "SCSI DMA caused bus error near 0x%08lx\n",
			       SCSI_DMA_READ_P(dma_addr));
			printk(KERN_CRIT "SCSI DMA bus error -- bad DMA programming!");
		}
	}

	/* If the DMA is active but not finished, we have the case
	 * that some other 5380 interrupt occurred within the DMA transfer.
	 * This means we have residual bytes, if the desired end address
	 * is not yet reached. Maybe we have to fetch some bytes from the
	 * rest data register, too. The residual must be calculated from
	 * the address pointer, not the counter register, because only the
	 * addr reg counts bytes not yet written and pending in the rest
	 * data reg!
	 */
	if ((dma_stat & 0x02) && !(dma_stat & 0x40)) {
213 214
		atari_dma_residual = hostdata->dma_len -
			(SCSI_DMA_READ_P(dma_addr) - atari_dma_startaddr);
Linus Torvalds's avatar
Linus Torvalds committed
215

Finn Thain's avatar
Finn Thain committed
216
		dprintk(NDEBUG_DMA, "SCSI DMA: There are %ld residual bytes.\n",
Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221
			   atari_dma_residual);

		if ((signed int)atari_dma_residual < 0)
			atari_dma_residual = 0;
		if ((dma_stat & 1) == 0) {
222 223 224 225
			/*
			 * After read operations, we maybe have to
			 * transport some rest bytes
			 */
Linus Torvalds's avatar
Linus Torvalds committed
226
			atari_scsi_fetch_restbytes();
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
		} else {
			/*
			 * There seems to be a nasty bug in some SCSI-DMA/NCR
			 * combinations: If a target disconnects while a write
			 * operation is going on, the address register of the
			 * DMA may be a few bytes farer than it actually read.
			 * This is probably due to DMA prefetching and a delay
			 * between DMA and NCR.  Experiments showed that the
			 * dma_addr is 9 bytes to high, but this could vary.
			 * The problem is, that the residual is thus calculated
			 * wrong and the next transfer will start behind where
			 * it should.  So we round up the residual to the next
			 * multiple of a sector size, if it isn't already a
			 * multiple and the originally expected transfer size
			 * was.  The latter condition is there to ensure that
			 * the correction is taken only for "real" data
			 * transfers and not for, e.g., the parameters of some
			 * other command.  These shouldn't disconnect anyway.
			 */
Linus Torvalds's avatar
Linus Torvalds committed
246
			if (atari_dma_residual & 0x1ff) {
Finn Thain's avatar
Finn Thain committed
247
				dprintk(NDEBUG_DMA, "SCSI DMA: DMA bug corrected, "
Linus Torvalds's avatar
Linus Torvalds committed
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
					   "difference %ld bytes\n",
					   512 - (atari_dma_residual & 0x1ff));
				atari_dma_residual = (atari_dma_residual + 511) & ~0x1ff;
			}
		}
		tt_scsi_dma.dma_ctrl = 0;
	}

	/* If the DMA is finished, fetch the rest bytes and turn it off */
	if (dma_stat & 0x40) {
		atari_dma_residual = 0;
		if ((dma_stat & 1) == 0)
			atari_scsi_fetch_restbytes();
		tt_scsi_dma.dma_ctrl = 0;
	}

264
	NCR5380_intr(irq, dev);
Linus Torvalds's avatar
Linus Torvalds committed
265 266 267 268 269

	return IRQ_HANDLED;
}


270
static irqreturn_t scsi_falcon_intr(int irq, void *dev)
Linus Torvalds's avatar
Linus Torvalds committed
271
{
272 273
	struct Scsi_Host *instance = dev;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
	int dma_stat;

	/* Turn off DMA and select sector counter register before
	 * accessing the status register (Atari recommendation!)
	 */
	st_dma.dma_mode_status = 0x90;
	dma_stat = st_dma.dma_mode_status;

	/* Bit 0 indicates some error in the DMA process... don't know
	 * what happened exactly (no further docu).
	 */
	if (!(dma_stat & 0x01)) {
		/* DMA error */
		printk(KERN_CRIT "SCSI DMA error near 0x%08lx!\n", SCSI_DMA_GETADR());
	}

	/* If the DMA was active, but now bit 1 is not clear, it is some
	 * other 5380 interrupt that finishes the DMA transfer. We have to
	 * calculate the number of residual bytes and give a warning if
	 * bytes are stuck in the ST-DMA fifo (there's no way to reach them!)
	 */
	if (atari_dma_active && (dma_stat & 0x02)) {
296
		unsigned long transferred;
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300 301 302 303 304 305 306 307

		transferred = SCSI_DMA_GETADR() - atari_dma_startaddr;
		/* The ST-DMA address is incremented in 2-byte steps, but the
		 * data are written only in 16-byte chunks. If the number of
		 * transferred bytes is not divisible by 16, the remainder is
		 * lost somewhere in outer space.
		 */
		if (transferred & 15)
			printk(KERN_ERR "SCSI DMA error: %ld bytes lost in "
			       "ST-DMA fifo\n", transferred & 15);

308
		atari_dma_residual = hostdata->dma_len - transferred;
Finn Thain's avatar
Finn Thain committed
309
		dprintk(NDEBUG_DMA, "SCSI DMA: There are %ld residual bytes.\n",
Linus Torvalds's avatar
Linus Torvalds committed
310
			   atari_dma_residual);
311
	} else
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317 318 319
		atari_dma_residual = 0;
	atari_dma_active = 0;

	if (atari_dma_orig_addr) {
		/* If the dribble buffer was used on a read operation, copy the DMA-ed
		 * data to the original destination address.
		 */
		memcpy(atari_dma_orig_addr, phys_to_virt(atari_dma_startaddr),
320
		       hostdata->dma_len - atari_dma_residual);
Linus Torvalds's avatar
Linus Torvalds committed
321 322 323
		atari_dma_orig_addr = NULL;
	}

324 325
	NCR5380_intr(irq, dev);

Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329
	return IRQ_HANDLED;
}


330
static void atari_scsi_fetch_restbytes(void)
Linus Torvalds's avatar
Linus Torvalds committed
331 332 333 334 335 336 337 338 339 340 341 342
{
	int nr;
	char *src, *dst;
	unsigned long phys_dst;

	/* fetch rest bytes in the DMA register */
	phys_dst = SCSI_DMA_READ_P(dma_addr);
	nr = phys_dst & 3;
	if (nr) {
		/* there are 'nr' bytes left for the last long address
		   before the DMA pointer */
		phys_dst ^= nr;
Finn Thain's avatar
Finn Thain committed
343
		dprintk(NDEBUG_DMA, "SCSI DMA: there are %d rest bytes for phys addr 0x%08lx",
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346
			   nr, phys_dst);
		/* The content of the DMA pointer is a physical address!  */
		dst = phys_to_virt(phys_dst);
Finn Thain's avatar
Finn Thain committed
347
		dprintk(NDEBUG_DMA, " = virt addr %p\n", dst);
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350 351 352 353 354
		for (src = (char *)&tt_scsi_dma.dma_restdata; nr != 0; --nr)
			*dst++ = *src++;
	}
}


/* This function releases the lock on the DMA chip if there is no
355
 * connected command and the disconnected queue is empty.
Linus Torvalds's avatar
Linus Torvalds committed
356 357
 */

358
static void falcon_release_lock(void)
Linus Torvalds's avatar
Linus Torvalds committed
359
{
360 361 362
	if (IS_A_TT())
		return;

363
	if (stdma_is_locked_by(scsi_falcon_intr))
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366 367 368 369 370
		stdma_release();
}

/* This function manages the locking of the ST-DMA.
 * If the DMA isn't locked already for SCSI, it tries to lock it by
 * calling stdma_lock(). But if the DMA is locked by the SCSI code and
 * there are other drivers waiting for the chip, we do not issue the
371
 * command immediately but tell the SCSI mid-layer to defer.
Linus Torvalds's avatar
Linus Torvalds committed
372 373
 */

374
static int falcon_get_lock(struct Scsi_Host *instance)
Linus Torvalds's avatar
Linus Torvalds committed
375
{
376
	if (IS_A_TT())
377
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
378

379 380 381 382
	if (stdma_is_locked_by(scsi_falcon_intr) &&
	    instance->hostt->can_queue > 1)
		return 1;

383
	if (in_interrupt())
384
		return stdma_try_lock(scsi_falcon_intr, instance);
Linus Torvalds's avatar
Linus Torvalds committed
385

386
	stdma_lock(scsi_falcon_intr, instance);
387
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
388 389
}

390 391
#ifndef MODULE
static int __init atari_scsi_setup(char *str)
Linus Torvalds's avatar
Linus Torvalds committed
392 393 394
{
	/* Format of atascsi parameter is:
	 *   atascsi=<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
395
	 * Defaults depend on TT or Falcon, determined at run time.
Linus Torvalds's avatar
Linus Torvalds committed
396 397
	 * Negative values mean don't change.
	 */
398
	int ints[8];
399 400

	get_options(str, ARRAY_SIZE(ints), ints);
401

Linus Torvalds's avatar
Linus Torvalds committed
402
	if (ints[0] < 1) {
403
		printk("atari_scsi_setup: no arguments!\n");
404
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
405
	}
406 407 408 409 410 411 412 413
	if (ints[0] >= 1)
		setup_can_queue = ints[1];
	if (ints[0] >= 2)
		setup_cmd_per_lun = ints[2];
	if (ints[0] >= 3)
		setup_sg_tablesize = ints[3];
	if (ints[0] >= 4)
		setup_hostid = ints[4];
414
	/* ints[5] (use_tagged_queuing) is ignored */
415 416 417
	/* ints[6] (use_pdma) is ignored */
	if (ints[0] >= 7)
		setup_toshiba_delay = ints[7];
418 419

	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
420 421
}

422 423 424
__setup("atascsi=", atari_scsi_setup);
#endif /* !MODULE */

425
static unsigned long atari_scsi_dma_setup(struct NCR5380_hostdata *hostdata,
426 427
					  void *data, unsigned long count,
					  int dir)
Linus Torvalds's avatar
Linus Torvalds committed
428
{
429
	unsigned long addr = virt_to_phys(data);
Linus Torvalds's avatar
Linus Torvalds committed
430

431 432
	dprintk(NDEBUG_DMA, "scsi%d: setting up dma, data = %p, phys = %lx, count = %ld, dir = %d\n",
	        hostdata->host->host_no, data, addr, count, dir);
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436 437 438 439 440

	if (!IS_A_TT() && !STRAM_ADDR(addr)) {
		/* If we have a non-DMAable address on a Falcon, use the dribble
		 * buffer; 'orig_addr' != 0 in the read case tells the interrupt
		 * handler to copy data from the dribble buffer to the originally
		 * wanted address.
		 */
		if (dir)
441
			memcpy(atari_dma_buffer, data, count);
Linus Torvalds's avatar
Linus Torvalds committed
442 443 444 445
		else
			atari_dma_orig_addr = data;
		addr = atari_dma_phys_buffer;
	}
446

Linus Torvalds's avatar
Linus Torvalds committed
447
	atari_dma_startaddr = addr;	/* Needed for calculating residual later. */
448

Linus Torvalds's avatar
Linus Torvalds committed
449 450 451 452 453
	/* Cache cleanup stuff: On writes, push any dirty cache out before sending
	 * it to the peripheral. (Must be done before DMA setup, since at least
	 * the ST-DMA begins to fill internal buffers right after setup. For
	 * reads, invalidate any cache, may be altered after DMA without CPU
	 * knowledge.
454
	 *
Linus Torvalds's avatar
Linus Torvalds committed
455 456 457
	 * ++roman: For the Medusa, there's no need at all for that cache stuff,
	 * because the hardware does bus snooping (fine!).
	 */
458
	dma_cache_maintenance(addr, count, dir);
Linus Torvalds's avatar
Linus Torvalds committed
459 460 461

	if (IS_A_TT()) {
		tt_scsi_dma.dma_ctrl = dir;
462 463
		SCSI_DMA_WRITE_P(dma_addr, addr);
		SCSI_DMA_WRITE_P(dma_cnt, count);
Linus Torvalds's avatar
Linus Torvalds committed
464
		tt_scsi_dma.dma_ctrl = dir | 2;
465 466
	} else { /* ! IS_A_TT */

Linus Torvalds's avatar
Linus Torvalds committed
467
		/* set address */
468
		SCSI_DMA_SETADR(addr);
Linus Torvalds's avatar
Linus Torvalds committed
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485

		/* toggle direction bit to clear FIFO and set DMA direction */
		dir <<= 8;
		st_dma.dma_mode_status = 0x90 | dir;
		st_dma.dma_mode_status = 0x90 | (dir ^ 0x100);
		st_dma.dma_mode_status = 0x90 | dir;
		udelay(40);
		/* On writes, round up the transfer length to the next multiple of 512
		 * (see also comment at atari_dma_xfer_len()). */
		st_dma.fdc_acces_seccount = (count + (dir ? 511 : 0)) >> 9;
		udelay(40);
		st_dma.dma_mode_status = 0x10 | dir;
		udelay(40);
		/* need not restore value of dir, only boolean value is tested */
		atari_dma_active = 1;
	}

486
	return count;
Linus Torvalds's avatar
Linus Torvalds committed
487 488
}

489 490 491 492 493 494 495 496 497 498 499
static inline int atari_scsi_dma_recv_setup(struct NCR5380_hostdata *hostdata,
                                            unsigned char *data, int count)
{
	return atari_scsi_dma_setup(hostdata, data, count, 0);
}

static inline int atari_scsi_dma_send_setup(struct NCR5380_hostdata *hostdata,
                                            unsigned char *data, int count)
{
	return atari_scsi_dma_setup(hostdata, data, count, 1);
}
Linus Torvalds's avatar
Linus Torvalds committed
500

501
static int atari_scsi_dma_residual(struct NCR5380_hostdata *hostdata)
Linus Torvalds's avatar
Linus Torvalds committed
502
{
503
	return atari_dma_residual;
Linus Torvalds's avatar
Linus Torvalds committed
504 505 506 507 508 509 510
}


#define	CMD_SURELY_BLOCK_MODE	0
#define	CMD_SURELY_BYTE_MODE	1
#define	CMD_MODE_UNKNOWN		2

511
static int falcon_classify_cmd(struct scsi_cmnd *cmd)
Linus Torvalds's avatar
Linus Torvalds committed
512 513
{
	unsigned char opcode = cmd->cmnd[0];
514

Linus Torvalds's avatar
Linus Torvalds committed
515
	if (opcode == READ_DEFECT_DATA || opcode == READ_LONG ||
516 517
	    opcode == READ_BUFFER)
		return CMD_SURELY_BYTE_MODE;
Linus Torvalds's avatar
Linus Torvalds committed
518 519 520 521 522 523 524
	else if (opcode == READ_6 || opcode == READ_10 ||
		 opcode == 0xa8 /* READ_12 */ || opcode == READ_REVERSE ||
		 opcode == RECOVER_BUFFERED_DATA) {
		/* In case of a sequential-access target (tape), special care is
		 * needed here: The transfer is block-mode only if the 'fixed' bit is
		 * set! */
		if (cmd->device->type == TYPE_TAPE && !(cmd->cmnd[1] & 1))
525
			return CMD_SURELY_BYTE_MODE;
Linus Torvalds's avatar
Linus Torvalds committed
526
		else
527 528 529
			return CMD_SURELY_BLOCK_MODE;
	} else
		return CMD_MODE_UNKNOWN;
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532 533 534 535 536 537 538 539 540 541
}


/* This function calculates the number of bytes that can be transferred via
 * DMA. On the TT, this is arbitrary, but on the Falcon we have to use the
 * ST-DMA chip. There are only multiples of 512 bytes possible and max.
 * 255*512 bytes :-( This means also, that defining READ_OVERRUNS is not
 * possible on the Falcon, since that would require to program the DMA for
 * n*512 - atari_read_overrun bytes. But it seems that the Falcon doesn't have
 * the overrun problem, so this question is academic :-)
 */

542 543
static int atari_scsi_dma_xfer_len(struct NCR5380_hostdata *hostdata,
                                   struct scsi_cmnd *cmd)
Linus Torvalds's avatar
Linus Torvalds committed
544
{
545 546
	int wanted_len = cmd->SCp.this_residual;
	int possible_len, limit;
547

548 549 550
	if (wanted_len < DMA_MIN_SIZE)
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
551 552
	if (IS_A_TT())
		/* TT SCSI DMA can transfer arbitrary #bytes */
553
		return wanted_len;
Linus Torvalds's avatar
Linus Torvalds committed
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582

	/* ST DMA chip is stupid -- only multiples of 512 bytes! (and max.
	 * 255*512 bytes, but this should be enough)
	 *
	 * ++roman: Aaargl! Another Falcon-SCSI problem... There are some commands
	 * that return a number of bytes which cannot be known beforehand. In this
	 * case, the given transfer length is an "allocation length". Now it
	 * can happen that this allocation length is a multiple of 512 bytes and
	 * the DMA is used. But if not n*512 bytes really arrive, some input data
	 * will be lost in the ST-DMA's FIFO :-( Thus, we have to distinguish
	 * between commands that do block transfers and those that do byte
	 * transfers. But this isn't easy... there are lots of vendor specific
	 * commands, and the user can issue any command via the
	 * SCSI_IOCTL_SEND_COMMAND.
	 *
	 * The solution: We classify SCSI commands in 1) surely block-mode cmd.s,
	 * 2) surely byte-mode cmd.s and 3) cmd.s with unknown mode. In case 1)
	 * and 3), the thing to do is obvious: allow any number of blocks via DMA
	 * or none. In case 2), we apply some heuristic: Byte mode is assumed if
	 * the transfer (allocation) length is < 1024, hoping that no cmd. not
	 * explicitly known as byte mode have such big allocation lengths...
	 * BTW, all the discussion above applies only to reads. DMA writes are
	 * unproblematic anyways, since the targets aborts the transfer after
	 * receiving a sufficient number of bytes.
	 *
	 * Another point: If the transfer is from/to an non-ST-RAM address, we
	 * use the dribble buffer and thus can do only STRAM_BUFFER_SIZE bytes.
	 */

583
	if (cmd->sc_data_direction == DMA_TO_DEVICE) {
Linus Torvalds's avatar
Linus Torvalds committed
584 585 586 587 588
		/* Write operation can always use the DMA, but the transfer size must
		 * be rounded up to the next multiple of 512 (atari_dma_setup() does
		 * this).
		 */
		possible_len = wanted_len;
589
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
590 591 592 593 594 595 596 597 598
		/* Read operations: if the wanted transfer length is not a multiple of
		 * 512, we cannot use DMA, since the ST-DMA cannot split transfers
		 * (no interrupt on DMA finished!)
		 */
		if (wanted_len & 0x1ff)
			possible_len = 0;
		else {
			/* Now classify the command (see above) and decide whether it is
			 * allowed to do DMA at all */
599 600
			switch (falcon_classify_cmd(cmd)) {
			case CMD_SURELY_BLOCK_MODE:
Linus Torvalds's avatar
Linus Torvalds committed
601 602
				possible_len = wanted_len;
				break;
603
			case CMD_SURELY_BYTE_MODE:
Linus Torvalds's avatar
Linus Torvalds committed
604 605
				possible_len = 0; /* DMA prohibited */
				break;
606 607
			case CMD_MODE_UNKNOWN:
			default:
Linus Torvalds's avatar
Linus Torvalds committed
608 609 610 611 612 613 614
				/* For unknown commands assume block transfers if the transfer
				 * size/allocation length is >= 1024 */
				possible_len = (wanted_len < 1024) ? 0 : wanted_len;
				break;
			}
		}
	}
615

Linus Torvalds's avatar
Linus Torvalds committed
616
	/* Last step: apply the hard limit on DMA transfers */
617
	limit = (atari_dma_buffer && !STRAM_ADDR(virt_to_phys(cmd->SCp.ptr))) ?
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620 621 622
		    STRAM_BUFFER_SIZE : 255*512;
	if (possible_len > limit)
		possible_len = limit;

	if (possible_len != wanted_len)
623 624
		dprintk(NDEBUG_DMA, "DMA transfer now %d bytes instead of %d\n",
		        possible_len, wanted_len);
Linus Torvalds's avatar
Linus Torvalds committed
625

626
	return possible_len;
Linus Torvalds's avatar
Linus Torvalds committed
627 628 629 630 631 632 633 634 635 636
}


/* NCR5380 register access functions
 *
 * There are separate functions for TT and Falcon, because the access
 * methods are quite different. The calling macros NCR5380_read and
 * NCR5380_write call these functions via function pointers.
 */

637
static u8 atari_scsi_tt_reg_read(unsigned int reg)
Linus Torvalds's avatar
Linus Torvalds committed
638
{
639
	return tt_scsi_regp[reg * 2];
Linus Torvalds's avatar
Linus Torvalds committed
640 641
}

642
static void atari_scsi_tt_reg_write(unsigned int reg, u8 value)
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646
{
	tt_scsi_regp[reg * 2] = value;
}

647
static u8 atari_scsi_falcon_reg_read(unsigned int reg)
Linus Torvalds's avatar
Linus Torvalds committed
648
{
649
	unsigned long flags;
650
	u8 result;
651 652 653 654

	reg += 0x88;
	local_irq_save(flags);
	dma_wd.dma_mode_status = (u_short)reg;
655
	result = (u8)dma_wd.fdc_acces_seccount;
656 657
	local_irq_restore(flags);
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
658 659
}

660
static void atari_scsi_falcon_reg_write(unsigned int reg, u8 value)
Linus Torvalds's avatar
Linus Torvalds committed
661
{
662 663 664 665 666
	unsigned long flags;

	reg += 0x88;
	local_irq_save(flags);
	dma_wd.dma_mode_status = (u_short)reg;
Linus Torvalds's avatar
Linus Torvalds committed
667
	dma_wd.fdc_acces_seccount = (u_short)value;
668
	local_irq_restore(flags);
Linus Torvalds's avatar
Linus Torvalds committed
669 670 671
}


672
#include "NCR5380.c"
Linus Torvalds's avatar
Linus Torvalds committed
673

674 675 676
static int atari_scsi_bus_reset(struct scsi_cmnd *cmd)
{
	int rv;
677 678 679
	unsigned long flags;

	local_irq_save(flags);
680

681 682
	/* Abort a maybe active DMA transfer */
	if (IS_A_TT()) {
683 684
		tt_scsi_dma.dma_ctrl = 0;
	} else {
685 686
		if (stdma_is_locked_by(scsi_falcon_intr))
			st_dma.dma_mode_status = 0x90;
687 688 689 690 691 692
		atari_dma_active = 0;
		atari_dma_orig_addr = NULL;
	}

	rv = NCR5380_bus_reset(cmd);

693 694 695 696 697
	/* The 5380 raises its IRQ line while _RST is active but the ST DMA
	 * "lock" has been released so this interrupt may end up handled by
	 * floppy or IDE driver (if one of them holds the lock). The NCR5380
	 * interrupt flag has been cleared already.
	 */
698

699
	local_irq_restore(flags);
700 701 702 703

	return rv;
}

704 705 706 707 708 709
#define DRV_MODULE_NAME         "atari_scsi"
#define PFX                     DRV_MODULE_NAME ": "

static struct scsi_host_template atari_scsi_template = {
	.module			= THIS_MODULE,
	.proc_name		= DRV_MODULE_NAME,
Linus Torvalds's avatar
Linus Torvalds committed
710 711 712 713 714
	.name			= "Atari native SCSI",
	.info			= atari_scsi_info,
	.queuecommand		= atari_scsi_queue_command,
	.eh_abort_handler	= atari_scsi_abort,
	.eh_bus_reset_handler	= atari_scsi_bus_reset,
715
	.this_id		= 7,
716
	.cmd_per_lun		= 2,
717
	.use_clustering		= DISABLE_CLUSTERING,
718
	.cmd_size		= NCR5380_CMD_SIZE,
Linus Torvalds's avatar
Linus Torvalds committed
719 720
};

721 722 723 724 725
static int __init atari_scsi_probe(struct platform_device *pdev)
{
	struct Scsi_Host *instance;
	int error;
	struct resource *irq;
726
	int host_flags = 0;
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743

	irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!irq)
		return -ENODEV;

	if (ATARIHW_PRESENT(TT_SCSI)) {
		atari_scsi_reg_read  = atari_scsi_tt_reg_read;
		atari_scsi_reg_write = atari_scsi_tt_reg_write;
	} else {
		atari_scsi_reg_read  = atari_scsi_falcon_reg_read;
		atari_scsi_reg_write = atari_scsi_falcon_reg_write;
	}

	if (ATARIHW_PRESENT(TT_SCSI)) {
		atari_scsi_template.can_queue    = 16;
		atari_scsi_template.sg_tablesize = SG_ALL;
	} else {
744
		atari_scsi_template.can_queue    = 1;
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
		atari_scsi_template.sg_tablesize = SG_NONE;
	}

	if (setup_can_queue > 0)
		atari_scsi_template.can_queue = setup_can_queue;

	if (setup_cmd_per_lun > 0)
		atari_scsi_template.cmd_per_lun = setup_cmd_per_lun;

	/* Leave sg_tablesize at 0 on a Falcon! */
	if (ATARIHW_PRESENT(TT_SCSI) && setup_sg_tablesize >= 0)
		atari_scsi_template.sg_tablesize = setup_sg_tablesize;

	if (setup_hostid >= 0) {
		atari_scsi_template.this_id = setup_hostid & 7;
	} else {
		/* Test if a host id is set in the NVRam */
		if (ATARIHW_PRESENT(TT_CLK) && nvram_check_checksum()) {
763
			unsigned char b = nvram_read_byte(16);
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785

			/* Arbitration enabled? (for TOS)
			 * If yes, use configured host ID
			 */
			if (b & 0x80)
				atari_scsi_template.this_id = b & 7;
		}
	}

	/* If running on a Falcon and if there's TT-Ram (i.e., more than one
	 * memory block, since there's always ST-Ram in a Falcon), then
	 * allocate a STRAM_BUFFER_SIZE byte dribble buffer for transfers
	 * from/to alternative Ram.
	 */
	if (ATARIHW_PRESENT(ST_SCSI) && !ATARIHW_PRESENT(EXTD_DMA) &&
	    m68k_num_memory > 1) {
		atari_dma_buffer = atari_stram_alloc(STRAM_BUFFER_SIZE, "SCSI");
		if (!atari_dma_buffer) {
			pr_err(PFX "can't allocate ST-RAM double buffer\n");
			return -ENOMEM;
		}
		atari_dma_phys_buffer = atari_stram_to_phys(atari_dma_buffer);
786
		atari_dma_orig_addr = NULL;
787 788 789 790 791 792 793 794 795 796 797
	}

	instance = scsi_host_alloc(&atari_scsi_template,
	                           sizeof(struct NCR5380_hostdata));
	if (!instance) {
		error = -ENOMEM;
		goto fail_alloc;
	}

	instance->irq = irq->start;

798
	host_flags |= IS_A_TT() ? 0 : FLAG_LATE_DMA_SETUP;
799
	host_flags |= setup_toshiba_delay > 0 ? FLAG_TOSHIBA_DELAY : 0;
800

801 802 803
	error = NCR5380_init(instance, host_flags);
	if (error)
		goto fail_init;
804 805 806 807 808 809 810 811 812 813

	if (IS_A_TT()) {
		error = request_irq(instance->irq, scsi_tt_intr, 0,
		                    "NCR5380", instance);
		if (error) {
			pr_err(PFX "request irq %d failed, aborting\n",
			       instance->irq);
			goto fail_irq;
		}
		tt_mfp.active_edge |= 0x80;	/* SCSI int on L->H */
814

815 816 817 818 819 820 821 822 823 824 825
		tt_scsi_dma.dma_ctrl = 0;
		atari_dma_residual = 0;

		/* While the read overruns (described by Drew Eckhardt in
		 * NCR5380.c) never happened on TTs, they do in fact on the
		 * Medusa (This was the cause why SCSI didn't work right for
		 * so long there.) Since handling the overruns slows down
		 * a bit, I turned the #ifdef's into a runtime condition.
		 *
		 * In principle it should be sufficient to do max. 1 byte with
		 * PIO, but there is another problem on the Medusa with the DMA
826
		 * rest data register. So read_overruns is currently set
827 828 829
		 * to 4 to avoid having transfers that aren't a multiple of 4.
		 * If the rest data bug is fixed, this can be lowered to 1.
		 */
830 831 832 833 834 835
		if (MACH_IS_MEDUSA) {
			struct NCR5380_hostdata *hostdata =
				shost_priv(instance);

			hostdata->read_overruns = 4;
		}
836 837 838 839 840 841 842 843 844 845
	} else {
		/* Nothing to do for the interrupt: the ST-DMA is initialized
		 * already.
		 */
		atari_dma_residual = 0;
		atari_dma_active = 0;
		atari_dma_stram_mask = (ATARIHW_PRESENT(EXTD_DMA) ? 0x00000000
					: 0xff000000);
	}

846 847
	NCR5380_maybe_reset_bus(instance);

848 849 850 851 852 853 854 855 856 857 858 859 860 861
	error = scsi_add_host(instance, NULL);
	if (error)
		goto fail_host;

	platform_set_drvdata(pdev, instance);

	scsi_scan_host(instance);
	return 0;

fail_host:
	if (IS_A_TT())
		free_irq(instance->irq, instance);
fail_irq:
	NCR5380_exit(instance);
862
fail_init:
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
	scsi_host_put(instance);
fail_alloc:
	if (atari_dma_buffer)
		atari_stram_free(atari_dma_buffer);
	return error;
}

static int __exit atari_scsi_remove(struct platform_device *pdev)
{
	struct Scsi_Host *instance = platform_get_drvdata(pdev);

	scsi_remove_host(instance);
	if (IS_A_TT())
		free_irq(instance->irq, instance);
	NCR5380_exit(instance);
	scsi_host_put(instance);
	if (atari_dma_buffer)
		atari_stram_free(atari_dma_buffer);
	return 0;
}

static struct platform_driver atari_scsi_driver = {
	.remove = __exit_p(atari_scsi_remove),
	.driver = {
		.name	= DRV_MODULE_NAME,
	},
};
Linus Torvalds's avatar
Linus Torvalds committed
890

891
module_platform_driver_probe(atari_scsi_driver, atari_scsi_probe);
Linus Torvalds's avatar
Linus Torvalds committed
892

893
MODULE_ALIAS("platform:" DRV_MODULE_NAME);
Linus Torvalds's avatar
Linus Torvalds committed
894
MODULE_LICENSE("GPL");