cebix/cwcbm/writecbm.c

/*
 *  writecbm.c - Write CBM disk from image file with the Catweasel controller
 *
 *  Written in 2003 by Christian Bauer <Christian.Bauer@uni-mainz.de>
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <errno.h>
#include <sys/io.h>

#include "catweasel.h"
#include "common.h"


/* Number of sync GCR bytes */
#define SYNC_LENGTH 5

/* Number of header gap GCR bytes */
#define HEADER_GAP_LENGTH 9

/* Number of inter-sector gap GCR bytes */
#define GAP_LENGTH 4


/* Write byte to Catweasel buffer */
#define PUT(x) put_precomp(x)

static void put_precomp(unsigned char x)
{
        static int previous = 0, adjust = 0;
        int newadjust = (previous > 1) - (x > 1);

        outb(0x80 - clock_table[previous] - adjust - newadjust, c.io_mem);
        previous = x;
        adjust = -newadjust;
}


/*
 *  We take advantage of the fact that all GCR nybbles (5 bits) end in "x1"
 *  or "10", so there is either one or no "0"-bit before the next nybble.
 *  This table stores the sequence of distances between "1"-bits for each
 *  possible 4-bit value. The end marker is -1 if the trailing bit is 1,
 *  and -2 if it is 0. In the latter case, the first distance value for
 *  the next nybble must be incremented by 1.
 */

static const int bin2gcr[16 * 5] = {
        2, 2, -2, 0, 0, // 01010
        2, 2, 1, -1, 0, // 01011
        1, 3, -2, 0, 0, // 10010
        1, 3, 1, -1, 0, // 10011
        2, 1, 1, -2, 0, // 01110
        2, 1, 1, 1, -1, // 01111
        1, 2, 1, -2, 0, // 10110
        1, 2, 1, 1, -1, // 10111
        2, 3, -1, 0, 0, // 01001
        1, 1, 3, -1, 0, // 11001
        1, 1, 2, -2, 0, // 11010
        1, 1, 2, 1, -1, // 11011
        2, 1, 2, -1, 0, // 01101
        1, 1, 1, 2, -1, // 11101
        1, 1, 1, 1, -2, // 11110
        1, 2, 2, -1, 0  // 10101
};

/* Encode one nybble */
static void encode_nybble(int x, int *trailing_zero)
{
        const int *gcr = bin2gcr + x * 5;
        int v;

        do {
                v = *gcr++;
                if (v > 0)
                        PUT(v + *trailing_zero);
                *trailing_zero = (v == -2) ? 1 : 0;
        } while (v > 0);
}

/* Encode GCR data from specified buffer */
static void encode_gcr(const unsigned char *p, int num)
{
        int trailing_zero = 0;

        while (num > 0) {

                // Read byte from buffer
                unsigned char x = *p++;
                num--;

                // Encode upper and lower nybbles
                encode_nybble(x >> 4, &trailing_zero);
                encode_nybble(x & 0x0f, &trailing_zero);
        }
}


/* Encode sector header */
static void encode_header(int track, int sector, unsigned char id1, unsigned char id2)
{
        unsigned char header[8];
        int i;

        // Set up header data
        header[0] = 0x08;
        header[2] = sector;
        header[3] = track;
        header[4] = id2;
        header[5] = id1;
        header[6] = 0x0f;
        header[7] = 0x0f;
        header[1] = header[2] ^ header[3] ^ header[4] ^ header[5];

        // Write sync
        for (i = 0; i < SYNC_LENGTH * 8; i++)
                PUT(1);

        // Write header
        encode_gcr(header, 8);

        // Write header gap
        for (i = 0; i < HEADER_GAP_LENGTH * 4; i++)
                PUT(2);
}


/* Encode sector data from specified buffer */
static void encode_data(int track, const unsigned char *p)
{
        unsigned char tmp[SECTOR_SIZE + 4];
        int i, sum = 0;

        // Set up sector data
        tmp[0] = 0x07;
        memcpy(tmp + 1, p, SECTOR_SIZE);
        for (i = 0; i < SECTOR_SIZE; i++)
                sum ^= p[i];
        tmp[SECTOR_SIZE + 1] = sum;
        tmp[SECTOR_SIZE + 2] = 0;
        tmp[SECTOR_SIZE + 3] = 0;

        // Write sync
        for (i = 0; i < SYNC_LENGTH * 8; i++)
                PUT(1);

        // Write data
        encode_gcr(tmp, SECTOR_SIZE + 4);

        // Write inter-sector gap
        for (i = 0; i < GAP_LENGTH * 4; i++)
                PUT(2);
}


/* Encode sectors from track_buf */
static void encode_sectors(int track)
{
        int sector;

        // Encode each sector
        for (sector = 0; sector < num_sectors[track]; sector++) {
                encode_header(track, sector, 0x41, 0x41);
                encode_data(track, track_buf + SECTOR_SIZE * sector);
        }
}


/* Write one track from track_buf, returns 0 on error */
static int write_track(int drive, int track)
{
        int i;

        // Set speed zone and tables
        set_zone(track);

        // Seek to track
        catweasel_seek(c.drives + drive, (track - 1) * (double_step + 1));
        msdelay(20);

        // Write empty track
        inb(c.iobase + 1);
        for (i = 0; i < bps[std_speed[track]] * 60 / drive_rpm; i++)
                PUT(2);
        outb(0xff, c.io_mem);
        if (!catweasel_write(c.drives + drive, 0, 1, 1100 * 60 / drive_rpm)) {
                fprintf(stderr, "Error writing track %d\n", track);
                return 0;
        }

        // Reset buffer pointer
        inb(c.iobase + 1);

        // Encode all sectors
        encode_sectors(track);

        // Write to disk (1 revolution + 10%)
        outb(0xff, c.io_mem);
        if (!catweasel_write(c.drives + drive, 0, 1, 1100 * 60 / drive_rpm)) {
                fprintf(stderr, "Error writing track %d\n", track);
                return 0;
        }

        return 1;
}


int main(int argc, char **argv)
{
        int port, drive, track, ret = 0;
        FILE *f;

        // Parse arguments
        if (argc != 4) {
                fprintf(stderr, "Usage: %s <port> <drive> <file>\n", argv[0]);
                return 1;
        }

        port = strtol(argv[1], NULL, 16);
        drive = atoi(argv[2]) & 1;

        // Open input file
        f = fopen(argv[3], "rb");
        if (f == NULL) {
                fprintf(stderr, "Can't open %s for reading: %s\n", argv[3], strerror(errno));
                return 1;
        }

        // Obtain access to I/O ports
        if (ioperm(port, 8, 1) == -1) {
                fprintf(stderr, "No access to I/O ports\n");
                return 1;
        }
        setuid(getuid());

        // Init Catweasel
        memset(&c, 0, sizeof(c));
        c.iobase = port;
        c.msdelay = msdelay;
        c.type = CATWEASEL_TYPE_MK1;
        catweasel_init_controller(&c);

        // Start drive
        catweasel_select(&c, drive == 0, drive == 1);
        catweasel_set_motor(c.drives + drive, 1);
        msdelay(500);
        catweasel_seek(c.drives + drive, 0);
        msdelay(20);

        // Disk write protected?
        if (!catweasel_write_protected(c.drives + drive)) {

                // No, write all tracks
                for (track = 1; track <= NUM_TRACKS; track++) {
                        printf("Track %d...\n", track);
                        if (fread(track_buf, 256, num_sectors[track], f) != num_sectors[track]) {
                                fprintf(stderr, "Error reading input file\n");
                                break;
                        }
                        if (!write_track(drive, track))
                                break;
                }

        } else {

                fprintf(stderr, "Error: disk write-protected\n");
                ret = 1;
        }

        // Stop drive
        catweasel_set_motor(c.drives + drive, 0);
        catweasel_select(&c, 0, 0);
        catweasel_free_controller(&c);

        // Close input file
        fclose(f);

        return ret;
}
Revision:	1.1.1.1 (vendor branch)
Committed:	2004-01-07T15:37:45Z (20 years, 10 months ago) by cebix
Content type:	text/plain
Branch:	cebix
CVS Tags:	start
Changes since 1.1:	+0 -0 lines
Log Message:	imported sources
#	Content
1	/*
2	* writecbm.c - Write CBM disk from image file with the Catweasel controller
3	*
4	* Written in 2003 by Christian Bauer <Christian.Bauer@uni-mainz.de>
5	*/
6
7	#include <stdio.h>
8	#include <stdlib.h>
9	#include <string.h>
10	#include <time.h>
11	#include <unistd.h>
12	#include <errno.h>
13	#include <sys/io.h>
14
15	#include "catweasel.h"
16	#include "common.h"
17
18
19	/* Number of sync GCR bytes */
20	#define SYNC_LENGTH 5
21
22	/* Number of header gap GCR bytes */
23	#define HEADER_GAP_LENGTH 9
24
25	/* Number of inter-sector gap GCR bytes */
26	#define GAP_LENGTH 4
27
28
29	/* Write byte to Catweasel buffer */
30	#define PUT(x) put_precomp(x)
31
32	static void put_precomp(unsigned char x)
33	{
34	static int previous = 0, adjust = 0;
35	int newadjust = (previous > 1) - (x > 1);
36
37	outb(0x80 - clock_table[previous] - adjust - newadjust, c.io_mem);
38	previous = x;
39	adjust = -newadjust;
40	}
41
42
43	/*
44	* We take advantage of the fact that all GCR nybbles (5 bits) end in "x1"
45	* or "10", so there is either one or no "0"-bit before the next nybble.
46	* This table stores the sequence of distances between "1"-bits for each
47	* possible 4-bit value. The end marker is -1 if the trailing bit is 1,
48	* and -2 if it is 0. In the latter case, the first distance value for
49	* the next nybble must be incremented by 1.
50	*/
51
52	static const int bin2gcr[16 * 5] = {
53	2, 2, -2, 0, 0, // 01010
54	2, 2, 1, -1, 0, // 01011
55	1, 3, -2, 0, 0, // 10010
56	1, 3, 1, -1, 0, // 10011
57	2, 1, 1, -2, 0, // 01110
58	2, 1, 1, 1, -1, // 01111
59	1, 2, 1, -2, 0, // 10110
60	1, 2, 1, 1, -1, // 10111
61	2, 3, -1, 0, 0, // 01001
62	1, 1, 3, -1, 0, // 11001
63	1, 1, 2, -2, 0, // 11010
64	1, 1, 2, 1, -1, // 11011
65	2, 1, 2, -1, 0, // 01101
66	1, 1, 1, 2, -1, // 11101
67	1, 1, 1, 1, -2, // 11110
68	1, 2, 2, -1, 0 // 10101
69	};
70
71	/* Encode one nybble */
72	static void encode_nybble(int x, int *trailing_zero)
73	{
74	const int gcr = bin2gcr + x 5;
75	int v;
76
77	do {
78	v = *gcr++;
79	if (v > 0)
80	PUT(v + *trailing_zero);
81	*trailing_zero = (v == -2) ? 1 : 0;
82	} while (v > 0);
83	}
84
85	/* Encode GCR data from specified buffer */
86	static void encode_gcr(const unsigned char *p, int num)
87	{
88	int trailing_zero = 0;
89
90	while (num > 0) {
91
92	// Read byte from buffer
93	unsigned char x = *p++;
94	num--;
95
96	// Encode upper and lower nybbles
97	encode_nybble(x >> 4, &trailing_zero);
98	encode_nybble(x & 0x0f, &trailing_zero);
99	}
100	}
101
102
103	/* Encode sector header */
104	static void encode_header(int track, int sector, unsigned char id1, unsigned char id2)
105	{
106	unsigned char header[8];
107	int i;
108
109	// Set up header data
110	header[0] = 0x08;
111	header[2] = sector;
112	header[3] = track;
113	header[4] = id2;
114	header[5] = id1;
115	header[6] = 0x0f;
116	header[7] = 0x0f;
117	header[1] = header[2] ^ header[3] ^ header[4] ^ header[5];
118
119	// Write sync
120	for (i = 0; i < SYNC_LENGTH * 8; i++)
121	PUT(1);
122
123	// Write header
124	encode_gcr(header, 8);
125
126	// Write header gap
127	for (i = 0; i < HEADER_GAP_LENGTH * 4; i++)
128	PUT(2);
129	}
130
131
132	/* Encode sector data from specified buffer */
133	static void encode_data(int track, const unsigned char *p)
134	{
135	unsigned char tmp[SECTOR_SIZE + 4];
136	int i, sum = 0;
137
138	// Set up sector data
139	tmp[0] = 0x07;
140	memcpy(tmp + 1, p, SECTOR_SIZE);
141	for (i = 0; i < SECTOR_SIZE; i++)
142	sum ^= p[i];
143	tmp[SECTOR_SIZE + 1] = sum;
144	tmp[SECTOR_SIZE + 2] = 0;
145	tmp[SECTOR_SIZE + 3] = 0;
146
147	// Write sync
148	for (i = 0; i < SYNC_LENGTH * 8; i++)
149	PUT(1);
150
151	// Write data
152	encode_gcr(tmp, SECTOR_SIZE + 4);
153
154	// Write inter-sector gap
155	for (i = 0; i < GAP_LENGTH * 4; i++)
156	PUT(2);
157	}
158
159
160	/* Encode sectors from track_buf */
161	static void encode_sectors(int track)
162	{
163	int sector;
164
165	// Encode each sector
166	for (sector = 0; sector < num_sectors[track]; sector++) {
167	encode_header(track, sector, 0x41, 0x41);
168	encode_data(track, track_buf + SECTOR_SIZE * sector);
169	}
170	}
171
172
173	/* Write one track from track_buf, returns 0 on error */
174	static int write_track(int drive, int track)
175	{
176	int i;
177
178	// Set speed zone and tables
179	set_zone(track);
180
181	// Seek to track
182	catweasel_seek(c.drives + drive, (track - 1) * (double_step + 1));
183	msdelay(20);
184
185	// Write empty track
186	inb(c.iobase + 1);
187	for (i = 0; i < bps[std_speed[track]] * 60 / drive_rpm; i++)
188	PUT(2);
189	outb(0xff, c.io_mem);
190	if (!catweasel_write(c.drives + drive, 0, 1, 1100 * 60 / drive_rpm)) {
191	fprintf(stderr, "Error writing track %d\n", track);
192	return 0;
193	}
194
195	// Reset buffer pointer
196	inb(c.iobase + 1);
197
198	// Encode all sectors
199	encode_sectors(track);
200
201	// Write to disk (1 revolution + 10%)
202	outb(0xff, c.io_mem);
203	if (!catweasel_write(c.drives + drive, 0, 1, 1100 * 60 / drive_rpm)) {
204	fprintf(stderr, "Error writing track %d\n", track);
205	return 0;
206	}
207
208	return 1;
209	}
210
211
212	int main(int argc, char **argv)
213	{
214	int port, drive, track, ret = 0;
215	FILE *f;
216
217	// Parse arguments
218	if (argc != 4) {
219	fprintf(stderr, "Usage: %s <port> <drive> <file>\n", argv[0]);
220	return 1;
221	}
222
223	port = strtol(argv[1], NULL, 16);
224	drive = atoi(argv[2]) & 1;
225
226	// Open input file
227	f = fopen(argv[3], "rb");
228	if (f == NULL) {
229	fprintf(stderr, "Can't open %s for reading: %s\n", argv[3], strerror(errno));
230	return 1;
231	}
232
233	// Obtain access to I/O ports
234	if (ioperm(port, 8, 1) == -1) {
235	fprintf(stderr, "No access to I/O ports\n");
236	return 1;
237	}
238	setuid(getuid());
239
240	// Init Catweasel
241	memset(&c, 0, sizeof(c));
242	c.iobase = port;
243	c.msdelay = msdelay;
244	c.type = CATWEASEL_TYPE_MK1;
245	catweasel_init_controller(&c);
246
247	// Start drive
248	catweasel_select(&c, drive == 0, drive == 1);
249	catweasel_set_motor(c.drives + drive, 1);
250	msdelay(500);
251	catweasel_seek(c.drives + drive, 0);
252	msdelay(20);
253
254	// Disk write protected?
255	if (!catweasel_write_protected(c.drives + drive)) {
256
257	// No, write all tracks
258	for (track = 1; track <= NUM_TRACKS; track++) {
259	printf("Track %d...\n", track);
260	if (fread(track_buf, 256, num_sectors[track], f) != num_sectors[track]) {
261	fprintf(stderr, "Error reading input file\n");
262	break;
263	}
264	if (!write_track(drive, track))
265	break;
266	}
267
268	} else {
269
270	fprintf(stderr, "Error: disk write-protected\n");
271	ret = 1;
272	}
273
274	// Stop drive
275	catweasel_set_motor(c.drives + drive, 0);
276	catweasel_select(&c, 0, 0);
277	catweasel_free_controller(&c);
278
279	// Close input file
280	fclose(f);
281
282	return ret;
283	}