home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #1 / NN_1993_1.iso / spool / comp / os / linux / 23197 < prev    next >
Encoding:
Internet Message Format  |  1993-01-08  |  13.4 KB
  1. Path: sparky!uunet!mcsun!Germany.EU.net!urmel.informatik.rwth-aachen.de!kaa!heiko
  2. From: heiko@kaa.informatik.rwth-aachen.de (Heiko Schroeder)
  3. Newsgroups: comp.os.linux
  4. Subject: nonstandard floppy formats for linux
  5. Date: 8 Jan 93 10:02:48 GMT
  6. Organization: Rechnerbetrieb Informatik - RWTH Aachen
  7. Lines: 392
  8. Message-ID: <heiko.726487368@kaa>
  9. NNTP-Posting-Host: kaa.informatik.rwth-aachen.de
  10.  
  11. Hi,
  12.  
  13. for all of you who are not satisfied with 1.44MB on 3.5" floppy disk:
  14.  
  15. I patched the linux kernel so that I can use the formats known from the
  16. MS-DOS program fdformat. The formats are established with new device numbers,
  17. so that you can create dev-entries for them. Autodetection works, but there's
  18. one (minor) problem: some of the formats use more than 80 tracks, this is
  19. not detectable with reasonable effort (one would have to try to read the tracks
  20. 81,82,83 to find out if they exist, but I think, that's to much to slow).
  21. So I used a new variable in the main Makefile to decide which number of 
  22. tracks the autodetection routine should assume. You have to edit the Makefile
  23. to change this (I use FD_detect_83).
  24.  
  25. The new formats supported are:
  26. 3,5": 21 sectors, 80 tracks, 1.68MB, device 11
  27.       21 sectors, 82 tracks, 1.72MB, device 15
  28.       21 sectors, 83 tracks, 1.74MB, device 19
  29.       10 sectors, 80 tracks, 800k, device 9
  30.       10 sectors, 82 tracks, 820k, device 13
  31.       10 sectors, 83 tracks, 830k, device 17
  32. 5,25" HD:
  33.       18 sectors, 80 tracks, 1.44MB, device 10
  34.       18 sectors, 82 tracks, 1.48MB, device 14
  35.       18 sectors, 83 tracks, 1.59MB, device 18
  36.       10 sectors, 40 tracks, 400k, device 8
  37.       10 sectors, 41 tracks, 410k, device 12
  38.       10 sectors, 42 tracks, 420k, device 16
  39.  
  40. Minor device numbers are calculated as ususal:
  41.    device * 4 + drive number
  42. So a 1.74MB format for drive 0 would be set with
  43.   mknod /dev/fd0h1743 b 2 76
  44.  
  45. It works fine on my system and on a few other system, too, but I can't
  46. guarantee that it will work on other systems (but I think it should).
  47.  
  48. The files Makefile, boot/head.S and kernel/blk_drv/floppy.c are affected
  49. by the patch, so it should work with earlier versions of linux, but some
  50. editing may be needed.
  51. Here is the patch (for linux 0.99pl2):
  52. -------------------------------------------------------------------------
  53. *** Makefile.old    Fri Jan  1 21:45:57 1993
  54. --- Makefile    Thu Jan  7 18:00:38 1993
  55. ***************
  56. *** 71,80 ****
  57.   SOUND_SUPPORT = -DKERNEL_SOUNDCARD -DDSP_BUFFSIZE=16384 -DSBC_IRQ=7 -DPAS_IRQ=5
  58.   
  59.   #
  60.   # standard CFLAGS
  61.   #
  62.   
  63. ! CFLAGS = -Wall -O6 -fomit-frame-pointer
  64.   
  65.   ifdef CONFIG_M486
  66.   CFLAGS := $(CFLAGS) -m486
  67. --- 71,92 ----
  68.   SOUND_SUPPORT = -DKERNEL_SOUNDCARD -DDSP_BUFFSIZE=16384 -DSBC_IRQ=7 -DPAS_IRQ=5
  69.   
  70.   #
  71. + # As we can't detect the number of tracks on a floppy disk with in
  72. + # reasonable time, there is variable, which tells the autodetect routine
  73. + # how many tracks it should assume. This aplies only to the nonstandard
  74. + # formats!
  75. + #     FD_detect_82     assume 82 tracks
  76. + #     FD_detect_83     assume 83 tracks
  77. + #     (none)           assume 80 tracks, default
  78. + #
  79. + 
  80. + FD_DETECT=-DFD_detect_83
  81. + 
  82. + #
  83.   # standard CFLAGS
  84.   #
  85.   
  86. ! CFLAGS = -Wall -O6 -fomit-frame-pointer $(FD_DETECT) 
  87.   
  88.   ifdef CONFIG_M486
  89.   CFLAGS := $(CFLAGS) -m486
  90. *** boot/head.S.old    Fri Jan  1 21:45:58 1993
  91. --- boot/head.S    Thu Jan  7 14:37:31 1993
  92. ***************
  93. *** 215,224 ****
  94.    * floppy_track_buffer is used to buffer one track of floppy data: it
  95.    * has to be separate from the tmp_floppy area, as otherwise a single-
  96.    * sector read/write can mess it up. It can contain one full track of
  97. !  * data (18*2*512 bytes).
  98.    */
  99.   _floppy_track_buffer:
  100. !     .fill 512*2*18,1,0
  101.   
  102.   /* This is the default interrupt "handler" :-) */
  103.   int_msg:
  104. --- 215,224 ----
  105.    * floppy_track_buffer is used to buffer one track of floppy data: it
  106.    * has to be separate from the tmp_floppy area, as otherwise a single-
  107.    * sector read/write can mess it up. It can contain one full track of
  108. !  * data (21*2*512 bytes).
  109.    */
  110.   _floppy_track_buffer:
  111. !     .fill 512*2*21,1,0
  112.   
  113.   /* This is the default interrupt "handler" :-) */
  114.   int_msg:
  115. *** kernel/blk_drv/floppy.c.old    Fri Dec 11 11:15:23 1992
  116. --- kernel/blk_drv/floppy.c    Thu Jan  7 14:37:45 1993
  117. ***************
  118. *** 103,115 ****
  119.    * Maximum disk size (in kilobytes). This default is used whenever the
  120.    * current disk size is unknown.
  121.    */
  122. ! #define MAX_DISK_SIZE 1440
  123.   
  124.   /*
  125.    * Maximum number of sectors in a track buffer. Track buffering is disabled
  126.    * if tracks are bigger.
  127.    */
  128. ! #define MAX_BUFFER_SECTORS 18
  129.   
  130.   /*
  131.    * The DMA channel used by the floppy controller cannot access data at
  132. --- 103,115 ----
  133.    * Maximum disk size (in kilobytes). This default is used whenever the
  134.    * current disk size is unknown.
  135.    */
  136. ! #define MAX_DISK_SIZE 1743
  137.   
  138.   /*
  139.    * Maximum number of sectors in a track buffer. Track buffering is disabled
  140.    * if tracks are bigger.
  141.    */
  142. ! #define MAX_BUFFER_SECTORS 21
  143.   
  144.   /*
  145.    * The DMA channel used by the floppy controller cannot access data at
  146. ***************
  147. *** 135,171 ****
  148.    * be self-explanatory.
  149.    */
  150.   static struct floppy_struct floppy_type[] = {
  151. !     {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL },    /* no testing */
  152. !     {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,NULL },    /* 360kB PC diskettes */
  153. !     { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,NULL },    /* 1.2 MB AT-diskettes */
  154. !     {  720, 9,2,40,1,0x2A,0x02,0xDF,0x50,NULL },    /* 360kB in 720kB drive */
  155. !     { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,NULL },    /* 3.5" 720kB diskette */
  156. !     {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,NULL },    /* 360kB in 1.2MB drive */
  157. !     { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,NULL },    /* 720kB in 1.2MB drive */
  158. !     { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,NULL },    /* 1.44MB diskette */
  159.   };
  160.   
  161.   /*
  162. !  * Auto-detection. Each drive type has a pair of formats which are
  163.    * used in succession to try to read the disk. If the FDC cannot lock onto
  164.    * the disk, the next format is tried. This uses the variable 'probing'.
  165.    */
  166. ! static struct floppy_struct floppy_types[] = {
  167. !     {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"360k/PC" }, /* 360kB PC diskettes */
  168. !     {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"360k/PC" }, /* 360kB PC diskettes */
  169. !     { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"1.2M" },      /* 1.2 MB AT-diskettes */
  170. !     {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"360k/AT" }, /* 360kB in 1.2MB drive */
  171. !     { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k" },      /* 3.5" 720kB diskette */
  172. !     { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k" },      /* 3.5" 720kB diskette */
  173. !     { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"1.44M" },      /* 1.44MB diskette */
  174. !     { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k/AT" }, /* 3.5" 720kB diskette */
  175. ! };
  176.   
  177.   /* Auto-detection: Disk type used until the next media change occurs. */
  178.   struct floppy_struct *current_type[4] = { NULL, NULL, NULL, NULL };
  179.   
  180.   /* This type is tried first. */
  181. ! struct floppy_struct *base_type[4];
  182.   
  183.   /*
  184.    * User-provided type information. current_type points to
  185. --- 135,193 ----
  186.    * be self-explanatory.
  187.    */
  188.   static struct floppy_struct floppy_type[] = {
  189. !     {    0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL },    /*  0 no testing */
  190. !     {  720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"360k PC" },    /*  1 360kB PC diskettes */
  191. !     { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"1.2M" },    /*  2 1.2 MB AT-diskettes */
  192. !     {  720, 9,2,40,1,0x2A,0x02,0xDF,0x50,"D360" },    /*  3 360kB in 720kB drive */
  193. !     { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"720k"},    /*  4 3.5" 720kB diskette */
  194. !     {  720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" },    /*  5 360kB in 1.2MB drive */
  195. !     { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" },    /*  6 720kB in 1.2MB drive */
  196. !     { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"1.44M" },    /*  7 1.44MB diskette */
  197. !     {  800,10,2,40,1,0x25,0x02,0xDF,0x2E,"h400" },    /*  8 400k 5.25" */
  198. !     { 1600,10,2,80,0,0x25,0x01,0xDF,0x2E,"H800" },    /*  9 800k 3.5" */
  199. !     { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" }, /* 10 1.44MB 5.25" */
  200. !     { 3360,21,2,80,0,0x25,0x00,0xDF,0x0C,"H1680" }, /* 11 1.68MB 3.5" */
  201. !     {  820,10,2,41,1,0x25,0x02,0xDF,0x2E,"h410" },    /* 12 410k 5.25" */
  202. !     { 1640,10,2,82,0,0x25,0x01,0xDF,0x2E,"H820" },    /* 13 820k 3.5" */
  203. !     { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" },    /* 14 1.48MB 5.25" */
  204. !     { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" },    /* 15 1.72MB 3.5" */
  205. !     {  840,10,2,42,1,0x25,0x02,0xDF,0x2E,"h420" },    /* 16 420k 5.25" */
  206. !     { 1660,10,2,83,0,0x25,0x01,0xDF,0x2E,"H830" },    /* 17 830k 3.5" */
  207. !     { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" },    /* 18 1.49MB 5.25" */
  208. !     { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" },    /* 19 1.74MB 3.5" */
  209.   };
  210.   
  211.   /*
  212. !  * Auto-detection. Each drive type has four formats which are
  213.    * used in succession to try to read the disk. If the FDC cannot lock onto
  214.    * the disk, the next format is tried. This uses the variable 'probing'.
  215.    */
  216. ! static int floppy_types[] = {
  217. ! #ifdef FD_detect_82
  218. !      1,  1,  1,  1,  /* 5.25" DD drive */
  219. !     14,  2, 12,  5,  /* 5.25" HD drive */
  220. !     13,  4, 13,  4,  /* 3.5" DD drive */
  221. !     15,  7, 13,  4   /* 3.5" HD drive */
  222. ! #else
  223. ! #ifdef FD_detect_83
  224. !      1,  1,  1,  1,
  225. !     18,  2, 16,  5,
  226. !     17,  4, 17,  4,
  227. !     19,  7, 17,  4
  228. ! #else   /* 80 tracks */
  229. !      1,  1,  1,  1,
  230. !     10,  2,  8,  5,
  231. !      9,  4,  9,  4,
  232. !     11,  7,  9,  4
  233. ! #endif
  234. ! #endif
  235. !     };
  236.   
  237.   /* Auto-detection: Disk type used until the next media change occurs. */
  238.   struct floppy_struct *current_type[4] = { NULL, NULL, NULL, NULL };
  239.   
  240.   /* This type is tried first. */
  241. ! int *base_type[4];
  242.   
  243.   /*
  244.    * User-provided type information. current_type points to
  245. ***************
  246. *** 181,187 ****
  247.        720, 720, 720, 720,
  248.        360, 360, 360, 360,
  249.        720, 720, 720, 720,
  250. !     1440,1440,1440,1440
  251.   };
  252.   
  253.   /*
  254. --- 203,221 ----
  255.        720, 720, 720, 720,
  256.        360, 360, 360, 360,
  257.        720, 720, 720, 720,
  258. !     1440,1440,1440,1440,
  259. !      400, 400, 400, 400,
  260. !      800, 800, 800, 800,
  261. !     1440,1440,1440,1440,
  262. !     1680,1680,1680,1680,
  263. !      410, 410, 410, 410,
  264. !      820, 820, 820, 820,
  265. !     1476,1476,1476,1476,
  266. !     1722,1722,1722,1722,
  267. !      420, 420, 420, 420,
  268. !      830, 830, 830, 830,
  269. !     1494,1494,1494,1494,
  270. !     1743,1743,1743,1743
  271.   };
  272.   
  273.   /*
  274. ***************
  275. *** 899,921 ****
  276.   
  277.   static void setup_format_params(void)
  278.   {
  279. !     unsigned char *here = (unsigned char *) tmp_floppy_area;
  280. !     int count,head_shift,track_shift,total_shift;
  281.   
  282.       /* allow for about 30ms for data transport per track */
  283.       head_shift  = floppy->sect / 6;
  284.       /* a ``cylinder'' is two tracks plus a little stepping time */
  285.       track_shift = 2 * head_shift + 1; 
  286. !     /* count backwards */
  287. !     total_shift = floppy->sect - 
  288. !     ((track_shift * track + head_shift * head) % floppy->sect);
  289. ! 
  290. !     /* XXX: should do a check to see this fits in tmp_floppy_area!! */
  291. !     for (count = 0; count < floppy->sect; count++) {
  292. !     *here++ = track;
  293. !     *here++ = head;
  294. !     *here++ = 1 + (( count + total_shift ) % floppy->sect);
  295. !     *here++ = 2; /* 512 bytes */
  296.       }
  297.   }
  298.   
  299. --- 933,970 ----
  300.   
  301.   static void setup_format_params(void)
  302.   {
  303. !     struct fparm {
  304. !         unsigned char track,head,sect,size;
  305. !         } *here = (void *)tmp_floppy_area;
  306. !     int il,n,count,head_shift,track_shift;
  307.   
  308.       /* allow for about 30ms for data transport per track */
  309.       head_shift  = floppy->sect / 6;
  310.       /* a ``cylinder'' is two tracks plus a little stepping time */
  311.       track_shift = 2 * head_shift + 1; 
  312. !     /* position of logical sector 1 on this track */
  313. !     n = (track_shift * track + head_shift * head) % floppy->sect;
  314. !     /* determine interleave */
  315. !     il = (floppy->sect-
  316. !         floppy_type[base_type[format_req.device & 3][1]].sect)>2?2:1;
  317. !     /* initialize field */ 
  318. !     for (count = 0; count < floppy->sect; ++count) {
  319. !        here[count].track = track;
  320. !        here[count].head = head;
  321. !        here[count].sect = 0;
  322. !        here[count].size = 2;
  323. !        }
  324. !     /* place logical sectors */
  325. !     for (count = 1; count <= floppy->sect; ++count) {
  326. !         here[n].sect = count;
  327. !         n = (n+il) % floppy->sect;
  328. !         if (here[n].sect) { /* sector busy, find next free sector */
  329. !            ++n;
  330. !            if (n>=floppy->sect) {
  331. !              n-=floppy->sect;
  332. !              while (here[n].sect) ++n;
  333. !              }
  334. !         }
  335.       }
  336.   }
  337.   
  338. ***************
  339. *** 954,965 ****
  340.       else { /* Auto-detection */
  341.           if ((floppy = current_type[device & 3]) == NULL) {
  342.               probing = 1;
  343. !             if ((floppy = base_type[device & 3]) ==
  344. !                 NULL) {
  345.                   request_done(0);
  346.                   goto repeat;
  347.               }
  348. !             floppy += CURRENT_ERRORS & 1;
  349.           }
  350.       }
  351.       if (format_status != FORMAT_BUSY) {
  352. --- 1003,1014 ----
  353.       else { /* Auto-detection */
  354.           if ((floppy = current_type[device & 3]) == NULL) {
  355.               probing = 1;
  356. !             if (base_type[device & 3] == NULL) {
  357. !                 floppy = NULL;
  358.                   request_done(0);
  359.                   goto repeat;
  360.               }
  361. !             floppy = &floppy_type[base_type[device & 3][CURRENT_ERRORS & 3]];
  362.           }
  363.       }
  364.       if (format_status != FORMAT_BUSY) {
  365. ***************
  366. *** 1144,1156 ****
  367.   inb_p(0x71); \
  368.   })
  369.   
  370. ! static struct floppy_struct *find_base(int drive,int code)
  371.   {
  372. !     struct floppy_struct *base;
  373.   
  374.       if (code > 0 && code < 5) {
  375. !         base = &floppy_types[(code-1)*2];
  376. !         printk("fd%d is %s",drive,base->name);
  377.           return base;
  378.       }
  379.       printk("fd%d is unknown type %d",drive,code);
  380. --- 1193,1205 ----
  381.   inb_p(0x71); \
  382.   })
  383.   
  384. ! static int *find_base(int drive,int code)
  385.   {
  386. !     int *base;
  387.   
  388.       if (code > 0 && code < 5) {
  389. !         base = &floppy_types[(code-1)*4];
  390. !         printk("fd%d is %s",drive,floppy_type[base[1]].name);
  391.           return base;
  392.       }
  393.       printk("fd%d is unknown type %d",drive,code);
  394. ------------------------------------------------------------------------
  395. That`s ist. I hobe it is usefull for some of you.
  396.  
  397. CU
  398.    Heiko
  399. --
  400. PS: Please excuse my english as it is not my native language.
  401. (heiko@pool.informatik.rwth-aachen.de)
  402.  
  403.