Return to smd.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat

Annotation of 43BSDReno/sys/tahoestand/vdformat/smd.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)smd.c      1.3 (Berkeley/CCI) 6/7/88";
                      3: #endif
                      4: 
                      5: #include       "vdfmt.h"
                      6: 
                      7: 
                      8: 
                      9: /*
                     10: **     The sector format of the SMD (VDDC) controller looks like this:
                     11: **  28 bytes sector gap                (header error)
                     12: **   1 byte sync (0x19)                (header error)
                     13: **   2 bytes cylinder address  (header error)
                     14: **   1 byte track address      (header error)
                     15: **   1 byte sector address     (header error)
                     16: **   2 bytes header crc                (header error)
                     17: **  18 bytes header gap                (data error)
                     18: ** 512 bytes data              (data error)
                     19: **   4 byte ecc                        (data error)
                     20: **  ?? trailing pad            (data error)
                     21: */
                     22: 
                     23: smd_decode_position(bad_entry, error)
                     24: register bs_entry *bad_entry;
                     25: register fmt_err *error;
                     26: {
                     27:        int     sector_length = lab->d_traksize / lab->d_nsectors;
                     28:        int     offset = (bad_entry->bs_offset-2) % sector_length;
                     29:        int     bytes = ((bad_entry->bs_length / 8)) + 4;
                     30: 
                     31:        error->err_adr.cylinder = bad_entry->bs_cyl;
                     32:        error->err_adr.track = bad_entry->bs_trk;
                     33:        error->err_adr.sector = (bad_entry->bs_offset-2) / sector_length;
                     34:        if(error->err_adr.sector >= lab->d_nsectors) {
                     35:                error->err_adr.sector = lab->d_nsectors - 1;
                     36:                error->err_stat = DATA_ERROR;
                     37:        }
                     38:        else if((offset < 35) || ((offset+bytes) > sector_length))
                     39:                error->err_stat = HEADER_ERROR;
                     40:        else 
                     41:                error->err_stat = DATA_ERROR;
                     42: }
                     43: 
                     44: 
                     45: /*
                     46: **
                     47: */
                     48: 
                     49: smd_code_position(error, badent)
                     50: register fmt_err *error;
                     51: register bs_entry *badent;
                     52: {
                     53:        int             sector_length = lab->d_traksize / lab->d_nsectors;
                     54: 
                     55:        badent->bs_length = 1;
                     56:        badent->bs_cyl = error->err_adr.cylinder;
                     57:        badent->bs_trk = error->err_adr.track;
                     58:        badent->bs_offset = error->err_adr.sector * sector_length;
                     59:        if(error->err_stat & HEADER_ERROR) {
                     60:                badent->bs_offset += 1;
                     61:        }
                     62:        else {
                     63:                badent->bs_offset += 50;
                     64:        }
                     65:        badent->bs_alt.cylinder = 0;
                     66:        badent->bs_alt.track = 0;
                     67:        badent->bs_alt.sector = 0;
                     68:        badent->bs_how = scanning;
                     69: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.