![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to FloppyRw CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / notes|
Return to FloppyRw CVS log | Up to [Apple Darwin 0.x] / driverkit / notes |
1.1 root 1: #define KVM_PUNT 1
2: #define REQUIRE_SECT_ALIGN 1 /* */
3:
4: static boolean_t fd_setup_rw_req(fd_volume_t fvp,
5: boolean_t bad_block_map) /* TRUE = check for remapping */
6: {
7: /* input: fvp->start_sect
8: * fvp->bytes_to_go
9: * fvp->start_addrs
10: * fvp->io_flags
11: * fvp->dev_ioreq.pmap
12: * fvp->dev_ioreq.map
13: * fvp->format_info
14: * output: fvp->current_sect
15: * fvp->current_byte_cnt
16: * fvp->current_addrs
17: * fvp->dev_ioreq
18: *
19: * This routine determines the largest "safe" I/O which can be
20: * performed starting at fvp->start_sect, up to a max of
21: * fvp->bytes_to_go bytes. The bad block table will only be consulted
22: * if bad_block_map is also TRUE.
23: *
24: * No I/O is allowed to go past a track boundary.
25: *
26: * Short writes (less than one sector) result in user data being
27: * copied to *fvp->sect_buf, memory for which is allocated here.
28: * DMA occurs out of this buffer. The buffer must be freed upon I/O
29: * complete.
30: *
31: * Parameters describing the resulting "safe" I/O are placed in
32: * fvp->current_sect and fvp->current_byte_cnt. An fd_rw_cmd is then
33: * generated and placed in fvp->dev_ioreq.cmd_blk[].
34: *
35: * Returns TRUE if mapping occurred.
36: */
37: struct fd_rw_cmd start_rw_cmd; /* first sector, phys params */
38: struct fd_format_info *fip = &fvp->format_info;
39: u_int sect_size = fip->sectsize_info.sect_size;
40: int num_sects = howmany(fvp->bytes_to_go, sect_size);
41: int bytes_to_xfr;
42: caddr_t start_addrs;
43:
44: XDBG(("fd_setup_rw_req: start_sect = %d\n", fvp->start_sect));
45: /*
46: * See if we'll wrap past a track boundary. Max sector number on
47: * a track is sects_per_trk, NOT sects_per_trk-1...
48: */
49: fd_log_2_phys(fvp, fvp->start_sect, &start_rw_cmd);
50: if((start_rw_cmd.sector + num_sects) >
51: (fip->sectsize_info.sects_per_trk+1)) {
52: num_sects = fip->sectsize_info.sects_per_trk -
53: start_rw_cmd.sector + 1;
54: bytes_to_xfr = num_sects * sect_size;
55: XDBG(("fd_setup_rw_req: track wrap: num_sects = %d\n",
56: num_sects));
57: }
58: else {
59: /*
60: * The whole I/O fits on one track.
61: */
62: bytes_to_xfr = fvp->bytes_to_go;
63: }
64: /*
65: * See if we have to deal with a partial sector.
66: */
67: start_addrs = fvp->start_addrs;
68: fvp->padded_byte_cnt = 0;
69: #ifdef REQUIRE_SECT_ALIGN
70: if(bytes_to_xfr & (sect_size - 1)) {
71: printf("fd%d: PARTIAL SECTOR I/O\n", fvp->volume_num);
72: }
73: short_write_out:
74:
75: fvp->current_sect = fvp->start_sect;
76: fvp->current_byte_cnt = bytes_to_xfr;
77: fvp->current_addrs = start_addrs;
78: fd_gen_rw_cmd(fvp,
79: &fvp->dev_ioreq,
80: fvp->current_sect,
81: fvp->current_byte_cnt,
82: fvp->current_addrs,
83: fvp->io_flags & FVIOF_READ);
84: return(FALSE);
85:
86: } /* fd_setup_rw_req() */
87:
88: /*
89: * generate a write or read command in *fdiop (No I/O).
90: */
91: static void fd_gen_rw_cmd(fd_volume_t fvp,
92: fd_ioreq_t fdiop,
93: u_int sector,
94: u_int byte_count,
95: caddr_t dma_addrs,
96: int read) /* non-zero ==> read */
97: {
98: struct fd_rw_cmd *cmdp = (struct fd_rw_cmd *)fdiop->cmd_blk;
99: struct fd_format_info *fip = &fvp->format_info;
100:
101: XADDBG(("fd_gen_rw_cmd: sector 0x%x byte_count 0x%x read = %d\n",
102: sector, byte_count, read));
103: bzero(cmdp, SIZEOF_RW_CMD);
104: fd_log_2_phys(fvp, sector, cmdp); /* assign track, head, sect */
105: cmdp->mt = 0; /* multitrack - always false */
106: cmdp->mfm = fip->density_info.mfm;
107: cmdp->opcode = read ? FCCMD_READ : FCCMD_WRITE;
108: cmdp->hds = cmdp->head;
109: /*
110: * controller thread writes drive_sel.
111: */
112: cmdp->sector_size = fip->sectsize_info.n;
113: /*
114: * eot = the number of the LAST sector to be read/written.
115: */
116: cmdp->eot = cmdp->sector + howmany(byte_count,
117: fip->sectsize_info.sect_size) - 1;
118: cmdp->gap_length = fip->sectsize_info.rw_gap_length;
119: cmdp->dtl = 0xff;
120:
121: fdiop->density = fip->density_info.density;
122: fdiop->timeout = TO_RW;
123: fdiop->command = FDCMD_CMD_XFR;
124: fdiop->num_cmd_bytes = SIZEOF_RW_CMD;
125: fdiop->addrs = dma_addrs;
126: fdiop->byte_count = byte_count;
127: fdiop->num_stat_bytes = SIZEOF_RW_STAT;
128: if(read)
129: fdiop->flags |= FD_IOF_DMA_RD;
130: else
131: fdiop->flags &= ~FD_IOF_DMA_RD;
132:
133: } /* fd_gen_rw_cmd() */
134:
135: /*
136: * convert logical sector # into cylinder, head, sector. No range checking.
137: * Physical parameters are obtained from *fvp->labelp and fvp->sects_per_track.
138: *
139: * First sector on a track is sector 1.
140: */
141: static void fd_log_2_phys(fd_volume_t fvp,
142: u_int sector,
143: struct fd_rw_cmd *cmdp)
144: {
145: u_int track;
146: struct fd_format_info *fip = &fvp->format_info;
147:
148: ASSERT((fip->sectsize_info.sects_per_trk != 0) &&
149: (fip->disk_info.tracks_per_cyl != 0));
150: track = sector / fip->sectsize_info.sects_per_trk;
151: cmdp->cylinder = track / fip->disk_info.tracks_per_cyl;
152: cmdp->head = track % fip->disk_info.tracks_per_cyl;
153: cmdp->sector = sector % fip->sectsize_info.sects_per_trk + 1;
154: XADDBG(("fd_log_2_phys: lsect 0x%x; cyl 0x%x head 0x%x sector "
155: "0x%x\n", sector, cmdp->cylinder, cmdp->head, cmdp->sector-1));
156: }
157:
158: ........................
159:
160: what we really want:
161:
162: /*
163: * Common r/w routine. The following fdBuf fields are required:
164: * block
165: * blockCnt
166: * buf
167: * client
168: * pending
169: *
170: * block and blockCnt are assumed to be already adjusted for overflow.
171: */
172: - (ioReturn_t)fdRwCommon : (fdBuf_t *)fdBuf
173: {
174: int currentBlock = fdBuf->block;
175: int blocksToGo = fdBuf->blockCnt;
176: char *currentBuf = fdBuf->buf;
177: int currentBlockCnt;
178: fdIoReq_t fdIoReq;
179: ioReturn_t rtn;
180: int block_size = [self getBlockSize];
181: boolean_t readFlag = fdBuf->command == FDC_READ ? TRUE : FALSE;
182:
183: xpr_fd("fdRwCommon: block 0x%x count 0x%x\n",
184: fdBuf->block, fdBuf->BlockCnt, 3,4,5);
185:
186: /*
187: * We never cross a track boundary while reading and writing. This
188: * loop is executed once for each segment.
189: */
190: while(blocksToGo) {
191:
192: /*
193: * Set up controller command block for current segment.
194: */
195: currentBlockCnt = [self rwBlockCount:currentBlock
196: blocksToGo:blocksToGo];
197: [self fdGenRwCmd:currentBlock
198: blockCount:currentBlockCnt
199: fdIoReq:&fdIoReq
200: read:readFlag];
201: fdIoReq->command = FDCMD_CMD_XFR;
202: fdIoReq->addrs = currentBuf;
203: fdIoReq->byte_count = currentBlockCnt * block_size;
204: rtn = [self fdSendCmd:&fdIoReq];
205:
206: /*
207: * OK, what happened?
208: */
209: }
210: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.