int nad_ctable2_load( projCtx ctx, struct CTABLE *ct, FILE *fid )
{
int a_size;
fseek( fid, 160, SEEK_SET );
/* read all the actual shift values */
a_size = ct->lim.lam * ct->lim.phi;
ct->cvs = (FLP *) pj_malloc(sizeof(FLP) * a_size);
if( ct->cvs == NULL
|| fread(ct->cvs, sizeof(FLP), a_size, fid) != a_size )
{
pj_dalloc( ct->cvs );
ct->cvs = NULL;
if( getenv("PROJ_DEBUG") != NULL )
{
fprintf( stderr,
"ctable2 loading failed on fread() - binary incompatible?\n" );
}
pj_ctx_set_errno( ctx, -38 );
return 0;
}
if( !IS_LSB )
{
swap_words( ct->cvs, 4, a_size * 2 );
}
return 1;
}
void md5_update(struct md5_ctx *ctx, const void *data, unsigned int len)
{
unsigned int n;
const uint8_t *ptr = data;
uint8_t *buf = (uint8_t *)ctx->buf;
while (len > 0) {
n = MD5_BLOCK_LENGTH - bufpos(ctx);
if (n > len)
n = len;
memcpy(buf + bufpos(ctx), ptr, n);
ptr += n;
len -= n;
ctx->nbytes += n;
if (bufpos(ctx) == 0) {
swap_words(ctx->buf, 16);
md5_mix(ctx, ctx->buf);
}
}
}
unsigned int
fli_size(char *refany, unsigned short offset, boolean_t lsb)
{
/* fh = REVEAL(refany,struct fli_frame_header*) */
struct fli_frame_header *fh = (struct fli_frame_header*) refany;
int size;
#if __alpha
/* XXX This is strange stuff. mef */
/* detect and deal with unaligned access */
if ((long)refany % sizeof(int)) {
/* unaligned */
bcopy((char*)(((long)refany)+offset),(char*)&size,sizeof(int));
} else {
size = fh->size;
}
#else __alpha
size = frame_hdr->size;
#endif __alpha
if (lsb) size = swap_words(size);
return (size);
}
void md5_final(uint8_t *dst, struct md5_ctx *ctx)
{
static const uint8_t padding[MD5_BLOCK_LENGTH] = { 0x80 };
uint64_t final_len = ctx->nbytes * 8;
int pad_len, pos = bufpos(ctx);
/* add padding */
pad_len = MD5_BLOCK_LENGTH - 8 - pos;
if (pad_len <= 0)
pad_len += MD5_BLOCK_LENGTH;
md5_update(ctx, padding, pad_len);
/* add length directly */
swap_words(ctx->buf, 14);
ctx->buf[14] = final_len;
ctx->buf[15] = final_len >> 32;
/* final result */
md5_mix(ctx, ctx->buf);
le32enc(dst + 0, ctx->a);
le32enc(dst + 4, ctx->b);
le32enc(dst + 8, ctx->c);
le32enc(dst + 12, ctx->d);
}
void sortWordList() {
word_ptr wgrp, w0, w1, wtmp;
len_ptr lptr;
for (lptr = lengthList; lptr != NULL; lptr = lptr->nextLength) {
for (wgrp = lptr->wordlist; wgrp != NULL; wgrp = wgrp->next) {
for (w0 = wgrp->next_anagram; w0 != NULL; w0 = w0->next_anagram) {
for (w1 = w0->next_anagram; w1 != NULL; w1 = w1->next_anagram) {
if (strcmp(w0->str, w1->str) > 0) { /* swap w0 and w1 */
swap_words(w0, w1);
/*
* if w0 is the first element in the group, readjust the pointer
* from wgrp.
*/
if (wgrp->next_anagram == w0) {
wgrp->next_anagram = w1;
}
/*
* At this point, w0 and w1 have been swapped in the list.
* The problem now is that w0 and w1 no longer point into the
* same relative positions in the list of anagrams as they used
* to; unless we fix this, the sorting iterations will get
* messed up. E.g., if w0 was the 3rd element in the list and
* w1 the 5th element, then after the swap the outer (w0)
* iteration will continue from the 6th element of the list,
* rather than the 4th element. To fix this, we swap w0 and w1.
*/
wtmp = w0;
w0 = w1;
w1 = wtmp;
}
}
}
}
}
}
static int pj_gridinfo_init_ntv1( projCtx ctx, PAFile fid, PJ_GRIDINFO *gi )
{
unsigned char header[176];
struct CTABLE *ct;
LP ur;
/* cppcheck-suppress sizeofCalculation */
STATIC_ASSERT( sizeof(pj_int32) == 4 );
/* cppcheck-suppress sizeofCalculation */
STATIC_ASSERT( sizeof(double) == 8 );
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
if( pj_ctx_fread( ctx, header, sizeof(header), 1, fid ) != 1 )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
/* -------------------------------------------------------------------- */
/* Regularize fields of interest. */
/* -------------------------------------------------------------------- */
if( IS_LSB )
{
swap_words( header+8, 4, 1 );
swap_words( header+24, 8, 1 );
swap_words( header+40, 8, 1 );
swap_words( header+56, 8, 1 );
swap_words( header+72, 8, 1 );
swap_words( header+88, 8, 1 );
swap_words( header+104, 8, 1 );
}
if( *((int *) (header+8)) != 12 )
{
pj_log( ctx, PJ_LOG_ERROR,
"NTv1 grid shift file has wrong record count, corrupt?" );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
/* -------------------------------------------------------------------- */
/* Fill in CTABLE structure. */
/* -------------------------------------------------------------------- */
ct = (struct CTABLE *) pj_malloc(sizeof(struct CTABLE));
if (!ct) {
pj_ctx_set_errno(ctx, ENOMEM);
return 0;
}
strcpy( ct->id, "NTv1 Grid Shift File" );
ct->ll.lam = - to_double(header+72);
ct->ll.phi = to_double(header+24);
ur.lam = - to_double(header+56);
ur.phi = to_double(header+40);
ct->del.lam = to_double(header+104);
ct->del.phi = to_double(header+88);
ct->lim.lam = (pj_int32) (fabs(ur.lam-ct->ll.lam)/ct->del.lam + 0.5) + 1;
ct->lim.phi = (pj_int32) (fabs(ur.phi-ct->ll.phi)/ct->del.phi + 0.5) + 1;
pj_log( ctx, PJ_LOG_DEBUG_MINOR,
"NTv1 %dx%d: LL=(%.9g,%.9g) UR=(%.9g,%.9g)",
ct->lim.lam, ct->lim.phi,
ct->ll.lam, ct->ll.phi, ur.lam, ur.phi );
ct->ll.lam *= DEG_TO_RAD;
ct->ll.phi *= DEG_TO_RAD;
ct->del.lam *= DEG_TO_RAD;
ct->del.phi *= DEG_TO_RAD;
ct->cvs = NULL;
gi->ct = ct;
gi->grid_offset = pj_ctx_ftell( ctx, fid );
gi->format = "ntv1";
return 1;
}
static int pj_gridinfo_init_ntv2( projCtx ctx, PAFile fid, PJ_GRIDINFO *gilist )
{
unsigned char header[11*16];
int num_subfiles, subfile;
int must_swap;
/* cppcheck-suppress sizeofCalculation */
STATIC_ASSERT( sizeof(pj_int32) == 4 );
/* cppcheck-suppress sizeofCalculation */
STATIC_ASSERT( sizeof(double) == 8 );
/* -------------------------------------------------------------------- */
/* Read the overview header. */
/* -------------------------------------------------------------------- */
if( pj_ctx_fread( ctx, header, sizeof(header), 1, fid ) != 1 )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
if( header[8] == 11 )
must_swap = !IS_LSB;
else
must_swap = IS_LSB;
/* -------------------------------------------------------------------- */
/* Byte swap interesting fields if needed. */
/* -------------------------------------------------------------------- */
if( must_swap )
{
swap_words( header+8, 4, 1 );
swap_words( header+8+16, 4, 1 );
swap_words( header+8+32, 4, 1 );
swap_words( header+8+7*16, 8, 1 );
swap_words( header+8+8*16, 8, 1 );
swap_words( header+8+9*16, 8, 1 );
swap_words( header+8+10*16, 8, 1 );
}
/* -------------------------------------------------------------------- */
/* Get the subfile count out ... all we really use for now. */
/* -------------------------------------------------------------------- */
memcpy( &num_subfiles, header+8+32, 4 );
/* ==================================================================== */
/* Step through the subfiles, creating a PJ_GRIDINFO for each. */
/* ==================================================================== */
for( subfile = 0; subfile < num_subfiles; subfile++ )
{
struct CTABLE *ct;
LP ur;
int gs_count;
PJ_GRIDINFO *gi;
/* -------------------------------------------------------------------- */
/* Read header. */
/* -------------------------------------------------------------------- */
if( pj_ctx_fread( ctx, header, sizeof(header), 1, fid ) != 1 )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
if( strncmp((const char *) header,"SUB_NAME",8) != 0 )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
/* -------------------------------------------------------------------- */
/* Byte swap interesting fields if needed. */
/* -------------------------------------------------------------------- */
if( must_swap )
{
swap_words( header+8+16*4, 8, 1 );
swap_words( header+8+16*5, 8, 1 );
swap_words( header+8+16*6, 8, 1 );
swap_words( header+8+16*7, 8, 1 );
swap_words( header+8+16*8, 8, 1 );
swap_words( header+8+16*9, 8, 1 );
swap_words( header+8+16*10, 4, 1 );
}
/* -------------------------------------------------------------------- */
/* Initialize a corresponding "ct" structure. */
/* -------------------------------------------------------------------- */
ct = (struct CTABLE *) pj_malloc(sizeof(struct CTABLE));
if (!ct) {
pj_ctx_set_errno(ctx, ENOMEM);
return 0;
}
strncpy( ct->id, (const char *) header + 8, 8 );
ct->id[8] = '\0';
ct->ll.lam = - to_double(header+7*16+8); /* W_LONG */
ct->ll.phi = to_double(header+4*16+8); /* S_LAT */
ur.lam = - to_double(header+6*16+8); /* E_LONG */
ur.phi = to_double(header+5*16+8); /* N_LAT */
ct->del.lam = to_double(header+9*16+8);
ct->del.phi = to_double(header+8*16+8);
ct->lim.lam = (pj_int32) (fabs(ur.lam-ct->ll.lam)/ct->del.lam + 0.5) + 1;
ct->lim.phi = (pj_int32) (fabs(ur.phi-ct->ll.phi)/ct->del.phi + 0.5) + 1;
pj_log( ctx, PJ_LOG_DEBUG_MINOR,
"NTv2 %s %dx%d: LL=(%.9g,%.9g) UR=(%.9g,%.9g)",
ct->id,
ct->lim.lam, ct->lim.phi,
ct->ll.lam/3600.0, ct->ll.phi/3600.0,
ur.lam/3600.0, ur.phi/3600.0 );
ct->ll.lam *= DEG_TO_RAD/3600.0;
ct->ll.phi *= DEG_TO_RAD/3600.0;
ct->del.lam *= DEG_TO_RAD/3600.0;
ct->del.phi *= DEG_TO_RAD/3600.0;
memcpy( &gs_count, header + 8 + 16*10, 4 );
if( gs_count != ct->lim.lam * ct->lim.phi )
{
pj_log( ctx, PJ_LOG_ERROR,
"GS_COUNT(%d) does not match expected cells (%dx%d=%d)",
gs_count, ct->lim.lam, ct->lim.phi,
ct->lim.lam * ct->lim.phi );
pj_dalloc(ct);
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
ct->cvs = NULL;
/* -------------------------------------------------------------------- */
/* Create a new gridinfo for this if we aren't processing the */
/* 1st subfile, and initialize our grid info. */
/* -------------------------------------------------------------------- */
if( subfile == 0 )
gi = gilist;
else
{
gi = (PJ_GRIDINFO *) pj_calloc(1, sizeof(PJ_GRIDINFO));
if (!gi) {
pj_dalloc(ct);
pj_gridinfo_free(ctx, gilist);
pj_ctx_set_errno(ctx, ENOMEM);
return 0;
}
gi->gridname = pj_strdup( gilist->gridname );
gi->filename = pj_strdup( gilist->filename );
if (!gi->gridname || !gi->filename) {
pj_gridinfo_free(ctx, gi);
pj_dalloc(ct);
pj_gridinfo_free(ctx, gilist);
pj_ctx_set_errno(ctx, ENOMEM);
return 0;
}
gi->next = NULL;
}
gi->must_swap = must_swap;
gi->ct = ct;
gi->format = "ntv2";
gi->grid_offset = pj_ctx_ftell( ctx, fid );
/* -------------------------------------------------------------------- */
/* Attach to the correct list or sublist. */
/* -------------------------------------------------------------------- */
if( strncmp((const char *)header+24,"NONE",4) == 0 )
{
if( gi != gilist )
{
PJ_GRIDINFO *lnk;
for( lnk = gilist; lnk->next != NULL; lnk = lnk->next ) {}
lnk->next = gi;
}
}
else
{
PJ_GRIDINFO *lnk;
PJ_GRIDINFO *gp = gridinfo_parent(gilist,
(const char*)header+24,8);
if( gp == NULL )
{
pj_log( ctx, PJ_LOG_ERROR,
"pj_gridinfo_init_ntv2(): "
"failed to find parent %8.8s for %s.",
(const char *) header+24, gi->ct->id );
for( lnk = gilist; lnk->next != NULL; lnk = lnk->next ) {}
lnk->next = gi;
}
else
{
if( gp->child == NULL )
{
gp->child = gi;
}
else
{
for( lnk = gp->child; lnk->next != NULL; lnk = lnk->next ) {}
lnk->next = gi;
}
}
}
/* -------------------------------------------------------------------- */
/* Seek past the data. */
/* -------------------------------------------------------------------- */
pj_ctx_fseek( ctx, fid, gs_count * 16, SEEK_CUR );
}
return 1;
}
int pj_gridinfo_load( projCtx ctx, PJ_GRIDINFO *gi )
{
struct CTABLE ct_tmp;
if( gi == NULL || gi->ct == NULL )
return 0;
pj_acquire_lock();
if( gi->ct->cvs != NULL )
{
pj_release_lock();
return 1;
}
memcpy(&ct_tmp, gi->ct, sizeof(struct CTABLE));
/* -------------------------------------------------------------------- */
/* Original platform specific CTable format. */
/* -------------------------------------------------------------------- */
if( strcmp(gi->format,"ctable") == 0 )
{
PAFile fid;
int result;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
result = nad_ctable_load( ctx, &ct_tmp, fid );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return result;
}
/* -------------------------------------------------------------------- */
/* CTable2 format. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ctable2") == 0 )
{
PAFile fid;
int result;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
result = nad_ctable2_load( ctx, &ct_tmp, fid );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return result;
}
/* -------------------------------------------------------------------- */
/* NTv1 format. */
/* We process one line at a time. Note that the array storage */
/* direction (e-w) is different in the NTv1 file and what */
/* the CTABLE is supposed to have. The phi/lam are also */
/* reversed, and we have to be aware of byte swapping. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ntv1") == 0 )
{
double *row_buf;
int row;
PAFile fid;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
pj_ctx_fseek( ctx, fid, gi->grid_offset, SEEK_SET );
row_buf = (double *) pj_malloc(gi->ct->lim.lam * sizeof(double) * 2);
ct_tmp.cvs = (FLP *) pj_malloc(gi->ct->lim.lam*gi->ct->lim.phi*sizeof(FLP));
if( row_buf == NULL || ct_tmp.cvs == NULL )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, ENOMEM );
pj_release_lock();
return 0;
}
for( row = 0; row < gi->ct->lim.phi; row++ )
{
int i;
FLP *cvs;
double *diff_seconds;
if( pj_ctx_fread( ctx, row_buf,
sizeof(double), gi->ct->lim.lam * 2, fid )
!= (size_t)( 2 * gi->ct->lim.lam ) )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
if( IS_LSB )
swap_words( (unsigned char *) row_buf, 8, gi->ct->lim.lam*2 );
/* convert seconds to radians */
diff_seconds = row_buf;
for( i = 0; i < gi->ct->lim.lam; i++ )
{
cvs = ct_tmp.cvs + (row) * gi->ct->lim.lam
+ (gi->ct->lim.lam - i - 1);
cvs->phi = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
cvs->lam = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
}
}
pj_dalloc( row_buf );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return 1;
}
/* -------------------------------------------------------------------- */
/* NTv2 format. */
/* We process one line at a time. Note that the array storage */
/* direction (e-w) is different in the NTv2 file and what */
/* the CTABLE is supposed to have. The phi/lam are also */
/* reversed, and we have to be aware of byte swapping. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ntv2") == 0 )
{
float *row_buf;
int row;
PAFile fid;
pj_log( ctx, PJ_LOG_DEBUG_MINOR,
"NTv2 - loading grid %s", gi->ct->id );
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
pj_ctx_fseek( ctx, fid, gi->grid_offset, SEEK_SET );
row_buf = (float *) pj_malloc(gi->ct->lim.lam * sizeof(float) * 4);
ct_tmp.cvs = (FLP *) pj_malloc(gi->ct->lim.lam*gi->ct->lim.phi*sizeof(FLP));
if( row_buf == NULL || ct_tmp.cvs == NULL )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, ENOMEM );
pj_release_lock();
return 0;
}
for( row = 0; row < gi->ct->lim.phi; row++ )
{
int i;
FLP *cvs;
float *diff_seconds;
if( pj_ctx_fread( ctx, row_buf, sizeof(float),
gi->ct->lim.lam*4, fid )
!= (size_t)( 4 * gi->ct->lim.lam ) )
{
pj_dalloc( row_buf );
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
if( gi->must_swap )
swap_words( (unsigned char *) row_buf, 4,
gi->ct->lim.lam*4 );
/* convert seconds to radians */
diff_seconds = row_buf;
for( i = 0; i < gi->ct->lim.lam; i++ )
{
cvs = ct_tmp.cvs + (row) * gi->ct->lim.lam
+ (gi->ct->lim.lam - i - 1);
cvs->phi = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
cvs->lam = (float) (*(diff_seconds++) * ((M_PI/180.0) / 3600.0));
diff_seconds += 2; /* skip accuracy values */
}
}
pj_dalloc( row_buf );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return 1;
}
/* -------------------------------------------------------------------- */
/* GTX format. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"gtx") == 0 )
{
int words = gi->ct->lim.lam * gi->ct->lim.phi;
PAFile fid;
fid = pj_open_lib( ctx, gi->filename, "rb" );
if( fid == NULL )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
pj_ctx_fseek( ctx, fid, gi->grid_offset, SEEK_SET );
ct_tmp.cvs = (FLP *) pj_malloc(words*sizeof(float));
if( ct_tmp.cvs == NULL )
{
pj_ctx_set_errno( ctx, ENOMEM );
pj_release_lock();
return 0;
}
if( pj_ctx_fread( ctx, ct_tmp.cvs, sizeof(float), words, fid )
!= (size_t)words )
{
pj_dalloc( ct_tmp.cvs );
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
pj_release_lock();
return 0;
}
if( IS_LSB )
swap_words( (unsigned char *) ct_tmp.cvs, 4, words );
pj_ctx_fclose( ctx, fid );
gi->ct->cvs = ct_tmp.cvs;
pj_release_lock();
return 1;
}
else
{
pj_release_lock();
return 0;
}
}
void
AHCIPort::ScsiInquiry(scsi_ccb *request)
{
TRACE("AHCIPort::ScsiInquiry port %d\n", fIndex);
scsi_cmd_inquiry *cmd = (scsi_cmd_inquiry *)request->cdb;
scsi_res_inquiry scsiData;
ata_res_identify_device ataData;
ASSERT(sizeof(ataData) == 512);
if (cmd->evpd || cmd->page_code || request->data_length < sizeof(scsiData)) {
TRACE("invalid request\n");
request->subsys_status = SCSI_REQ_ABORTED;
gSCSI->finished(request, 1);
return;
}
sata_request sreq;
sreq.set_data(&ataData, sizeof(ataData));
sreq.set_ata_cmd(fIsATAPI ? 0xa1 : 0xec); // Identify (Packet) Device
ExecuteSataRequest(&sreq);
sreq.wait_for_completition();
if (sreq.completition_status() & ATA_ERR) {
TRACE("identify device failed\n");
request->subsys_status = SCSI_REQ_CMP_ERR;
gSCSI->finished(request, 1);
return;
}
/*
uint8 *data = (uint8*) &ataData;
for (int i = 0; i < 512; i += 8) {
TRACE(" %02x %02x %02x %02x %02x %02x %02x %02x\n", data[i], data[i+1],
data[i+2], data[i+3], data[i+4], data[i+5], data[i+6], data[i+7]);
}
*/
scsiData.device_type = fIsATAPI ? scsi_dev_CDROM : scsi_dev_direct_access;
scsiData.device_qualifier = scsi_periph_qual_connected;
scsiData.device_type_modifier = 0;
scsiData.removable_medium = fIsATAPI;
scsiData.ansi_version = 2;
scsiData.ecma_version = 0;
scsiData.iso_version = 0;
scsiData.response_data_format = 2;
scsiData.term_iop = false;
scsiData.additional_length = sizeof(scsiData) - 4;
scsiData.soft_reset = false;
scsiData.cmd_queue = false;
scsiData.linked = false;
scsiData.sync = false;
scsiData.write_bus16 = true;
scsiData.write_bus32 = false;
scsiData.relative_address = false;
memcpy(scsiData.vendor_ident, ataData.model_number,
sizeof(scsiData.vendor_ident));
memcpy(scsiData.product_ident, ataData.model_number + 8,
sizeof(scsiData.product_ident));
memcpy(scsiData.product_rev, ataData.serial_number,
sizeof(scsiData.product_rev));
if (!fIsATAPI) {
bool lba = (ataData.words[49] & (1 << 9)) != 0;
bool lba48 = (ataData.words[83] & (1 << 10)) != 0;
uint32 sectors = *(uint32*)&ataData.words[60];
uint64 sectors48 = *(uint64*)&ataData.words[100];
fUse48BitCommands = lba && lba48;
fSectorSize = 512;
fSectorCount = !(lba || sectors) ? 0 : lba48 ? sectors48 : sectors;
TRACE("lba %d, lba48 %d, fUse48BitCommands %d, sectors %lu, "
"sectors48 %llu, size %llu\n",
lba, lba48, fUse48BitCommands, sectors, sectors48,
fSectorCount * fSectorSize);
}
#if 0
if (fSectorCount < 0x0fffffff) {
TRACE("disabling 48 bit commands\n");
fUse48BitCommands = 0;
}
#endif
char modelNumber[sizeof(ataData.model_number) + 1];
char serialNumber[sizeof(ataData.serial_number) + 1];
char firmwareRev[sizeof(ataData.firmware_revision) + 1];
strlcpy(modelNumber, ataData.model_number, sizeof(modelNumber));
strlcpy(serialNumber, ataData.serial_number, sizeof(serialNumber));
strlcpy(firmwareRev, ataData.firmware_revision, sizeof(firmwareRev));
swap_words(modelNumber, sizeof(modelNumber) - 1);
swap_words(serialNumber, sizeof(serialNumber) - 1);
swap_words(firmwareRev, sizeof(firmwareRev) - 1);
TRACE("model number: %s\n", modelNumber);
TRACE("serial number: %s\n", serialNumber);
TRACE("firmware rev.: %s\n", firmwareRev);
if (sg_memcpy(request->sg_list, request->sg_count, &scsiData,
sizeof(scsiData)) < B_OK) {
request->subsys_status = SCSI_DATA_RUN_ERR;
} else {
request->subsys_status = SCSI_REQ_CMP;
request->data_resid = request->data_length - sizeof(scsiData);
}
gSCSI->finished(request, 1);
}
void
fli_lc(video_t dpy, char *chunk_buff, boolean_t lsb)
{
unsigned short i,j,k,l;
unsigned short skiplines;
unsigned short changelines;
unsigned char packets;
unsigned char skip;
char size;
char *save_buff;
/* XXX Fix me: the video_framebuffer() interface will
* go away. Need to compute the screen buffer position
* based on (x,y) coordinates
*
*/
char *screen_buff = video_framebuffer(dpy);
unsigned short frame_width = video_frame_width(dpy);
skiplines = *((unsigned short *)chunk_buff)++;
if(lsb) skiplines = swap_words(skiplines);
changelines = *((unsigned short *)chunk_buff)++;
if(lsb) changelines = swap_words(changelines);
screen_buff += (skiplines * frame_width);
save_buff = screen_buff;
for (i=0;i<changelines;i++)
{
packets = *chunk_buff++;
for (l =0;l<packets;l++)
{
skip = *chunk_buff++;
screen_buff += skip;
size = *chunk_buff++;
if (size > 0)
{
bcopy(chunk_buff,screen_buff,size);
chunk_buff += size;
screen_buff+= size;
/* for (k=0;k<size;k++)
* *screen_buff++ = *chunk_buff++;
*/
}
else if (size < 0)
{
size = -size;
/* if we just had a fast memset. */
memset(screen_buff,*chunk_buff,size);
/* for(k=0;k<size;k++)
* *screen_buff++ = *chunk_buff;
*/
screen_buff += size;
chunk_buff ++;
}
}
save_buff += frame_width;
screen_buff = save_buff;
}
}
static int pj_gridinfo_init_ntv1( projCtx ctx, PAFile fid, PJ_GRIDINFO *gi )
{
unsigned char header[176];
struct CTABLE *ct;
LP ur;
assert( sizeof(int) == 4 );
assert( sizeof(double) == 8 );
if( sizeof(int) != 4 || sizeof(double) != 8 )
{
pj_log( ctx, PJ_LOG_ERROR,
"basic types of inappropraiate size in nad_load_ntv1()" );
pj_ctx_set_errno( ctx, -38 );
return 0;
}
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
if( pj_ctx_fread( ctx, header, sizeof(header), 1, fid ) != 1 )
{
pj_ctx_set_errno( ctx, -38 );
return 0;
}
/* -------------------------------------------------------------------- */
/* Regularize fields of interest. */
/* -------------------------------------------------------------------- */
if( IS_LSB )
{
swap_words( header+8, 4, 1 );
swap_words( header+24, 8, 1 );
swap_words( header+40, 8, 1 );
swap_words( header+56, 8, 1 );
swap_words( header+72, 8, 1 );
swap_words( header+88, 8, 1 );
swap_words( header+104, 8, 1 );
}
if( *((int *) (header+8)) != 12 )
{
pj_log( ctx, PJ_LOG_ERROR,
"NTv1 grid shift file has wrong record count, corrupt?" );
pj_ctx_set_errno( ctx, -38 );
return 0;
}
/* -------------------------------------------------------------------- */
/* Fill in CTABLE structure. */
/* -------------------------------------------------------------------- */
ct = (struct CTABLE *) pj_malloc(sizeof(struct CTABLE));
strcpy( ct->id, "NTv1 Grid Shift File" );
ct->ll.lam = - *((double *) (header+72));
ct->ll.phi = *((double *) (header+24));
ur.lam = - *((double *) (header+56));
ur.phi = *((double *) (header+40));
ct->del.lam = *((double *) (header+104));
ct->del.phi = *((double *) (header+88));
ct->lim.lam = (int) (fabs(ur.lam-ct->ll.lam)/ct->del.lam + 0.5) + 1;
ct->lim.phi = (int) (fabs(ur.phi-ct->ll.phi)/ct->del.phi + 0.5) + 1;
pj_log( ctx, PJ_LOG_DEBUG_MINOR,
"NTv1 %dx%d: LL=(%.9g,%.9g) UR=(%.9g,%.9g)",
ct->lim.lam, ct->lim.phi,
ct->ll.lam, ct->ll.phi, ur.lam, ur.phi );
ct->ll.lam *= DEG_TO_RAD;
ct->ll.phi *= DEG_TO_RAD;
ct->del.lam *= DEG_TO_RAD;
ct->del.phi *= DEG_TO_RAD;
ct->cvs = NULL;
gi->ct = ct;
gi->grid_offset = pj_ctx_ftell( ctx, fid );
gi->format = "ntv1";
return 1;
}
struct CTABLE *nad_ctable2_init( projCtx ctx, FILE * fid )
{
struct CTABLE *ct;
int id_end;
char header[160];
if( fread( header, sizeof(header), 1, fid ) != 1 )
{
pj_ctx_set_errno( ctx, -38 );
return NULL;
}
if( !IS_LSB )
{
swap_words( header + 96, 8, 4 );
swap_words( header + 128, 4, 2 );
}
if( strncmp(header,"CTABLE V2",9) != 0 )
{
pj_log( ctx, PJ_LOG_ERROR, "ctable2 - wrong header!" );
pj_ctx_set_errno( ctx, -38 );
return NULL;
}
/* read the table header */
ct = (struct CTABLE *) pj_malloc(sizeof(struct CTABLE));
if( ct == NULL )
{
pj_ctx_set_errno( ctx, -38 );
return NULL;
}
memcpy( ct->id, header + 16, 80 );
memcpy( &ct->ll.lam, header + 96, 8 );
memcpy( &ct->ll.phi, header + 104, 8 );
memcpy( &ct->del.lam, header + 112, 8 );
memcpy( &ct->del.phi, header + 120, 8 );
memcpy( &ct->lim.lam, header + 128, 4 );
memcpy( &ct->lim.phi, header + 132, 4 );
/* do some minimal validation to ensure the structure isn't corrupt */
if( ct->lim.lam < 1 || ct->lim.lam > 100000
|| ct->lim.phi < 1 || ct->lim.phi > 100000 )
{
pj_ctx_set_errno( ctx, -38 );
return NULL;
}
/* trim white space and newlines off id */
for( id_end = strlen(ct->id)-1; id_end > 0; id_end-- )
{
if( ct->id[id_end] == '\n' || ct->id[id_end] == ' ' )
ct->id[id_end] = '\0';
else
break;
}
ct->cvs = NULL;
return ct;
}
static int pj_gridinfo_init_ntv2( FILE *fid, PJ_GRIDINFO *gilist )
{
unsigned char header[11*16];
int num_subfiles, subfile;
assert( sizeof(int) == 4 );
assert( sizeof(double) == 8 );
if( sizeof(int) != 4 || sizeof(double) != 8 )
{
fprintf( stderr,
"basic types of inappropraiate size in pj_gridinfo_init_ntv2()\n" );
pj_errno = -38;
return 0;
}
/* -------------------------------------------------------------------- */
/* Read the overview header. */
/* -------------------------------------------------------------------- */
if( fread( header, sizeof(header), 1, fid ) != 1 )
{
pj_errno = -38;
return 0;
}
/* -------------------------------------------------------------------- */
/* Byte swap interesting fields if needed. */
/* -------------------------------------------------------------------- */
if( !IS_LSB )
{
swap_words( header+8, 4, 1 );
swap_words( header+8+16, 4, 1 );
swap_words( header+8+32, 4, 1 );
swap_words( header+8+7*16, 8, 1 );
swap_words( header+8+8*16, 8, 1 );
swap_words( header+8+9*16, 8, 1 );
swap_words( header+8+10*16, 8, 1 );
}
/* -------------------------------------------------------------------- */
/* Get the subfile count out ... all we really use for now. */
/* -------------------------------------------------------------------- */
memcpy( &num_subfiles, header+8+32, 4 );
/* ==================================================================== */
/* Step through the subfiles, creating a PJ_GRIDINFO for each. */
/* ==================================================================== */
for( subfile = 0; subfile < num_subfiles; subfile++ )
{
struct CTABLE *ct;
LP ur;
int gs_count;
PJ_GRIDINFO *gi;
/* -------------------------------------------------------------------- */
/* Read header. */
/* -------------------------------------------------------------------- */
if( fread( header, sizeof(header), 1, fid ) != 1 )
{
pj_errno = -38;
return 0;
}
if( strncmp((const char *) header,"SUB_NAME",8) != 0 )
{
pj_errno = -38;
return 0;
}
/* -------------------------------------------------------------------- */
/* Byte swap interesting fields if needed. */
/* -------------------------------------------------------------------- */
if( !IS_LSB )
{
swap_words( header+8+16*4, 8, 1 );
swap_words( header+8+16*5, 8, 1 );
swap_words( header+8+16*6, 8, 1 );
swap_words( header+8+16*7, 8, 1 );
swap_words( header+8+16*8, 8, 1 );
swap_words( header+8+16*9, 8, 1 );
swap_words( header+8+16*10, 4, 1 );
}
/* -------------------------------------------------------------------- */
/* Initialize a corresponding "ct" structure. */
/* -------------------------------------------------------------------- */
ct = (struct CTABLE *) pj_malloc(sizeof(struct CTABLE));
strncpy( ct->id, (const char *) header + 8, 8 );
ct->id[8] = '\0';
ct->ll.lam = - *((double *) (header+7*16+8)); /* W_LONG */
ct->ll.phi = *((double *) (header+4*16+8)); /* S_LAT */
ur.lam = - *((double *) (header+6*16+8)); /* E_LONG */
ur.phi = *((double *) (header+5*16+8)); /* N_LAT */
ct->del.lam = *((double *) (header+9*16+8));
ct->del.phi = *((double *) (header+8*16+8));
ct->lim.lam = (int) (fabs(ur.lam-ct->ll.lam)/ct->del.lam + 0.5) + 1;
ct->lim.phi = (int) (fabs(ur.phi-ct->ll.phi)/ct->del.phi + 0.5) + 1;
if( getenv("PROJ_DEBUG") != NULL )
fprintf( stderr,
"NTv2 %s %dx%d: LL=(%.9g,%.9g) UR=(%.9g,%.9g)\n",
ct->id,
ct->lim.lam, ct->lim.phi,
ct->ll.lam/3600.0, ct->ll.phi/3600.0,
ur.lam/3600.0, ur.phi/3600.0 );
ct->ll.lam *= DEG_TO_RAD/3600.0;
ct->ll.phi *= DEG_TO_RAD/3600.0;
ct->del.lam *= DEG_TO_RAD/3600.0;
ct->del.phi *= DEG_TO_RAD/3600.0;
memcpy( &gs_count, header + 8 + 16*10, 4 );
if( gs_count != ct->lim.lam * ct->lim.phi )
{
fprintf( stderr,
"GS_COUNT(%d) does not match expected cells (%dx%d=%d)\n",
gs_count, ct->lim.lam, ct->lim.phi,
ct->lim.lam * ct->lim.phi );
pj_errno = -38;
return 0;
}
ct->cvs = NULL;
/* -------------------------------------------------------------------- */
/* Create a new gridinfo for this if we aren't processing the */
/* 1st subfile, and initialize our grid info. */
/* -------------------------------------------------------------------- */
if( subfile == 0 )
gi = gilist;
else
{
gi = (PJ_GRIDINFO *) pj_malloc(sizeof(PJ_GRIDINFO));
memset( gi, 0, sizeof(PJ_GRIDINFO) );
gi->gridname = strdup( gilist->gridname );
gi->filename = strdup( gilist->filename );
gi->next = NULL;
}
gi->ct = ct;
gi->format = "ntv2";
gi->grid_offset = ftell( fid );
/* -------------------------------------------------------------------- */
/* Attach to the correct list or sublist. */
/* -------------------------------------------------------------------- */
if( strncmp((const char *)header+24,"NONE",4) == 0 )
{
if( gi != gilist )
{
PJ_GRIDINFO *lnk;
for( lnk = gilist; lnk->next != NULL; lnk = lnk->next ) {}
lnk->next = gi;
}
}
else
{
PJ_GRIDINFO *lnk;
PJ_GRIDINFO *gp = gilist;
while( gp != NULL
&& strncmp(gp->ct->id,(const char*)header+24,8) != 0 )
gp = gp->next;
if( gp == NULL )
{
if( getenv("PROJ_DEBUG") != NULL )
fprintf( stderr, "pj_gridinfo_init_ntv2(): "
"failed to find parent %8.8s for %s.\n",
(const char *) header+24, gi->ct->id );
for( lnk = gp; lnk->next != NULL; lnk = lnk->next ) {}
lnk->next = gi;
}
else if( gp->child == NULL )
{
gp->child = gi;
}
else
{
for( lnk = gp->child; lnk->next != NULL; lnk = lnk->next ) {}
lnk->next = gi;
}
}
/* -------------------------------------------------------------------- */
/* Seek past the data. */
/* -------------------------------------------------------------------- */
fseek( fid, gs_count * 16, SEEK_CUR );
}
return 1;
}
int pj_gridinfo_load( PJ_GRIDINFO *gi )
{
if( gi == NULL || gi->ct == NULL )
return 0;
/* -------------------------------------------------------------------- */
/* ctable is currently loaded on initialization though there is */
/* no real reason not to support delayed loading for it as well. */
/* -------------------------------------------------------------------- */
if( strcmp(gi->format,"ctable") == 0 )
{
FILE *fid;
int result;
fid = pj_open_lib( gi->filename, "rb" );
if( fid == NULL )
{
pj_errno = -38;
return 0;
}
result = nad_ctable_load( gi->ct, fid );
fclose( fid );
return result;
}
/* -------------------------------------------------------------------- */
/* NTv1 format. */
/* We process one line at a time. Note that the array storage */
/* direction (e-w) is different in the NTv1 file and what */
/* the CTABLE is supposed to have. The phi/lam are also */
/* reversed, and we have to be aware of byte swapping. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ntv1") == 0 )
{
double *row_buf;
int row;
FILE *fid;
fid = pj_open_lib( gi->filename, "rb" );
if( fid == NULL )
{
pj_errno = -38;
return 0;
}
fseek( fid, gi->grid_offset, SEEK_SET );
row_buf = (double *) pj_malloc(gi->ct->lim.lam * sizeof(double) * 2);
gi->ct->cvs = (FLP *) pj_malloc(gi->ct->lim.lam*gi->ct->lim.phi*sizeof(FLP));
if( row_buf == NULL || gi->ct->cvs == NULL )
{
pj_errno = -38;
return 0;
}
for( row = 0; row < gi->ct->lim.phi; row++ )
{
int i;
FLP *cvs;
double *diff_seconds;
if( fread( row_buf, sizeof(double), gi->ct->lim.lam * 2, fid )
!= 2 * gi->ct->lim.lam )
{
pj_dalloc( row_buf );
pj_dalloc( gi->ct->cvs );
pj_errno = -38;
return 0;
}
if( IS_LSB )
swap_words( (unsigned char *) row_buf, 8, gi->ct->lim.lam*2 );
/* convert seconds to radians */
diff_seconds = row_buf;
for( i = 0; i < gi->ct->lim.lam; i++ )
{
cvs = gi->ct->cvs + (row) * gi->ct->lim.lam
+ (gi->ct->lim.lam - i - 1);
cvs->phi = *(diff_seconds++) * ((PI/180.0) / 3600.0);
cvs->lam = *(diff_seconds++) * ((PI/180.0) / 3600.0);
}
}
pj_dalloc( row_buf );
fclose( fid );
return 1;
}
/* -------------------------------------------------------------------- */
/* NTv2 format. */
/* We process one line at a time. Note that the array storage */
/* direction (e-w) is different in the NTv2 file and what */
/* the CTABLE is supposed to have. The phi/lam are also */
/* reversed, and we have to be aware of byte swapping. */
/* -------------------------------------------------------------------- */
else if( strcmp(gi->format,"ntv2") == 0 )
{
float *row_buf;
int row;
FILE *fid;
if( getenv("PROJ_DEBUG") != NULL )
{
fprintf( stderr, "NTv2 - loading grid %s\n", gi->ct->id );
}
fid = pj_open_lib( gi->filename, "rb" );
if( fid == NULL )
{
pj_errno = -38;
return 0;
}
fseek( fid, gi->grid_offset, SEEK_SET );
row_buf = (float *) pj_malloc(gi->ct->lim.lam * sizeof(float) * 4);
gi->ct->cvs = (FLP *) pj_malloc(gi->ct->lim.lam*gi->ct->lim.phi*sizeof(FLP));
if( row_buf == NULL || gi->ct->cvs == NULL )
{
pj_errno = -38;
return 0;
}
for( row = 0; row < gi->ct->lim.phi; row++ )
{
int i;
FLP *cvs;
float *diff_seconds;
if( fread( row_buf, sizeof(float), gi->ct->lim.lam*4, fid )
!= 4 * gi->ct->lim.lam )
{
pj_dalloc( row_buf );
pj_dalloc( gi->ct->cvs );
gi->ct->cvs = NULL;
pj_errno = -38;
return 0;
}
if( !IS_LSB )
swap_words( (unsigned char *) row_buf, 4,
gi->ct->lim.lam*4 );
/* convert seconds to radians */
diff_seconds = row_buf;
for( i = 0; i < gi->ct->lim.lam; i++ )
{
cvs = gi->ct->cvs + (row) * gi->ct->lim.lam
+ (gi->ct->lim.lam - i - 1);
cvs->phi = *(diff_seconds++) * ((PI/180.0) / 3600.0);
cvs->lam = *(diff_seconds++) * ((PI/180.0) / 3600.0);
diff_seconds += 2; /* skip accuracy values */
}
}
pj_dalloc( row_buf );
fclose( fid );
return 1;
}
else
{
return 0;
}
}
static int pj_gridinfo_init_gtx( projCtx ctx, PAFile fid, PJ_GRIDINFO *gi )
{
unsigned char header[40];
struct CTABLE *ct;
double xorigin,yorigin,xstep,ystep;
int rows, columns;
/* cppcheck-suppress sizeofCalculation */
STATIC_ASSERT( sizeof(pj_int32) == 4 );
/* cppcheck-suppress sizeofCalculation */
STATIC_ASSERT( sizeof(double) == 8 );
/* -------------------------------------------------------------------- */
/* Read the header. */
/* -------------------------------------------------------------------- */
if( pj_ctx_fread( ctx, header, sizeof(header), 1, fid ) != 1 )
{
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
/* -------------------------------------------------------------------- */
/* Regularize fields of interest and extract. */
/* -------------------------------------------------------------------- */
if( IS_LSB )
{
swap_words( header+0, 8, 4 );
swap_words( header+32, 4, 2 );
}
memcpy( &yorigin, header+0, 8 );
memcpy( &xorigin, header+8, 8 );
memcpy( &ystep, header+16, 8 );
memcpy( &xstep, header+24, 8 );
memcpy( &rows, header+32, 4 );
memcpy( &columns, header+36, 4 );
if( xorigin < -360 || xorigin > 360
|| yorigin < -90 || yorigin > 90 )
{
pj_log( ctx, PJ_LOG_ERROR,
"gtx file header has invalid extents, corrupt?");
pj_ctx_set_errno( ctx, PJD_ERR_FAILED_TO_LOAD_GRID );
return 0;
}
/* -------------------------------------------------------------------- */
/* Fill in CTABLE structure. */
/* -------------------------------------------------------------------- */
ct = (struct CTABLE *) pj_malloc(sizeof(struct CTABLE));
if (!ct) {
pj_ctx_set_errno(ctx, ENOMEM);
return 0;
}
strcpy( ct->id, "GTX Vertical Grid Shift File" );
ct->ll.lam = xorigin;
ct->ll.phi = yorigin;
ct->del.lam = xstep;
ct->del.phi = ystep;
ct->lim.lam = columns;
ct->lim.phi = rows;
/* some GTX files come in 0-360 and we shift them back into the
expected -180 to 180 range if possible. This does not solve
problems with grids spanning the dateline. */
if( ct->ll.lam >= 180.0 )
ct->ll.lam -= 360.0;
if( ct->ll.lam >= 0.0 && ct->ll.lam + ct->del.lam * ct->lim.lam > 180.0 )
{
pj_log( ctx, PJ_LOG_DEBUG_MAJOR,
"This GTX spans the dateline! This will cause problems." );
}
pj_log( ctx, PJ_LOG_DEBUG_MINOR,
"GTX %dx%d: LL=(%.9g,%.9g) UR=(%.9g,%.9g)",
ct->lim.lam, ct->lim.phi,
ct->ll.lam, ct->ll.phi,
ct->ll.lam + (columns-1)*xstep, ct->ll.phi + (rows-1)*ystep);
ct->ll.lam *= DEG_TO_RAD;
ct->ll.phi *= DEG_TO_RAD;
ct->del.lam *= DEG_TO_RAD;
ct->del.phi *= DEG_TO_RAD;
ct->cvs = NULL;
gi->ct = ct;
gi->grid_offset = 40;
gi->format = "gtx";
return 1;
}
void
AHCIPort::ScsiInquiry(scsi_ccb *request)
{
TRACE("AHCIPort::ScsiInquiry port %d\n", fIndex);
const scsi_cmd_inquiry *cmd = (const scsi_cmd_inquiry *)request->cdb;
scsi_res_inquiry scsiData;
ata_device_infoblock ataData;
ASSERT(sizeof(ataData) == 512);
if (cmd->evpd || cmd->page_code || request->data_length < sizeof(scsiData)) {
TRACE("invalid request\n");
request->subsys_status = SCSI_REQ_ABORTED;
gSCSI->finished(request, 1);
return;
}
sata_request sreq;
sreq.set_data(&ataData, sizeof(ataData));
sreq.set_ata_cmd(fIsATAPI ? 0xa1 : 0xec); // Identify (Packet) Device
ExecuteSataRequest(&sreq);
sreq.wait_for_completion();
if (sreq.completion_status() & ATA_ERR) {
TRACE("identify device failed\n");
request->subsys_status = SCSI_REQ_CMP_ERR;
gSCSI->finished(request, 1);
return;
}
/*
uint8 *data = (uint8*) &ataData;
for (int i = 0; i < 512; i += 8) {
TRACE(" %02x %02x %02x %02x %02x %02x %02x %02x\n", data[i], data[i+1],
data[i+2], data[i+3], data[i+4], data[i+5], data[i+6], data[i+7]);
}
*/
scsiData.device_type = fIsATAPI
? ataData.word_0.atapi.command_packet_set : scsi_dev_direct_access;
scsiData.device_qualifier = scsi_periph_qual_connected;
scsiData.device_type_modifier = 0;
scsiData.removable_medium = ataData.word_0.ata.removable_media_device;
scsiData.ansi_version = 2;
scsiData.ecma_version = 0;
scsiData.iso_version = 0;
scsiData.response_data_format = 2;
scsiData.term_iop = false;
scsiData.additional_length = sizeof(scsi_res_inquiry) - 4;
scsiData.soft_reset = false;
scsiData.cmd_queue = false;
scsiData.linked = false;
scsiData.sync = false;
scsiData.write_bus16 = true;
scsiData.write_bus32 = false;
scsiData.relative_address = false;
if (!fIsATAPI) {
fSectorCount = ataData.SectorCount(fUse48BitCommands, true);
fSectorSize = ataData.SectorSize();
fTrim = ataData.data_set_management_support;
TRACE("lba %d, lba48 %d, fUse48BitCommands %d, sectors %" B_PRIu32
", sectors48 %" B_PRIu64 ", size %" B_PRIu64 "\n",
ataData.dma_supported != 0, ataData.lba48_supported != 0,
fUse48BitCommands, ataData.lba_sector_count,
ataData.lba48_sector_count, fSectorCount * fSectorSize);
}
#if 0
if (fSectorCount < 0x0fffffff) {
TRACE("disabling 48 bit commands\n");
fUse48BitCommands = 0;
}
#endif
char modelNumber[sizeof(ataData.model_number) + 1];
char serialNumber[sizeof(ataData.serial_number) + 1];
char firmwareRev[sizeof(ataData.firmware_revision) + 1];
strlcpy(modelNumber, ataData.model_number, sizeof(modelNumber));
strlcpy(serialNumber, ataData.serial_number, sizeof(serialNumber));
strlcpy(firmwareRev, ataData.firmware_revision, sizeof(firmwareRev));
swap_words(modelNumber, sizeof(modelNumber) - 1);
swap_words(serialNumber, sizeof(serialNumber) - 1);
swap_words(firmwareRev, sizeof(firmwareRev) - 1);
TRACE("model number: %s\n", modelNumber);
TRACE("serial number: %s\n", serialNumber);
TRACE("firmware rev.: %s\n", firmwareRev);
TRACE("trim support: %s\n", fTrim ? "yes" : "no");
// There's not enough space to fit all of the data in. ATA has 40 bytes for
// the model number, 20 for the serial number and another 8 for the
// firmware revision. SCSI has room for 8 for vendor ident, 16 for product
// ident and another 4 for product revision. We just try and fit in as much
// as possible of the model number into the vendor and product ident fields
// and put a little of the serial number into the product revision field.
memcpy(scsiData.vendor_ident, modelNumber, sizeof(scsiData.vendor_ident));
memcpy(scsiData.product_ident, modelNumber + 8,
sizeof(scsiData.product_ident));
memcpy(scsiData.product_rev, serialNumber, sizeof(scsiData.product_rev));
if (sg_memcpy(request->sg_list, request->sg_count, &scsiData,
sizeof(scsiData)) < B_OK) {
request->subsys_status = SCSI_DATA_RUN_ERR;
} else {
request->subsys_status = SCSI_REQ_CMP;
request->data_resid = request->data_length - sizeof(scsiData);
}
gSCSI->finished(request, 1);
}
int main(int argc, char **argv) {
struct CTABLE ct;
FLP *p, t;
size_t tsize;
int i, j, ichk;
long lam, laml, phi, phil;
FILE *fp;
const char *output_file = NULL;
const char *format = "ctable2";
const char *GS_TYPE = "SECONDS";
const char *VERSION = "";
const char *SYSTEM_F = "NAD27";
const char *SYSTEM_T = "NAD83";
const char *SUB_NAME = "";
const char *CREATED = "";
const char *UPDATED = "";
/* ==================================================================== */
/* Process arguments. */
/* ==================================================================== */
for( i = 1; i < argc; i++ )
{
if( strcmp(argv[i],"-f") == 0 && i < argc-1 )
{
format = argv[++i];
}
else if( output_file == NULL )
{
output_file = argv[i];
}
else
Usage();
}
if( output_file == NULL )
Usage();
fprintf( stdout, "Output Binary File Format: %s\n", format );
/* ==================================================================== */
/* Read the ASCII Table */
/* ==================================================================== */
if ( NULL == fgets(ct.id, MAX_TAB_ID, stdin) ) {
perror("fgets");
exit(1);
}
if ( EOF == scanf("%d %d %*d %lf %lf %lf %lf", &ct.lim.lam, &ct.lim.phi,
&ct.ll.lam, &ct.del.lam, &ct.ll.phi, &ct.del.phi) ) {
perror("scanf");
exit(1);
}
if (!(ct.cvs = (FLP *)malloc(tsize = ct.lim.lam * ct.lim.phi *
sizeof(FLP)))) {
perror("mem. alloc");
exit(1);
}
ct.ll.lam *= DEG_TO_RAD;
ct.ll.phi *= DEG_TO_RAD;
ct.del.lam *= DEG_TO_RAD;
ct.del.phi *= DEG_TO_RAD;
/* load table */
for (p = ct.cvs, i = 0; i < ct.lim.phi; ++i) {
if ( EOF == scanf("%d:%ld %ld", &ichk, &laml, &phil) ) {
perror("scanf on row");
exit(1);
}
if (ichk != i) {
fprintf(stderr,"format check on row\n");
exit(1);
}
t.lam = laml * U_SEC_TO_RAD;
t.phi = phil * U_SEC_TO_RAD;
*p++ = t;
for (j = 1; j < ct.lim.lam; ++j) {
if ( EOF == scanf("%ld %ld", &lam, &phi) ) {
perror("scanf on column");
exit(1);
}
t.lam = (laml += lam) * U_SEC_TO_RAD;
t.phi = (phil += phi) * U_SEC_TO_RAD;
*p++ = t;
}
}
if (feof(stdin)) {
fprintf(stderr, "premature EOF\n");
exit(1);
}
/* ==================================================================== */
/* Write out the old ctable format - this is machine and byte */
/* order specific. */
/* ==================================================================== */
if( strcmp(format,"ctable") == 0 )
{
if (!(fp = fopen(output_file, "wb"))) {
perror(output_file);
exit(2);
}
if (fwrite(&ct, sizeof(ct), 1, fp) != 1 ||
fwrite(ct.cvs, tsize, 1, fp) != 1) {
fprintf(stderr, "output failure\n");
exit(2);
}
fclose( fp );
exit(0); /* normal completion */
}
/* ==================================================================== */
/* Write out the old ctable format - this is machine and byte */
/* order specific. */
/* ==================================================================== */
if( strcmp(format,"ctable2") == 0 )
{
char header[160];
if (!(fp = fopen(output_file, "wb"))) {
perror(output_file);
exit(2);
}
assert( MAX_TAB_ID == 80 );
assert( sizeof(int) == 4 ); /* for ct.lim.lam/phi */
memset( header, 0, sizeof(header) );
memcpy( header + 0, "CTABLE V2.0 ", 16 );
memcpy( header + 16, ct.id, 80 );
memcpy( header + 96, &ct.ll.lam, 8 );
memcpy( header + 104, &ct.ll.phi, 8 );
memcpy( header + 112, &ct.del.lam, 8 );
memcpy( header + 120, &ct.del.phi, 8 );
memcpy( header + 128, &ct.lim.lam, 4 );
memcpy( header + 132, &ct.lim.phi, 4 );
/* force into LSB format */
if( !IS_LSB )
{
swap_words( header + 96, 8, 4 );
swap_words( header + 128, 4, 2 );
swap_words( ct.cvs, 4, ct.lim.lam * 2 * ct.lim.phi );
}
if( fwrite( header, sizeof(header), 1, fp ) != 1 ) {
perror( "fwrite" );
exit( 2 );
}
if (fwrite(ct.cvs, tsize, 1, fp) != 1) {
perror( "fwrite" );
exit(2);
}
fclose( fp );
exit(0); /* normal completion */
}
/* ==================================================================== */
/* Write out the NTv2 format grid shift file. */
/* ==================================================================== */
if( strcmp(format,"ntv2") == 0 )
{
if (!(fp = fopen(output_file, "wb")))
{
perror(output_file);
exit(2);
}
/* -------------------------------------------------------------------- */
/* Write the file header. */
/* -------------------------------------------------------------------- */
{
char achHeader[11*16];
memset( achHeader, 0, sizeof(achHeader) );
memcpy( achHeader + 0*16, "NUM_OREC", 8 );
achHeader[ 0*16 + 8] = 0xb;
memcpy( achHeader + 1*16, "NUM_SREC", 8 );
achHeader[ 1*16 + 8] = 0xb;
memcpy( achHeader + 2*16, "NUM_FILE", 8 );
achHeader[ 2*16 + 8] = 0x1;
memcpy( achHeader + 3*16, "GS_TYPE ", 16 );
memcpy( achHeader + 3*16+8, GS_TYPE, MIN(16,strlen(GS_TYPE)) );
memcpy( achHeader + 4*16, "VERSION ", 16 );
memcpy( achHeader + 4*16+8, VERSION, MIN(16,strlen(VERSION)) );
memcpy( achHeader + 5*16, "SYSTEM_F ", 16 );
memcpy( achHeader + 5*16+8, SYSTEM_F, MIN(16,strlen(SYSTEM_F)) );
memcpy( achHeader + 6*16, "SYSTEM_T ", 16 );
memcpy( achHeader + 6*16+8, SYSTEM_T, MIN(16,strlen(SYSTEM_T)) );
memcpy( achHeader + 7*16, "MAJOR_F ", 8);
memcpy( achHeader + 8*16, "MINOR_F ", 8 );
memcpy( achHeader + 9*16, "MAJOR_T ", 8 );
memcpy( achHeader + 10*16, "MINOR_T ", 8 );
fwrite( achHeader, 1, sizeof(achHeader), fp );
}
/* -------------------------------------------------------------------- */
/* Write the grid header. */
/* -------------------------------------------------------------------- */
{
unsigned char achHeader[11*16];
double dfValue;
int nGSCount = ct.lim.lam * ct.lim.phi;
LP ur;
ur.lam = ct.ll.lam + (ct.lim.lam-1) * ct.del.lam;
ur.phi = ct.ll.phi + (ct.lim.phi-1) * ct.del.phi;
assert( sizeof(nGSCount) == 4 );
memset( achHeader, 0, sizeof(achHeader) );
memcpy( achHeader + 0*16, "SUB_NAME ", 16 );
memcpy( achHeader + 0*16+8, SUB_NAME, MIN(16,strlen(SUB_NAME)) );
memcpy( achHeader + 1*16, "PARENT ", 16 );
memcpy( achHeader + 1*16+8, "NONE", MIN(16,strlen("NONE")) );
memcpy( achHeader + 2*16, "CREATED ", 16 );
memcpy( achHeader + 2*16+8, CREATED, MIN(16,strlen(CREATED)) );
memcpy( achHeader + 3*16, "UPDATED ", 16 );
memcpy( achHeader + 3*16+8, UPDATED, MIN(16,strlen(UPDATED)) );
memcpy( achHeader + 4*16, "S_LAT ", 8 );
dfValue = ct.ll.phi * 3600.0 / DEG_TO_RAD;
memcpy( achHeader + 4*16 + 8, &dfValue, 8 );
memcpy( achHeader + 5*16, "N_LAT ", 8 );
dfValue = ur.phi * 3600.0 / DEG_TO_RAD;
memcpy( achHeader + 5*16 + 8, &dfValue, 8 );
memcpy( achHeader + 6*16, "E_LONG ", 8 );
dfValue = -1 * ur.lam * 3600.0 / DEG_TO_RAD;
memcpy( achHeader + 6*16 + 8, &dfValue, 8 );
memcpy( achHeader + 7*16, "W_LONG ", 8 );
dfValue = -1 * ct.ll.lam * 3600.0 / DEG_TO_RAD;
memcpy( achHeader + 7*16 + 8, &dfValue, 8 );
memcpy( achHeader + 8*16, "LAT_INC ", 8 );
dfValue = ct.del.phi * 3600.0 / DEG_TO_RAD;
memcpy( achHeader + 8*16 + 8, &dfValue, 8 );
memcpy( achHeader + 9*16, "LONG_INC", 8 );
dfValue = ct.del.lam * 3600.0 / DEG_TO_RAD;
memcpy( achHeader + 9*16 + 8, &dfValue, 8 );
memcpy( achHeader + 10*16, "GS_COUNT", 8 );
memcpy( achHeader + 10*16+8, &nGSCount, 4 );
if( !IS_LSB )
{
swap_words( achHeader + 4*16 + 8, 8, 1 );
swap_words( achHeader + 5*16 + 8, 8, 1 );
swap_words( achHeader + 6*16 + 8, 8, 1 );
swap_words( achHeader + 7*16 + 8, 8, 1 );
swap_words( achHeader + 8*16 + 8, 8, 1 );
swap_words( achHeader + 9*16 + 8, 8, 1 );
swap_words( achHeader + 10*16 + 8, 4, 1 );
}
fwrite( achHeader, 1, sizeof(achHeader), fp );
}
/* -------------------------------------------------------------------- */
/* Write the actual grid cells. */
/* -------------------------------------------------------------------- */
{
float *row_buf;
int row;
row_buf = (float *) pj_malloc(ct.lim.lam * sizeof(float) * 4);
memset( row_buf, 0, sizeof(float)*4 );
for( row = 0; row < ct.lim.phi; row++ )
{
int i;
for( i = 0; i < ct.lim.lam; i++ )
{
FLP *cvs = ct.cvs + (row) * ct.lim.lam
+ (ct.lim.lam - i - 1);
/* convert radians to seconds */
row_buf[i*4+0] = cvs->phi * (3600.0 / (PI/180.0));
row_buf[i*4+1] = cvs->lam * (3600.0 / (PI/180.0));
/* We leave the accuracy values as zero */
}
if( !IS_LSB )
swap_words( row_buf, 4, ct.lim.lam * 4 );
if( fwrite( row_buf, sizeof(float), ct.lim.lam*4, fp )
!= 4 * ct.lim.lam )
{
perror( "write()" );
exit( 2 );
}
}
}
fclose( fp );
exit(0); /* normal completion */
}
fprintf( stderr, "Unsupported format, nothing written.\n" );
exit( 3 );
}
