/*! \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; }