cebix/cwcbm/writecbm.c

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

#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;

        // Seek to track, set speed zone
        seek_to(drive, track);

        // 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 track, ret = 0;
        FILE *f;

        // Parse arguments
        parse_args(argc, argv);

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

        // Obtain access to I/O ports
        ioport_access();

        // Init Catweasel
        catweasel_init_controller(&c);

        // Start drive
        start_drive(drive_num);

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

                // 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_num, track))
                                break;
                }

        } else {

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

        // Stop drive
        stop_drive(drive_num);

        // Free Catweasel
        catweasel_free_controller(&c);

        // Close input file
        fclose(f);

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