← Back to branch summary

~ubuntu-branches/ubuntu/karmic/xmame/karmic

« back to all changes in this revision

Viewing changes to mess/formats/coco_dsk.c

  • Committer: Bazaar Package Importer
  • Author(s): Bruno Barrera C.
  • Date: 2007-02-16 10:06:54 UTC
  • mfrom: (2.1.5 edgy)
  • Revision ID: james.westby@ubuntu.com-20070216100654-iztas2cl47k5j039
Tags: 0.106-2
http://bugs.debian.org/382672
http://bugs.debian.org/396610
http://bugs.debian.org/400011
http://bugs.debian.org/409960
* Added Italian debconf templates translation. (closes: #382672)
* Added German debconf templates translation. (closes: #396610)
* Added Japanese debconf templates translation. (closes: #400011)
* Added Portuguese debconf templates translation. (closes: #409960)

Show diffs side-by-side

added added

removed removed

Lines of Context:
mess/formats/coco_dsk.c
10
10
#include <assert.h>
11
11
#include <time.h>
12
12
 
 
13
#include "osdepend.h"
13
14
#include "formats/coco_dsk.h"
14
15
#include "formats/basicdsk.h"
15
16
#include "utils.h"
16
17
 
17
 
#ifndef MIN
18
 
#define MIN(a,b)                (((a) < (b)) ? (a) : (b))
19
 
#endif
20
 
 
21
 
#ifndef TRUE
22
 
#define TRUE    1
23
 
#endif
24
 
 
25
 
#ifndef FALSE
26
 
#define FALSE   1
27
 
#endif
28
 
 
29
18
/* ----------------------------------------------------------------------- 
30
19
 * JVC (Jeff Vavasour CoCo) format                                         
31
20
 *                                                                         
320
309
        geometry->sector_length = 256;
321
310
        geometry->sectors = (header[0x11] << 8) + header[0x12];
322
311
        geometry->heads = (header[0x10] & 0x01) ? 2 : 1;
 
312
 
 
313
        if (!geometry->sectors)
 
314
                return FLOPPY_ERROR_INVALIDIMAGE;
 
315
 
323
316
        geometry->tracks = total_sectors / geometry->sectors / geometry->heads;
324
317
 
325
318
        if (total_sectors != geometry->tracks * geometry->sectors * geometry->heads)
725
718
        UINT16 idam_offset;
726
719
        UINT16 crc;
727
720
        UINT8 *track_data;
 
721
        void *track_data_v;
728
722
        UINT32 max_track_size;
729
723
        int *sector_map = NULL;
730
724
            
747
741
                goto done;
748
742
        }
749
743
                
750
 
        err = floppy_load_track(floppy, head, track, TRUE, (void **) &track_data, NULL);
 
744
        err = floppy_load_track(floppy, head, track, TRUE, &track_data_v, NULL);
751
745
        if (err)
752
746
                goto done;
 
747
        track_data = (UINT8 *) track_data_v;
753
748
 
754
749
        /* set up sector map */
755
750
        sector_map = malloc(sectors * sizeof(*sector_map));
769
764
                        physical_sector %= sectors;
770
765
                }
771
766
 
772
 
                sector_map[physical_sector] = logical_sector;
 
767
                sector_map[physical_sector] = logical_sector + first_sector_id;
773
768
                physical_sector += interleave + 1;
774
769
                physical_sector %= sectors;
775
770
        }
871
866
        
872
867
        
873
868
 
874
 
static floperr_t coco_dmk_seek_sector_in_track(floppy_image *floppy, int head, int track, int sector, int dirtify, UINT8 **sector_data, UINT32 *sector_length)
 
869
static floperr_t coco_dmk_seek_sector_in_track(floppy_image *floppy, int head, int track, int sector, int sector_is_index, int dirtify, UINT8 **sector_data, UINT32 *sector_length)
875
870
{
876
871
        struct dmk_tag *tag = get_dmk_tag(floppy);
877
872
        floperr_t err;
878
 
        UINT32 idam_offset;
 
873
        UINT32 idam_offset = 0;
879
874
        UINT16 calculated_crc;
880
875
        size_t i;
881
876
        size_t offs;
882
877
        int state;
883
878
        UINT8 *track_data;
 
879
        void *track_data_v;
884
880
        size_t track_length;
885
881
        size_t sec_len;
886
882
 
887
 
        err = floppy_load_track(floppy, head, track, dirtify, (void **) &track_data, &track_length);
 
883
        err = floppy_load_track(floppy, head, track, dirtify, &track_data_v, &track_length);
888
884
        if (err)
889
885
                return err;
 
886
        track_data = (UINT8 *) track_data_v;
890
887
                
891
888
        /* search for matching IDAM */
892
889
        for (i = 0; i < DMK_TOC_LEN; i++)
908
905
 
909
906
                calculated_crc = ccitt_crc16(0xCDB4, &track_data[idam_offset], DMK_IDAM_LENGTH - 2);
910
907
 
911
 
                /* check IDAM integrity and check for matching sector */
912
 
                if ((calculated_crc == dmk_idam_crc(&track_data[idam_offset]))
913
 
                                && (track == dmk_idam_track(&track_data[idam_offset]))
914
 
                                && (head == dmk_idam_side(&track_data[idam_offset]))
915
 
                                && (sector == dmk_idam_sector(&track_data[idam_offset])))
916
 
                        break;
 
908
                if (calculated_crc == dmk_idam_crc(&track_data[idam_offset]))
 
909
                {
 
910
                        if (sector_is_index)
 
911
                        {
 
912
                                /* the sector is indexed; decrement the index and go */
 
913
                                if (sector-- == 0)
 
914
                                        break;
 
915
                        }
 
916
                        else
 
917
                        {
 
918
                                /* check IDAM integrity and check for matching sector */
 
919
                                if ((sector == dmk_idam_sector(&track_data[idam_offset]))
 
920
/*                                      && (track == dmk_idam_track(&track_data[idam_offset]))  */
 
921
/*                                      && (head == dmk_idam_side(&track_data[idam_offset]))    */
 
922
                                        )
 
923
                                        break;
 
924
                        }
 
925
                }
917
926
        }
918
927
 
919
928
        if (i >= DMK_TOC_LEN)
957
966
 
958
967
static floperr_t coco_dmk_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length)
959
968
{
960
 
        return coco_dmk_seek_sector_in_track(floppy, head, track, sector, FALSE, NULL, sector_length);
 
969
        return coco_dmk_seek_sector_in_track(floppy, head, track, sector, FALSE, FALSE, NULL, sector_length);
961
970
}
962
971
 
963
972
 
964
973
 
965
 
static floperr_t coco_dmk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *sector, UINT32 *sector_length)
 
974
static floperr_t coco_dmk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length)
966
975
{
967
976
        floperr_t err;
968
977
        UINT32 idam_offset;
969
978
        const UINT8 *track_data;
 
979
        void *track_data_v;
970
980
 
971
981
        if (sector_index*2 >= DMK_TOC_LEN)
972
982
                return FLOPPY_ERROR_SEEKERROR;
973
983
 
974
 
        err = floppy_load_track(floppy, head, track, FALSE, (void **) &track_data, NULL);
 
984
        err = floppy_load_track(floppy, head, track, FALSE, &track_data_v, NULL);
975
985
        if (err)
976
986
                return err;
 
987
        track_data = (UINT8 *) track_data_v;
977
988
 
978
989
        idam_offset = track_data[sector_index * 2 + 1];
979
990
        idam_offset <<= 8;
983
994
        if (idam_offset == 0)
984
995
                return FLOPPY_ERROR_SEEKERROR;
985
996
 
 
997
        if (cylinder)
 
998
                *cylinder = dmk_idam_track(&track_data[idam_offset]);
 
999
        if (side)
 
1000
                *side = dmk_idam_side(&track_data[idam_offset]);
986
1001
        if (sector)
987
1002
                *sector = dmk_idam_sector(&track_data[idam_offset]);
988
1003
        if (sector_length)
992
1007
 
993
1008
 
994
1009
 
995
 
static floperr_t coco_dmk_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
 
1010
static floperr_t internal_coco_dmk_read_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen)
996
1011
{
997
1012
        floperr_t err;
998
1013
        UINT32 sector_length;
1000
1015
        UINT16 calculated_crc;
1001
1016
        UINT8 *sector_data;
1002
1017
                                
1003
 
        err = coco_dmk_seek_sector_in_track(floppy, head, track, sector, FALSE, &sector_data, &sector_length);
 
1018
        err = coco_dmk_seek_sector_in_track(floppy, head, track, sector, sector_is_index, FALSE, &sector_data, &sector_length);
1004
1019
        if (err)
1005
1020
                return err;
1006
1021
 
1016
1031
 
1017
1032
        return FLOPPY_ERROR_SUCCESS;
1018
1033
}
1019
 
        
1020
 
        
1021
 
        
1022
 
static floperr_t coco_dmk_write_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen)
 
1034
 
 
1035
 
 
1036
 
 
1037
static floperr_t internal_coco_dmk_write_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, const void *buffer, size_t buflen)
1023
1038
{
1024
1039
        floperr_t err;
1025
1040
        UINT32 sector_length;
1026
1041
        UINT8 *sector_data;
1027
1042
        UINT16 crc;
1028
1043
                
1029
 
        err = coco_dmk_seek_sector_in_track(floppy, head, track, sector, TRUE, &sector_data, &sector_length);
 
1044
        err = coco_dmk_seek_sector_in_track(floppy, head, track, sector, sector_is_index, TRUE, &sector_data, &sector_length);
1030
1045
        if (err)
1031
1046
                return err;
1032
1047
                
1043
1058
 
1044
1059
                
1045
1060
 
 
1061
static floperr_t coco_dmk_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
 
1062
{
 
1063
        return internal_coco_dmk_read_sector(floppy, head, track, sector, FALSE, buffer, buflen);
 
1064
}
 
1065
 
 
1066
static floperr_t coco_dmk_write_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen)
 
1067
{
 
1068
        return internal_coco_dmk_write_sector(floppy, head, track, sector, FALSE, buffer, buflen);
 
1069
}
 
1070
 
 
1071
static floperr_t coco_dmk_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
 
1072
{
 
1073
        return internal_coco_dmk_read_sector(floppy, head, track, sector, TRUE, buffer, buflen);
 
1074
}
 
1075
 
 
1076
static floperr_t coco_dmk_write_indexed_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen)
 
1077
{
 
1078
        return internal_coco_dmk_write_sector(floppy, head, track, sector, TRUE, buffer, buflen);
 
1079
}
 
1080
 
 
1081
 
 
1082
 
1046
1083
static void coco_dmk_interpret_header(floppy_image *floppy, int *heads, int *tracks, int *track_size)
1047
1084
{
1048
1085
        UINT8 header[DMK_HEADER_LEN];
1107
1144
        callbacks->get_indexed_sector_info = coco_dmk_get_indexed_sector_info;
1108
1145
        callbacks->read_sector = coco_dmk_read_sector;
1109
1146
        callbacks->write_sector = coco_dmk_write_sector;
 
1147
        callbacks->read_indexed_sector = coco_dmk_read_indexed_sector;
 
1148
        callbacks->write_indexed_sector = coco_dmk_write_indexed_sector;
1110
1149
 
1111
1150
        return FLOPPY_ERROR_SUCCESS;
1112
1151
}