/*! \brief Write data to a logical block.
* \param vol - the parent volume.
* \param nSect - the location of the target block.
* \param buf - a buffer containing to the data to write.
* \return RC_OK or RC_ERROR.
*/
RETCODE adfWriteBlock(struct Volume* vol, long nSect, unsigned char *buf)
{
long pSect;
struct nativeFunctions *nFct;
RETCODE rc;
if (!vol->mounted) {
(*adfEnv.eFct)("the volume isn't mounted, adfWriteBlock not possible");
return RC_ERROR;
}
if (vol->readOnly) {
(*adfEnv.wFct)("adfWriteBlock : can't write block, read only volume");
return RC_ERROR;
}
pSect = nSect+vol->firstBlock;
#ifdef _DEBUG_PRINTF_
printf("write nsect=%ld psect=%ld\n",nSect,pSect);
#endif /*_DEBUG_PRINTF_*/
if (adfEnv.useRWAccess)
(*adfEnv.rwhAccess)(pSect,nSect,TRUE);
if (pSect<vol->firstBlock || pSect>vol->lastBlock) {
(*adfEnv.wFct)("adfWriteBlock : nSect out of range");
}
nFct = adfEnv.nativeFct;
#ifdef _DEBUG_PRINTF_
printf("nativ=%d\n",vol->dev->isNativeDev);
#endif /*_DEBUG_PRINTF_*/
if (vol->dev->isNativeDev)
rc = (*nFct->adfNativeWriteSector)(vol->dev, pSect, 512, buf);
else
rc = adfWriteDumpSector(vol->dev, pSect, 512, buf);
if (rc!=RC_OK)
return RC_ERROR;
else
return RC_OK;
}
/*
* adfWriteRDSKblock
*
*/
RETCODE
adfWriteRDSKblock(struct Device *dev, struct bRDSKblock* rdsk)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
struct nativeFunctions *nFct;
RETCODE rc2, rc = RC_OK;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWriteRDSKblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(rdsk->id,"RDSK",4);
rdsk->size = sizeof(struct bRDSKblock)/sizeof(int32_t);
rdsk->blockSize = LOGICAL_BLOCK_SIZE;
rdsk->badBlockList = -1;
strncpy(rdsk->diskVendor,"ADFlib ",8);
strncpy(rdsk->diskProduct,"harddisk.adf ",16);
strncpy(rdsk->diskRevision,"v1.0",4);
memcpy(buf, rdsk, sizeof(struct bRDSKblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_RDSK);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8, newSum);
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc2=(*nFct->adfNativeWriteSector)(dev, 0, LOGICAL_BLOCK_SIZE, buf);
else
rc2=adfWriteDumpSector(dev, 0, LOGICAL_BLOCK_SIZE, buf);
if (rc2!=RC_OK)
return RC_ERROR;
return rc;
}
/*
* adfWritePARTblock
*
*/
RETCODE
adfWritePARTblock(struct Device *dev, int32_t nSect, struct bPARTblock* part)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
struct nativeFunctions *nFct;
RETCODE rc2, rc = RC_OK;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWritePARTblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(part->id,"PART",4);
part->size = sizeof(struct bPARTblock)/sizeof(int32_t);
part->blockSize = LOGICAL_BLOCK_SIZE;
part->vectorSize = 16;
part->blockSize = 128;
part->sectorsPerBlock = 1;
part->dosReserved = 2;
memcpy(buf, part, sizeof(struct bPARTblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_PART);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8, newSum);
/* *(int32_t*)(buf+8) = swapLong((uint8_t*)&newSum);*/
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc2=(*nFct->adfNativeWriteSector)(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
else
rc2=adfWriteDumpSector(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
if (rc2!=RC_OK)
return RC_ERROR;
return rc;
}
/*
* adfWriteLSEGblock
*
*/
RETCODE
adfWriteLSEGblock(struct Device *dev, int32_t nSect, struct bLSEGblock* lseg)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
struct nativeFunctions *nFct;
RETCODE rc;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWriteLSEGblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(lseg->id,"LSEG",4);
lseg->size = sizeof(struct bLSEGblock)/sizeof(int32_t);
memcpy(buf, lseg, sizeof(struct bLSEGblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_LSEG);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8,newSum);
/* *(int32_t*)(buf+8) = swapLong((uint8_t*)&newSum);*/
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc=(*nFct->adfNativeWriteSector)(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
else
rc=adfWriteDumpSector(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
if (rc!=RC_OK)
return RC_ERROR;
return RC_OK;
}
/*
* adfWriteFSHDblock
*
*/
RETCODE
adfWriteFSHDblock(struct Device *dev, long nSect, struct bFSHDblock* fshd)
{
unsigned char buf[LOGICAL_BLOCK_SIZE];
unsigned long newSum;
struct nativeFunctions *nFct;
RETCODE rc = RC_OK;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWriteFSHDblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(fshd->id,"FSHD",4);
fshd->size = sizeof(struct bFSHDblock)/sizeof(long);
memcpy(buf, fshd, sizeof(struct bFSHDblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_FSHD);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8, newSum);
/* *(long*)(buf+8) = swapLong((unsigned char*)&newSum);*/
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc=(*nFct->adfNativeWriteSector)(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
else
rc=adfWriteDumpSector(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
if (rc!=RC_OK)
return RC_ERROR;
return RC_OK;
}
