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
Committed:	2004-01-07T15:37:45Z (20 years, 10 months ago) by cebix
Content type:	text/plain
Branch:	MAIN
Branch point for:	cebix
Log Message:	Initial revision
#	User	Rev	Content
1	cebix	1.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			}