]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright (C) 1993-1996 Bas Laarhoven, | |
3 | * (C) 1996-1997 Claus-Justus Heine. | |
4 | ||
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2, or (at your option) | |
8 | any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; see the file COPYING. If not, write to | |
17 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
18 | ||
19 | * | |
20 | * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-read.c,v $ | |
21 | * $Revision: 1.6 $ | |
22 | * $Date: 1997/10/21 14:39:22 $ | |
23 | * | |
24 | * This file contains the reading code | |
25 | * for the QIC-117 floppy-tape driver for Linux. | |
26 | * | |
27 | */ | |
28 | ||
29 | #include <linux/string.h> | |
30 | #include <linux/errno.h> | |
31 | #include <linux/mm.h> | |
32 | ||
33 | #include <linux/ftape.h> | |
34 | #include <linux/qic117.h> | |
35 | #include "../lowlevel/ftape-tracing.h" | |
36 | #include "../lowlevel/ftape-read.h" | |
37 | #include "../lowlevel/ftape-io.h" | |
38 | #include "../lowlevel/ftape-ctl.h" | |
39 | #include "../lowlevel/ftape-rw.h" | |
40 | #include "../lowlevel/ftape-write.h" | |
41 | #include "../lowlevel/ftape-ecc.h" | |
42 | #include "../lowlevel/ftape-bsm.h" | |
43 | ||
44 | /* Global vars. | |
45 | */ | |
46 | ||
47 | /* Local vars. | |
48 | */ | |
49 | ||
50 | void ftape_zap_read_buffers(void) | |
51 | { | |
52 | int i; | |
53 | ||
54 | for (i = 0; i < ft_nr_buffers; ++i) { | |
55 | /* changed to "fit" with dynamic allocation of tape_buffer. --khp */ | |
56 | ft_buffer[i]->status = waiting; | |
57 | ft_buffer[i]->bytes = 0; | |
58 | ft_buffer[i]->skip = 0; | |
59 | ft_buffer[i]->retry = 0; | |
60 | } | |
61 | /* ftape_reset_buffer(); */ | |
62 | } | |
63 | ||
64 | static SectorMap convert_sector_map(buffer_struct * buff) | |
65 | { | |
66 | int i = 0; | |
67 | SectorMap bad_map = ftape_get_bad_sector_entry(buff->segment_id); | |
68 | SectorMap src_map = buff->soft_error_map | buff->hard_error_map; | |
69 | SectorMap dst_map = 0; | |
70 | TRACE_FUN(ft_t_any); | |
71 | ||
72 | if (bad_map || src_map) { | |
73 | TRACE(ft_t_flow, "bad_map = 0x%08lx", (long) bad_map); | |
74 | TRACE(ft_t_flow, "src_map = 0x%08lx", (long) src_map); | |
75 | } | |
76 | while (bad_map) { | |
77 | while ((bad_map & 1) == 0) { | |
78 | if (src_map & 1) { | |
79 | dst_map |= (1 << i); | |
80 | } | |
81 | src_map >>= 1; | |
82 | bad_map >>= 1; | |
83 | ++i; | |
84 | } | |
85 | /* (bad_map & 1) == 1 */ | |
86 | src_map >>= 1; | |
87 | bad_map >>= 1; | |
88 | } | |
89 | if (src_map) { | |
90 | dst_map |= (src_map << i); | |
91 | } | |
92 | if (dst_map) { | |
93 | TRACE(ft_t_flow, "dst_map = 0x%08lx", (long) dst_map); | |
94 | } | |
95 | TRACE_EXIT dst_map; | |
96 | } | |
97 | ||
98 | static int correct_and_copy_fraction(buffer_struct *buff, __u8 * destination, | |
99 | int start, int size) | |
100 | { | |
101 | struct memory_segment mseg; | |
102 | int result; | |
103 | SectorMap read_bad; | |
104 | TRACE_FUN(ft_t_any); | |
105 | ||
106 | mseg.read_bad = convert_sector_map(buff); | |
107 | mseg.marked_bad = 0; /* not used... */ | |
108 | mseg.blocks = buff->bytes / FT_SECTOR_SIZE; | |
109 | mseg.data = buff->address; | |
110 | /* If there are no data sectors we can skip this segment. | |
111 | */ | |
112 | if (mseg.blocks <= 3) { | |
113 | TRACE_ABORT(0, ft_t_noise, "empty segment"); | |
114 | } | |
115 | read_bad = mseg.read_bad; | |
116 | ft_history.crc_errors += count_ones(read_bad); | |
117 | result = ftape_ecc_correct_data(&mseg); | |
118 | if (read_bad != 0 || mseg.corrected != 0) { | |
119 | TRACE(ft_t_noise, "crc error map: 0x%08lx", (unsigned long)read_bad); | |
120 | TRACE(ft_t_noise, "corrected map: 0x%08lx", (unsigned long)mseg.corrected); | |
121 | ft_history.corrected += count_ones(mseg.corrected); | |
122 | } | |
123 | if (result == ECC_CORRECTED || result == ECC_OK) { | |
124 | if (result == ECC_CORRECTED) { | |
125 | TRACE(ft_t_info, "ecc corrected segment: %d", buff->segment_id); | |
126 | } | |
127 | if(start < 0) { | |
128 | start= 0; | |
129 | } | |
130 | if((start+size) > ((mseg.blocks - 3) * FT_SECTOR_SIZE)) { | |
131 | size = (mseg.blocks - 3) * FT_SECTOR_SIZE - start; | |
132 | } | |
133 | if (size < 0) { | |
134 | size= 0; | |
135 | } | |
136 | if(size > 0) { | |
137 | memcpy(destination + start, mseg.data + start, size); | |
138 | } | |
139 | if ((read_bad ^ mseg.corrected) & mseg.corrected) { | |
140 | /* sectors corrected without crc errors set */ | |
141 | ft_history.crc_failures++; | |
142 | } | |
143 | TRACE_EXIT size; /* (mseg.blocks - 3) * FT_SECTOR_SIZE; */ | |
144 | } else { | |
145 | ft_history.ecc_failures++; | |
146 | TRACE_ABORT(-EAGAIN, | |
147 | ft_t_err, "ecc failure on segment %d", | |
148 | buff->segment_id); | |
149 | } | |
150 | TRACE_EXIT 0; | |
151 | } | |
152 | ||
153 | /* Read given segment into buffer at address. | |
154 | */ | |
155 | int ftape_read_segment_fraction(const int segment_id, | |
156 | void *address, | |
157 | const ft_read_mode_t read_mode, | |
158 | const int start, | |
159 | const int size) | |
160 | { | |
161 | int result = 0; | |
162 | int retry = 0; | |
163 | int bytes_read = 0; | |
164 | int read_done = 0; | |
165 | TRACE_FUN(ft_t_flow); | |
166 | ||
167 | ft_history.used |= 1; | |
168 | TRACE(ft_t_data_flow, "segment_id = %d", segment_id); | |
169 | if (ft_driver_state != reading) { | |
170 | TRACE(ft_t_noise, "calling ftape_abort_operation"); | |
171 | TRACE_CATCH(ftape_abort_operation(),); | |
172 | ftape_set_state(reading); | |
173 | } | |
174 | for(;;) { | |
175 | buffer_struct *tail; | |
176 | /* Allow escape from this loop on signal ! | |
177 | */ | |
178 | FT_SIGNAL_EXIT(_DONT_BLOCK); | |
179 | /* Search all full buffers for the first matching the | |
180 | * wanted segment. Clear other buffers on the fly. | |
181 | */ | |
182 | tail = ftape_get_buffer(ft_queue_tail); | |
183 | while (!read_done && tail->status == done) { | |
184 | /* Allow escape from this loop on signal ! | |
185 | */ | |
186 | FT_SIGNAL_EXIT(_DONT_BLOCK); | |
187 | if (tail->segment_id == segment_id) { | |
188 | /* If out buffer is already full, | |
189 | * return its contents. | |
190 | */ | |
191 | TRACE(ft_t_flow, "found segment in cache: %d", | |
192 | segment_id); | |
193 | if (tail->deleted) { | |
194 | /* Return a value that | |
195 | * read_header_segment | |
196 | * understands. As this | |
197 | * should only occur when | |
198 | * searching for the header | |
199 | * segments it shouldn't be | |
200 | * misinterpreted elsewhere. | |
201 | */ | |
202 | TRACE_EXIT 0; | |
203 | } | |
204 | result = correct_and_copy_fraction( | |
205 | tail, | |
206 | address, | |
207 | start, | |
208 | size); | |
209 | TRACE(ft_t_flow, "segment contains (bytes): %d", | |
210 | result); | |
211 | if (result < 0) { | |
212 | if (result != -EAGAIN) { | |
213 | TRACE_EXIT result; | |
214 | } | |
215 | /* keep read_done == 0, will | |
216 | * trigger | |
217 | * ftape_abort_operation | |
218 | * because reading wrong | |
219 | * segment. | |
220 | */ | |
221 | TRACE(ft_t_err, "ecc failed, retry"); | |
222 | ++retry; | |
223 | } else { | |
224 | read_done = 1; | |
225 | bytes_read = result; | |
226 | } | |
227 | } else { | |
228 | TRACE(ft_t_flow,"zapping segment in cache: %d", | |
229 | tail->segment_id); | |
230 | } | |
231 | tail->status = waiting; | |
232 | tail = ftape_next_buffer(ft_queue_tail); | |
233 | } | |
234 | if (!read_done && tail->status == reading) { | |
235 | if (tail->segment_id == segment_id) { | |
236 | switch(ftape_wait_segment(reading)) { | |
237 | case 0: | |
238 | break; | |
239 | case -EINTR: | |
240 | TRACE_ABORT(-EINTR, ft_t_warn, | |
241 | "interrupted by " | |
242 | "non-blockable signal"); | |
243 | break; | |
244 | default: | |
245 | TRACE(ft_t_noise, | |
246 | "wait_segment failed"); | |
247 | ftape_abort_operation(); | |
248 | ftape_set_state(reading); | |
249 | break; | |
250 | } | |
251 | } else { | |
252 | /* We're reading the wrong segment, | |
253 | * stop runner. | |
254 | */ | |
255 | TRACE(ft_t_noise, "reading wrong segment"); | |
256 | ftape_abort_operation(); | |
257 | ftape_set_state(reading); | |
258 | } | |
259 | } | |
260 | /* should runner stop ? | |
261 | */ | |
262 | if (ft_runner_status == aborting) { | |
263 | buffer_struct *head = ftape_get_buffer(ft_queue_head); | |
264 | switch(head->status) { | |
265 | case error: | |
266 | ft_history.defects += | |
267 | count_ones(head->hard_error_map); | |
268 | case reading: | |
269 | head->status = waiting; | |
270 | break; | |
271 | default: | |
272 | break; | |
273 | } | |
274 | TRACE_CATCH(ftape_dumb_stop(),); | |
275 | } else { | |
276 | /* If just passed last segment on tape: wait | |
277 | * for BOT or EOT mark. Sets ft_runner_status to | |
278 | * idle if at lEOT and successful | |
279 | */ | |
280 | TRACE_CATCH(ftape_handle_logical_eot(),); | |
281 | } | |
282 | /* If we got a segment: quit, or else retry up to limit. | |
283 | * | |
284 | * If segment to read is empty, do not start runner for it, | |
285 | * but wait for next read call. | |
286 | */ | |
287 | if (read_done || | |
288 | ftape_get_bad_sector_entry(segment_id) == EMPTY_SEGMENT ) { | |
289 | /* bytes_read = 0; should still be zero */ | |
290 | TRACE_EXIT bytes_read; | |
291 | ||
292 | } | |
293 | if (retry > FT_RETRIES_ON_ECC_ERROR) { | |
294 | ft_history.defects++; | |
295 | TRACE_ABORT(-ENODATA, ft_t_err, | |
296 | "too many retries on ecc failure"); | |
297 | } | |
298 | /* Now at least one buffer is empty ! | |
299 | * Restart runner & tape if needed. | |
300 | */ | |
301 | TRACE(ft_t_any, "head: %d, tail: %d, ft_runner_status: %d", | |
302 | ftape_buffer_id(ft_queue_head), | |
303 | ftape_buffer_id(ft_queue_tail), | |
304 | ft_runner_status); | |
305 | TRACE(ft_t_any, "buffer[].status, [head]: %d, [tail]: %d", | |
306 | ftape_get_buffer(ft_queue_head)->status, | |
307 | ftape_get_buffer(ft_queue_tail)->status); | |
308 | tail = ftape_get_buffer(ft_queue_tail); | |
309 | if (tail->status == waiting) { | |
310 | buffer_struct *head = ftape_get_buffer(ft_queue_head); | |
311 | ||
312 | ftape_setup_new_segment(head, segment_id, -1); | |
313 | if (read_mode == FT_RD_SINGLE) { | |
314 | /* disable read-ahead */ | |
315 | head->next_segment = 0; | |
316 | } | |
317 | ftape_calc_next_cluster(head); | |
318 | if (ft_runner_status == idle) { | |
319 | result = ftape_start_tape(segment_id, | |
320 | head->sector_offset); | |
321 | if (result < 0) { | |
322 | TRACE_ABORT(result, ft_t_err, "Error: " | |
323 | "segment %d unreachable", | |
324 | segment_id); | |
325 | } | |
326 | } | |
327 | head->status = reading; | |
328 | fdc_setup_read_write(head, FDC_READ); | |
329 | } | |
330 | } | |
331 | /* not reached */ | |
332 | TRACE_EXIT -EIO; | |
333 | } | |
334 | ||
335 | int ftape_read_header_segment(__u8 *address) | |
336 | { | |
337 | int result; | |
338 | int header_segment; | |
339 | int first_failed = 0; | |
340 | int status; | |
341 | TRACE_FUN(ft_t_flow); | |
342 | ||
343 | ft_used_header_segment = -1; | |
344 | TRACE_CATCH(ftape_report_drive_status(&status),); | |
345 | TRACE(ft_t_flow, "reading..."); | |
346 | /* We're looking for the first header segment. | |
347 | * A header segment cannot contain bad sectors, therefor at the | |
348 | * tape start, segments with bad sectors are (according to QIC-40/80) | |
349 | * written with deleted data marks and must be skipped. | |
350 | */ | |
351 | memset(address, '\0', (FT_SECTORS_PER_SEGMENT - 3) * FT_SECTOR_SIZE); | |
352 | result = 0; | |
353 | #define HEADER_SEGMENT_BOUNDARY 68 /* why not 42? */ | |
354 | for (header_segment = 0; | |
355 | header_segment < HEADER_SEGMENT_BOUNDARY && result == 0; | |
356 | ++header_segment) { | |
357 | /* Set no read-ahead, the isr will force read-ahead whenever | |
358 | * it encounters deleted data ! | |
359 | */ | |
360 | result = ftape_read_segment(header_segment, | |
361 | address, | |
362 | FT_RD_SINGLE); | |
363 | if (result < 0 && !first_failed) { | |
364 | TRACE(ft_t_err, "header segment damaged, trying backup"); | |
365 | first_failed = 1; | |
366 | result = 0; /* force read of next (backup) segment */ | |
367 | } | |
368 | } | |
369 | if (result < 0 || header_segment >= HEADER_SEGMENT_BOUNDARY) { | |
370 | TRACE_ABORT(-EIO, ft_t_err, | |
371 | "no readable header segment found"); | |
372 | } | |
373 | TRACE_CATCH(ftape_abort_operation(),); | |
374 | ft_used_header_segment = header_segment; | |
375 | result = ftape_decode_header_segment(address); | |
376 | TRACE_EXIT result; | |
377 | } | |
378 | ||
379 | int ftape_decode_header_segment(__u8 *address) | |
380 | { | |
381 | unsigned int max_floppy_side; | |
382 | unsigned int max_floppy_track; | |
383 | unsigned int max_floppy_sector; | |
384 | unsigned int new_tape_len; | |
385 | TRACE_FUN(ft_t_flow); | |
386 | ||
387 | if (GET4(address, FT_SIGNATURE) == FT_D2G_MAGIC) { | |
388 | /* Ditto 2GB header segment. They encrypt the bad sector map. | |
389 | * We decrypt it and store them in normal format. | |
390 | * I hope this is correct. | |
391 | */ | |
392 | int i; | |
393 | TRACE(ft_t_warn, | |
394 | "Found Ditto 2GB tape, " | |
395 | "trying to decrypt bad sector map"); | |
396 | for (i=256; i < 29 * FT_SECTOR_SIZE; i++) { | |
397 | address[i] = ~(address[i] - (i&0xff)); | |
398 | } | |
399 | PUT4(address, 0,FT_HSEG_MAGIC); | |
400 | } else if (GET4(address, FT_SIGNATURE) != FT_HSEG_MAGIC) { | |
401 | TRACE_ABORT(-EIO, ft_t_err, | |
402 | "wrong signature in header segment"); | |
403 | } | |
404 | ft_format_code = (ft_format_type) address[FT_FMT_CODE]; | |
405 | if (ft_format_code != fmt_big) { | |
406 | ft_header_segment_1 = GET2(address, FT_HSEG_1); | |
407 | ft_header_segment_2 = GET2(address, FT_HSEG_2); | |
408 | ft_first_data_segment = GET2(address, FT_FRST_SEG); | |
409 | ft_last_data_segment = GET2(address, FT_LAST_SEG); | |
410 | } else { | |
411 | ft_header_segment_1 = GET4(address, FT_6_HSEG_1); | |
412 | ft_header_segment_2 = GET4(address, FT_6_HSEG_2); | |
413 | ft_first_data_segment = GET4(address, FT_6_FRST_SEG); | |
414 | ft_last_data_segment = GET4(address, FT_6_LAST_SEG); | |
415 | } | |
416 | TRACE(ft_t_noise, "first data segment: %d", ft_first_data_segment); | |
417 | TRACE(ft_t_noise, "last data segment: %d", ft_last_data_segment); | |
418 | TRACE(ft_t_noise, "header segments are %d and %d", | |
419 | ft_header_segment_1, ft_header_segment_2); | |
420 | ||
421 | /* Verify tape parameters... | |
422 | * QIC-40/80 spec: tape_parameters: | |
423 | * | |
424 | * segments-per-track segments_per_track | |
425 | * tracks-per-cartridge tracks_per_tape | |
426 | * max-floppy-side (segments_per_track * | |
427 | * tracks_per_tape - 1) / | |
428 | * ftape_segments_per_head | |
429 | * max-floppy-track ftape_segments_per_head / | |
430 | * ftape_segments_per_cylinder - 1 | |
431 | * max-floppy-sector ftape_segments_per_cylinder * | |
432 | * FT_SECTORS_PER_SEGMENT | |
433 | */ | |
434 | ft_segments_per_track = GET2(address, FT_SPT); | |
435 | ft_tracks_per_tape = address[FT_TPC]; | |
436 | max_floppy_side = address[FT_FHM]; | |
437 | max_floppy_track = address[FT_FTM]; | |
438 | max_floppy_sector = address[FT_FSM]; | |
439 | TRACE(ft_t_noise, "(fmt/spt/tpc/fhm/ftm/fsm) = %d/%d/%d/%d/%d/%d", | |
440 | ft_format_code, ft_segments_per_track, ft_tracks_per_tape, | |
441 | max_floppy_side, max_floppy_track, max_floppy_sector); | |
442 | new_tape_len = ftape_tape_len; | |
443 | switch (ft_format_code) { | |
444 | case fmt_425ft: | |
445 | new_tape_len = 425; | |
446 | break; | |
447 | case fmt_normal: | |
448 | if (ftape_tape_len == 0) { /* otherwise 307 ft */ | |
449 | new_tape_len = 205; | |
450 | } | |
451 | break; | |
452 | case fmt_1100ft: | |
453 | new_tape_len = 1100; | |
454 | break; | |
455 | case fmt_var:{ | |
456 | int segments_per_1000_inch = 1; /* non-zero default for switch */ | |
457 | switch (ft_qic_std) { | |
458 | case QIC_TAPE_QIC40: | |
459 | segments_per_1000_inch = 332; | |
460 | break; | |
461 | case QIC_TAPE_QIC80: | |
462 | segments_per_1000_inch = 488; | |
463 | break; | |
464 | case QIC_TAPE_QIC3010: | |
465 | segments_per_1000_inch = 730; | |
466 | break; | |
467 | case QIC_TAPE_QIC3020: | |
468 | segments_per_1000_inch = 1430; | |
469 | break; | |
470 | } | |
471 | new_tape_len = (1000 * ft_segments_per_track + | |
472 | (segments_per_1000_inch - 1)) / segments_per_1000_inch; | |
473 | break; | |
474 | } | |
475 | case fmt_big:{ | |
476 | int segments_per_1000_inch = 1; /* non-zero default for switch */ | |
477 | switch (ft_qic_std) { | |
478 | case QIC_TAPE_QIC40: | |
479 | segments_per_1000_inch = 332; | |
480 | break; | |
481 | case QIC_TAPE_QIC80: | |
482 | segments_per_1000_inch = 488; | |
483 | break; | |
484 | case QIC_TAPE_QIC3010: | |
485 | segments_per_1000_inch = 730; | |
486 | break; | |
487 | case QIC_TAPE_QIC3020: | |
488 | segments_per_1000_inch = 1430; | |
489 | break; | |
490 | default: | |
491 | TRACE_ABORT(-EIO, ft_t_bug, | |
492 | "%x QIC-standard with fmt-code %d, please report", | |
493 | ft_qic_std, ft_format_code); | |
494 | } | |
495 | new_tape_len = ((1000 * ft_segments_per_track + | |
496 | (segments_per_1000_inch - 1)) / | |
497 | segments_per_1000_inch); | |
498 | break; | |
499 | } | |
500 | default: | |
501 | TRACE_ABORT(-EIO, ft_t_err, | |
502 | "unknown tape format, please report !"); | |
503 | } | |
504 | if (new_tape_len != ftape_tape_len) { | |
505 | ftape_tape_len = new_tape_len; | |
506 | TRACE(ft_t_info, "calculated tape length is %d ft", | |
507 | ftape_tape_len); | |
508 | ftape_calc_timeouts(ft_qic_std, ft_data_rate, ftape_tape_len); | |
509 | } | |
510 | if (ft_segments_per_track == 0 && ft_tracks_per_tape == 0 && | |
511 | max_floppy_side == 0 && max_floppy_track == 0 && | |
512 | max_floppy_sector == 0) { | |
513 | /* QIC-40 Rev E and earlier has no values in the header. | |
514 | */ | |
515 | ft_segments_per_track = 68; | |
516 | ft_tracks_per_tape = 20; | |
517 | max_floppy_side = 1; | |
518 | max_floppy_track = 169; | |
519 | max_floppy_sector = 128; | |
520 | } | |
521 | /* This test will compensate for the wrong parameter on tapes | |
522 | * formatted by Conner software. | |
523 | */ | |
524 | if (ft_segments_per_track == 150 && | |
525 | ft_tracks_per_tape == 28 && | |
526 | max_floppy_side == 7 && | |
527 | max_floppy_track == 149 && | |
528 | max_floppy_sector == 128) { | |
529 | TRACE(ft_t_info, "the famous CONNER bug: max_floppy_side off by one !"); | |
530 | max_floppy_side = 6; | |
531 | } | |
532 | /* These tests will compensate for the wrong parameter on tapes | |
533 | * formatted by ComByte Windows software. | |
534 | * | |
535 | * First, for 205 foot tapes | |
536 | */ | |
537 | if (ft_segments_per_track == 100 && | |
538 | ft_tracks_per_tape == 28 && | |
539 | max_floppy_side == 9 && | |
540 | max_floppy_track == 149 && | |
541 | max_floppy_sector == 128) { | |
542 | TRACE(ft_t_info, "the ComByte bug: max_floppy_side incorrect!"); | |
543 | max_floppy_side = 4; | |
544 | } | |
545 | /* Next, for 307 foot tapes. */ | |
546 | if (ft_segments_per_track == 150 && | |
547 | ft_tracks_per_tape == 28 && | |
548 | max_floppy_side == 9 && | |
549 | max_floppy_track == 149 && | |
550 | max_floppy_sector == 128) { | |
551 | TRACE(ft_t_info, "the ComByte bug: max_floppy_side incorrect!"); | |
552 | max_floppy_side = 6; | |
553 | } | |
554 | /* This test will compensate for the wrong parameter on tapes | |
555 | * formatted by Colorado Windows software. | |
556 | */ | |
557 | if (ft_segments_per_track == 150 && | |
558 | ft_tracks_per_tape == 28 && | |
559 | max_floppy_side == 6 && | |
560 | max_floppy_track == 150 && | |
561 | max_floppy_sector == 128) { | |
562 | TRACE(ft_t_info, "the famous Colorado bug: max_floppy_track off by one !"); | |
563 | max_floppy_track = 149; | |
564 | } | |
565 | ftape_segments_per_head = ((max_floppy_sector/FT_SECTORS_PER_SEGMENT) * | |
566 | (max_floppy_track + 1)); | |
567 | /* This test will compensate for some bug reported by Dima | |
568 | * Brodsky. Seems to be a Colorado bug, either. (freebee | |
569 | * Imation tape shipped together with Colorado T3000 | |
570 | */ | |
571 | if ((ft_format_code == fmt_var || ft_format_code == fmt_big) && | |
572 | ft_tracks_per_tape == 50 && | |
573 | max_floppy_side == 54 && | |
574 | max_floppy_track == 255 && | |
575 | max_floppy_sector == 128) { | |
576 | TRACE(ft_t_info, "the famous ??? bug: max_floppy_track off by one !"); | |
577 | max_floppy_track = 254; | |
578 | } | |
579 | /* | |
580 | * Verify drive_configuration with tape parameters | |
581 | */ | |
582 | if (ftape_segments_per_head == 0 || ftape_segments_per_cylinder == 0 || | |
583 | ((ft_segments_per_track * ft_tracks_per_tape - 1) / ftape_segments_per_head | |
584 | != max_floppy_side) || | |
585 | (ftape_segments_per_head / ftape_segments_per_cylinder - 1 != max_floppy_track) || | |
586 | (ftape_segments_per_cylinder * FT_SECTORS_PER_SEGMENT != max_floppy_sector) | |
587 | #ifdef TESTING | |
588 | || ((ft_format_code == fmt_var || ft_format_code == fmt_big) && | |
589 | (max_floppy_track != 254 || max_floppy_sector != 128)) | |
590 | #endif | |
591 | ) { | |
592 | char segperheadz = ftape_segments_per_head ? ' ' : '?'; | |
593 | char segpercylz = ftape_segments_per_cylinder ? ' ' : '?'; | |
594 | TRACE(ft_t_err,"Tape parameters inconsistency, please report"); | |
595 | TRACE(ft_t_err, "reported = %d/%d/%d/%d/%d/%d", | |
596 | ft_format_code, | |
597 | ft_segments_per_track, | |
598 | ft_tracks_per_tape, | |
599 | max_floppy_side, | |
600 | max_floppy_track, | |
601 | max_floppy_sector); | |
602 | TRACE(ft_t_err, "required = %d/%d/%d/%d%c/%d%c/%d", | |
603 | ft_format_code, | |
604 | ft_segments_per_track, | |
605 | ft_tracks_per_tape, | |
606 | ftape_segments_per_head ? | |
607 | ((ft_segments_per_track * ft_tracks_per_tape -1) / | |
608 | ftape_segments_per_head ) : | |
609 | (ft_segments_per_track * ft_tracks_per_tape -1), | |
610 | segperheadz, | |
611 | ftape_segments_per_cylinder ? | |
612 | (ftape_segments_per_head / | |
613 | ftape_segments_per_cylinder - 1 ) : | |
614 | ftape_segments_per_head - 1, | |
615 | segpercylz, | |
616 | (ftape_segments_per_cylinder * FT_SECTORS_PER_SEGMENT)); | |
617 | TRACE_EXIT -EIO; | |
618 | } | |
619 | ftape_extract_bad_sector_map(address); | |
620 | TRACE_EXIT 0; | |
621 | } |