summaryrefslogtreecommitdiff
path: root/src/stream/ide_stream.c
blob: d05c6aab917094140c3394a27e4863fb1f157690 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
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
#include <console/console.h>
#include <stdlib.h>
#include <stddef.h>
#include <stream/read_bytes.h>
#include <delay.h>
#include <string.h>

/* read a sector or a partial sector */
extern int ide_read_sector(int drive, void * buffer, unsigned int block, int byte_offset, 
	int n_bytes);
extern int ide_init(void);

static unsigned long offset;
int stream_init(void)
{
	int i,res;

        printk_debug ("Trying polled ide\n");
        printk_debug ("Waiting for ide disks to spin up\n");
        printk_notice ("This is a hard coded delay and longer than necessary.\n");
	for (i = 0; i < 2; i++) {
		printk_notice (".");
		delay(1);
	}
	printk_info ("\n");

#ifdef ONE_TRACK
	offset = (ONE_TRACK*512);
#elif defined(IDE_OFFSET)
	offset = IDE_OFFSET;
#else
	offset = 0x7e00;
#endif
	res = ide_init();
	delay(1);
	return res;
}

void stream_fini(void)
{
	return;
}

#ifdef IDE_SWAB
/* from string/swab.c */
void
swab (const char *from, char *to, int n)
{
	n &= ~1;
	while (n > 1)
	{
		const char b0 = from[--n], b1 = from[--n];
		to[n] = b0;
		to[n + 1] = b1;
	}
}
#endif

static unsigned char buffer[512];
static unsigned int block_num = 0;
static unsigned int first_fill = 1;
#ifndef IDE_BOOT_DRIVE
#define IDE_BOOT_DRIVE 0
#endif
static byte_offset_t ide_read(void *vdest, byte_offset_t offset, byte_offset_t count)
{
	byte_offset_t bytes = 0;
	unsigned char *dest = vdest;

	//printk_debug("ide_read count = %x\n", count);
	while (bytes < count) {
		unsigned int byte_offset, len;

		/* The block is not cached in memory or frist time called */
		if (block_num != offset / 512 || first_fill) {
			block_num  = offset / 512;
			printk_notice (".");
			ide_read_sector(IDE_BOOT_DRIVE, buffer, block_num,
					0, 512);
			first_fill = 0;
		}

		byte_offset = offset % 512;
		len = 512 - byte_offset;
		if (len > (count - bytes)) {
			len = (count - bytes);
		}

#ifdef IDE_SWAB
		swab(buffer + byte_offset, dest, len);
#else
		memcpy(dest, buffer + byte_offset, len);
#endif

		offset += len;
		bytes += len;
		dest += len;

	}
	return bytes;
}

byte_offset_t stream_read(void *vdest, byte_offset_t count)
{
	byte_offset_t len;

	len = ide_read(vdest, offset, count);
	if (len > 0) {
		offset += len;
	}

	return len;
}

byte_offset_t stream_skip(byte_offset_t count)
{
	offset += count;
	return count;
}