home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / unix / armlinux / kernel_src / LINUX-1_001 / linux-1.3.35pl2.diff
Encoding:
Text File  |  1996-03-14  |  282.1 KB  |  10,134 lines
  1. diff -urN linux.store/linux/Makefile linux/Makefile
  2. --- linux.store/linux/Makefile    Sun Feb 11 13:47:34 1996
  3. +++ linux/Makefile    Mon Mar 11 21:10:39 1996
  4. @@ -137,7 +137,7 @@
  5.          $(LIBS) -o vmlinux
  6.      $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)\|\( A \)\|\( t L\)' | sort > System.map
  7.  
  8. -symlinks:
  9. +symlinks::
  10.      rm -f include/asm
  11.      ( cd include ; ln -sf asm-$(ARCH) asm)
  12.  
  13. diff -urN linux.store/linux/README.arm linux/README.arm
  14. --- linux.store/linux/README.arm    Thu Jan  1 01:00:00 1970
  15. +++ linux/README.arm    Tue Mar 12 23:47:01 1996
  16. @@ -0,0 +1,35 @@
  17. +ARM Linux 1.3.35
  18. +----------------
  19. +
  20. +In order to compile ARM Linux, you will need the cross-utilities
  21. +on ftp.ecs.soton.ac.uk in the /pub/armlinux/cross-compilers
  22. +subdirectory.
  23. +
  24. +To configure the kernel, edit the top-level makefile, replacing:
  25. +ARCH = i386 with ARCH = arm
  26. +
  27. +Then examine arch/arm/Makefile for sub-architecture options
  28. +(including processor and machine type), setting them as required.
  29. +
  30. +Do a make config, followed by a make dep, and finally a make all.
  31. +
  32. +Please send all patches, bug reports and code for the ARM Linux
  33. +project to rmk92@ecs.soton.ac.uk.  Patches will not be included
  34. +into future kernels unless they come to me (or the relevent
  35. +person concerned).
  36. +
  37. +Here is a list of people currently working on the project (If you
  38. +wish to be added to the list, please mail me):
  39. +
  40. +Name: Russell King
  41. +Mail: rmk92@ecs.soton.ac.uk
  42. +Desc: Origional developer of ARM Linux, A5000 code and project
  43. +      co-ordinator.
  44. +
  45. +Name: Dave Gilbert
  46. +Mail: gilbertd@cs.man.ac.uk
  47. +Desc: A3/4/5xx floppy and hard disk code maintainer.
  48. +
  49. +Name: Ian Jeffray
  50. +Mail: ian_jeffray@MENTORG.COM
  51. +Desc: A3/4/5xx serial and parrallel port code maintainer.
  52. diff -urN linux.store/linux/arch/arm/Makefile linux/arch/arm/Makefile
  53. --- linux.store/linux/arch/arm/Makefile    Sat Feb 24 13:08:03 1996
  54. +++ linux/arch/arm/Makefile    Wed Mar 13 22:55:58 1996
  55. @@ -10,38 +10,68 @@
  56.  # License.  See the file "COPYING" in the main directory of this archive
  57.  # for more details.
  58.  #
  59. -# Copyright (C) 1995 by Russell King
  60. +# Copyright (C) 1995, 1996 by Russell King
  61.  #
  62. -
  63. -#
  64. -# Set these to indicate how to link it..
  65. -# -qmagic (we need to remove the 32 byte header for bootup purposes)
  66. +# Since we are going multi-computer, I think that this ought to reflect it...
  67.  #
  68. +# THIS IS MY PATCHLEVEL:  PATCHLEVEL2
  69. +
  70. +# MACHINE can be: arc a5k rpc
  71. +# PROCESSOR can be: arm2 arm3 arm6
  72. +# Computer:    MACHINE:  PROCESSOR:
  73. +#  A3xx        arc      arm2
  74. +#  A4xx        arc      arm2
  75. +#  A5xx        arc      arm2
  76. +#  A5000    a5k      arm3
  77. +#  A4000    a5k      arm3
  78. +#  A3020    a5k      arm3 (ok)
  79.  
  80. -SUBARCH         = -m3
  81. +MACHINE         = a5k
  82. +PROCESSOR     = arm3
  83.  
  84.  CPP         = $(CC) -E $(SUBARCH)
  85. -CFLAGS        := $(CFLAGS:-fomit-frame-pointer=) $(SUBARCH)
  86. +HOSTCFLAGS    := $(CFLAGS:-fomit-frame-pointer=)
  87. +CFLAGS        := $(CFLAGS:-fomit-frame-pointer=) $(ARCHFLAGS)
  88.  LINKFLAGS     = -Ttext 0x01800000
  89.  ZLINKFLAGS     = -N -Ttext 0x01800000
  90. +GCCLIB        := `gcc --print-libgcc-file-name`
  91. +
  92. +# -------------------------- END OF USER CONFIGURATION ------------------------------
  93. +
  94. +ifeq ($(PROCESSOR),arm3)
  95. +ARCHFLAGS     = -m3
  96. +else
  97. +ifeq ($(PROCESSOR),arm2)
  98. +ARCHFLAGS     = -m2
  99. +else
  100. +ARCHFLAGS     =
  101. +endif
  102. +endif
  103. +
  104. +ifeq ($(MACHINE),a5k)
  105. +ARCHFLAGS    := $(ARCHFLAGS) -DCONFIG_ARCH_A5K
  106. +else
  107. +ifeq ($(MACHINE),arc)
  108. +ARCHFLAGS    := $(ARCHFLAGS) -DCONFIG_ARCH_ARC
  109. +endif
  110. +endif
  111.  
  112.  HEAD        := arch/arm/kernel/head.o
  113.  SUBDIRS        := arch/arm/drivers arch/arm/kernel arch/arm/mm arch/arm/lib $(SUBDIRS)
  114.  ARCHIVES    := arch/arm/kernel/kernel.o arch/arm/mm/mm.o arch/arm/lib/lib.o $(ARCHIVES)
  115. -LIBS        := $(LIBS) `gcc --print-libgcc-file-name`
  116. +LIBS        := $(LIBS) $(GCCLIB)
  117.  
  118. -DRIVERS := arch/arm/drivers/block/block.a arch/arm/drivers/char/char.a \
  119. -           arch/arm/drivers/net/net.a
  120. +DRIVERS        := arch/arm/drivers/block/block.a arch/arm/drivers/char/char.a \
  121. +               arch/arm/drivers/net/net.a
  122.  
  123.  ifdef CONFIG_SOUND
  124. -DRIVERS := $(DRIVERS) arch/arm/drivers/sound/sound.a
  125. +DRIVERS        := $(DRIVERS) arch/arm/drivers/sound/sound.a
  126.  endif
  127.  
  128.  ifdef CONFIG_SCSI
  129. -DRIVERS := $(DRIVERS) arch/arm/drivers/scsi/scsi.a
  130. +DRIVERS        := $(DRIVERS) arch/arm/drivers/scsi/scsi.a
  131.  endif
  132.  
  133. -
  134.  arch/arm/kernel: dummy
  135.      $(MAKE) linuxsubdirs SUBDIRS=arch/arm/kernel
  136.  
  137. @@ -50,6 +80,10 @@
  138.  
  139.  MAKEBOOT = $(MAKE) -C arch/$(ARCH)/boot
  140.  
  141. +symlinks::
  142. +    rm -f include/asm-arm/arch include/asm-arm/proc
  143. +    (cd include/asm-arm; ln -sf arch-$(MACHINE) arch; ln -sf proc-$(PROCESSOR) proc)
  144. +
  145.  install:
  146.      @$(MAKEBOOT) install
  147.  
  148. @@ -65,6 +99,7 @@
  149.      @$(MAKE) -C arch/$(ARCH)/drivers/char LINKCLEAN
  150.      @$(MAKE) -C arch/$(ARCH)/drivers/net LINKCLEAN
  151.      @$(MAKE) -C arch/$(ARCH)/drivers/scsi LINKCLEAN
  152. +    rm -f include/asm-arm/arch include/asm-arm/proc
  153.  
  154.  archdep:
  155.      @$(MAKEBOOT) dep
  156. diff -urN linux.store/linux/arch/arm/boot/Makefile linux/arch/arm/boot/Makefile
  157. --- linux.store/linux/arch/arm/boot/Makefile    Sun Feb 11 21:59:54 1996
  158. +++ linux/arch/arm/boot/Makefile    Mon Mar 11 20:46:17 1996
  159. @@ -1,11 +1,11 @@
  160.  #
  161. -# arch/i386/boot/Makefile
  162. +# arch/arm/boot/Makefile
  163.  #
  164.  # This file is subject to the terms and conditions of the GNU General Public
  165.  # License.  See the file "COPYING" in the main directory of this archive
  166.  # for more details.
  167.  #
  168. -# Copyright (C) 1994 by Linus Torvalds
  169. +# Copyright (C) 1995, 1996 Russell King
  170.  #
  171.  
  172.  Image:    $(CONFIGURE) tools/build $(TOPDIR)/vmlinux
  173. @@ -25,23 +25,10 @@
  174.      sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
  175.  
  176.  tools/build: tools/build.c
  177. -    $(HOSTCC) $(CFLAGS) -o $@ $< -I$(TOPDIR)/include
  178. +    $(HOSTCC) $(HOSTCFLAGS) -o $@ $< -I$(TOPDIR)/include
  179.  
  180.  clean:
  181.      rm -f Image zImage tools/build
  182.      @$(MAKE) -C compressed clean
  183.  
  184.  dep:
  185. -
  186. -#zdisk: zImage
  187. -#    dd bs=8192 if=zImage of=/dev/fd0
  188. -
  189. -#zlilo: $(CONFIGURE) zImage
  190. -#    if [ -f $(INSTALL_PATH)/vmlinuz ]; then mv $(INSTALL_PATH)/vmlinuz $(INSTALL_PATH)/vmlinuz.old; fi
  191. -#    if [ -f $(INSTALL_PATH)/System.map ]; then mv $(INSTALL_PATH)/System.map $(INSTALL_PATH)/System.old; fi
  192. -#    cat zImage > $(INSTALL_PATH)/vmlinuz
  193. -#    cp $(TOPDIR)/System.map $(INSTALL_PATH)/
  194. -#    if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
  195. -
  196. -#install: $(CONFIGURE) zImage
  197. -#    sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
  198. diff -urN linux.store/linux/arch/arm/boot/compressed/Makefile linux/arch/arm/boot/compressed/Makefile
  199. --- linux.store/linux/arch/arm/boot/compressed/Makefile    Sun Mar  3 13:35:37 1996
  200. +++ linux/arch/arm/boot/compressed/Makefile    Mon Mar 11 20:58:20 1996
  201. @@ -7,6 +7,7 @@
  202.  CFLAGS = -O2 -DSTDC_HEADERS
  203.  LOADADDR = 0x01800000
  204.  RELADDR = 0x01960000
  205. +ARFLAGS = rcv
  206.  
  207.  SYSTEM = $(TOPDIR)/vmlinux
  208.  DECOMP_OBJS = inflate.o unzip.o misc.o ../../lib/ll_char_wr.o
  209. @@ -45,10 +46,10 @@
  210.  # rules for extracting & piggybacking the kernel
  211.  
  212.  xtract:     xtract.c
  213. -        $(HOSTCC) $(CFLAGS) -o xtract xtract.c
  214. +        $(HOSTCC) $(HOSTCFLAGS) -o xtract xtract.c
  215.  
  216.  piggyback:    piggyback.c
  217. -        $(HOSTCC) $(CFLAGS) -o piggyback piggyback.c
  218. +        $(HOSTCC) $(HOSTCFLAGS) -o piggyback piggyback.c
  219.  
  220.  
  221.  clean:
  222. diff -urN linux.store/linux/arch/arm/boot/compressed/misc.c linux/arch/arm/boot/compressed/misc.c
  223. --- linux.store/linux/arch/arm/boot/compressed/misc.c    Sun Feb 11 09:32:12 1996
  224. +++ linux/arch/arm/boot/compressed/misc.c    Sun Mar 10 15:32:20 1996
  225. @@ -231,15 +231,15 @@
  226.  
  227.  static void puts(const char *s)
  228.  {
  229. -    extern void ll_char_write(char *, char, char, char, char);
  230. +    extern void ll_write_char(char *, unsigned long);
  231.      int x,y;
  232. -    char c;
  233. +    unsigned char c;
  234.      char *ptr;
  235.  
  236.      x = params->video_x;
  237.      y = params->video_y;
  238.  
  239. -    while ( ( c = *s++ ) != '\0' ) {
  240. +    while ( ( c = *(unsigned char *)s++ ) != '\0' ) {
  241.          if ( c == '\n' ) {
  242.              x = 0;
  243.              if ( ++y >= video_num_lines ) {
  244. @@ -248,7 +248,7 @@
  245.              }
  246.          } else {
  247.              ptr = vidmem + (y*video_num_columns*params->bytes_per_char_v+x)*bytes_per_char_h;
  248. -            ll_char_write(ptr, c, white, 0, 0);
  249. +            ll_write_char (ptr, c|(white<<8));
  250.              if ( ++x >= video_num_columns ) {
  251.                  x = 0;
  252.                  if ( ++y >= video_num_lines ) {
  253. diff -urN linux.store/linux/arch/arm/config.in linux/arch/arm/config.in
  254. --- linux.store/linux/arch/arm/config.in    Sat Feb 24 21:32:58 1996
  255. +++ linux/arch/arm/config.in    Wed Mar 13 22:24:44 1996
  256. @@ -18,21 +18,14 @@
  257.  
  258.  mainmenu_option next_comment
  259.  comment 'General setup'
  260. -bool 'Compile for arm3' CONFIG_ARM3 y
  261. -if [ "$CONFIG_ARM3" = "n" ]; then
  262. -  bool 'Compile for arm610/710' CONFIG_ARM610 y
  263. -  if [ "$CONFIG_ARM610" = "n" ]; then
  264. -    bool 'Compile for StrongARM' CONFIG_ARMSTRONG y
  265. -  fi
  266. -else
  267. -  bool 'Page size as 32K' CONFIG_PAGE_32K y
  268. -  if [ "$CONFIG_PAGE_32K" = "n" ]; then
  269. -    bool 'Page size as 16K' CONFIG_PAGE_16K y
  270. -    if [ "$CONFIG_PAGE_16K" = "n" ]; then
  271. -      echo "Auto detected page size"
  272. -    fi
  273. -  fi
  274. -fi
  275. +# Other page sizes aren't supported yet...
  276. +#bool 'Page size as 32K' CONFIG_PAGE_32K y
  277. +#if [ "$CONFIG_PAGE_32K" = "n" ]; then
  278. +#  bool 'Page size as 16K' CONFIG_PAGE_16K y
  279. +#  if [ "$CONFIG_PAGE_16K" = "n" ]; then
  280. +#    echo "Auto detected page size"
  281. +#  fi
  282. +#fi
  283.  
  284.  comment 'Math emulation is provided by a run-time loadable module'
  285.  
  286. @@ -51,6 +44,9 @@
  287.  #  fi
  288.  fi
  289.  tristate 'MFM harddisk support' CONFIG_BLK_DEV_XD n
  290. +if [ "$CONFIG_BLK_DEV_XD" != "n" ]; then
  291. +  bool '  Use MFM with motherboard controller?' CONFIG_MFM_ONMAINBOARD y
  292. +fi
  293.  
  294.  bool 'Networking support' CONFIG_NET y
  295.  bool 'Limit memory to low 16MB' CONFIG_MAX_16M n
  296. diff -urN linux.store/linux/arch/arm/drivers/block/Makefile linux/arch/arm/drivers/block/Makefile
  297. --- linux.store/linux/arch/arm/drivers/block/Makefile    Sat Feb 24 13:17:05 1996
  298. +++ linux/arch/arm/drivers/block/Makefile    Wed Mar 13 14:46:03 1996
  299. @@ -16,27 +16,37 @@
  300.  M_OBJS   :=
  301.  MOD_LIST_NAME := BLOCK_MODULES
  302.  
  303. -ifeq ($(CONFIG_BLK_DEV_FD),y)
  304. -L_OBJS += floppy.o
  305. -else
  306. -  ifeq ($(CONFIG_BLK_DEV_FD),m)
  307. -  M_OBJS += floppy.o
  308. -  endif
  309. +# Architecture dependencies
  310. +
  311. +ifeq ($(MACHINE),a5k)
  312. +  FLOPPY = floppy.o
  313.  endif
  314.  
  315. -ifeq ($(CONFIG_BLK_DEV_HD),y)
  316. -L_OBJS += hd.o
  317. +ifeq ($(MACHINE),arc)
  318. +  FLOPPY = fd1772.o
  319.  endif
  320.  
  321. -ifeq ($(CONFIG_BLK_DEV_IDE),y)
  322. -L_OBJS += ide.o
  323. +# Common dependencies
  324. +
  325. +ifdef FLOPPY
  326. +  ifeq ($(CONFIG_BLK_DEV_FD),y)
  327. +    L_OBJS += $(FLOPPY)
  328. +  else
  329. +    ifeq ($(CONFIG_BLK_DEV_FD),m)
  330. +      M_OBJS += $(FLOPPY)
  331. +    endif
  332. +  endif
  333. +endif
  334. +
  335. +ifeq ($(CONFIG_BLK_DEV_HD),y)
  336. +  L_OBJS += hd.o
  337.  endif
  338.  
  339. -ifeq ($(CONFIG_BLK_DEV_MFM),y)
  340. -L_OBJS += mfmhd.o
  341. +ifeq ($(CONFIG_BLK_DEV_XD),y)
  342. +  L_OBJS += mfmhd.o
  343.  else
  344. -  ifeq ($(CONFIG_BLK_DEV_MFM),m)
  345. -  M_OBJS += mfmhd_mod.o
  346. +  ifeq ($(CONFIG_BLK_DEV_XD),m)
  347. +    M_OBJS += mfmhd_mod.o
  348.    endif
  349.  endif
  350.  
  351. @@ -45,9 +55,9 @@
  352.  fastdep: links
  353.  
  354.  mfmhd_mod.o: mfmhd.o
  355. -    ld -r -o $@ mfmhd.o `gcc --print-libgcc-file-name`
  356. +    ld -r -o $@ mfmhd.o $(GCCLIB)
  357.  
  358. -LK = blk.h ll_rw_blk.c ramdisk.c README.fd README.hd
  359. +LK = blk.h ramdisk.c README.fd README.hd
  360.  
  361.  links:
  362.      -@for f in $(LK); do \
  363. diff -urN linux.store/linux/arch/arm/drivers/block/fd1772.c linux/arch/arm/drivers/block/fd1772.c
  364. --- linux.store/linux/arch/arm/drivers/block/fd1772.c    Thu Jan  1 01:00:00 1970
  365. +++ linux/arch/arm/drivers/block/fd1772.c    Mon Mar 11 23:26:30 1996
  366. @@ -0,0 +1,1448 @@
  367. +/*
  368. + *  linux/kernel/arch/arm/drivers/block/fd1772.c
  369. + *  Based on ataflop.c in the m68k Linux
  370. + *  Copyright (C) 1993  Greg Harp
  371. + *  Atari Support by Bjoern Brauel, Roman Hodek
  372. + *  Archimedes Support by Dave Gilbert (gilbertd@cs.man.ac.uk)
  373. + *
  374. + *  Big cleanup Sep 11..14 1994 Roman Hodek:
  375. + *   - Driver now works interrupt driven
  376. + *   - Support for two drives; should work, but I cannot test that :-(
  377. + *   - Reading is done in whole tracks and buffered to speed up things
  378. + *   - Disk change detection and drive deselecting after motor-off
  379. + *     similar to TOS
  380. + *   - Autodetection of disk format (DD/HD); untested yet, because I
  381. + *     don't have an HD drive :-(
  382. + *
  383. + *  Fixes Nov 13 1994 Martin Schaller:
  384. + *   - Autodetection works now
  385. + *   - Support for 5 1/4" disks
  386. + *   - Removed drive type (unknown on atari)
  387. + *   - Do seeks with 8 Mhz
  388. + *
  389. + *  Changes by Andreas Schwab:
  390. + *   - After errors in multiple read mode try again reading single sectors
  391. + *  (Feb 1995):
  392. + *   - Clean up error handling
  393. + *   - Set blk_size for proper size checking
  394. + *   - Initialize track register when testing presence of floppy
  395. + *   - Implement some ioctl's
  396. + *
  397. + *  Changes by Torsten Lang:
  398. + *   - When probing the floppies we should add the FDC1772CMDADD_H flag since
  399. + *     the FDC1772 will otherwise wait forever when no disk is inserted...
  400. + *
  401. + *  Things left to do:
  402. + *   - Formatting
  403. + *   - Maybe a better strategy for disk change detection (does anyone
  404. + *     know one?)
  405. + *   - There are some strange problems left: The strangest one is
  406. + *     that, at least on my TT (4+4MB), the first 2 Bytes of the last
  407. + *     page of the TT-Ram (!) change their contents (some bits get
  408. + *     set) while a floppy DMA is going on. But there are no accesses
  409. + *     to these memory locations from the kernel... (I tested that by
  410. + *     making the page read-only). I cannot explain what's going on...
  411. + *   - Sometimes the drive-change-detection stops to work. The
  412. + *     function is still called, but the WP bit always reads as 0...
  413. + *     Maybe a problem with the status reg mode or a timing problem.
  414. + *     Note 10/12/94: The change detection now seems to work reliably.
  415. + *     There is no proof, but I've seen no hang for a long time...
  416. + *
  417. + * ARCHIMEDES changes:
  418. + *     26/12/95 - Changed all names starting with FDC to FDC1772
  419. + *                Removed all references to clock speed of FDC - we're stuck with 8MHz
  420. + *                Modified disk_type structure to remove HD formats
  421. + *
  422. + *      7/ 1/96 - Wrote FIQ code, removed most remaining atariisms
  423. + *
  424. + *     13/ 1/96 - Well I think its read a single sector; but there is a problem
  425. + *                fd_rwsec_done which is called in FIQ mode starts another transfer
  426. + *                off (in fd_rwsec) while still in FIQ mode.  Because its still in
  427. + *                FIQ mode it can't service the DMA and loses data. So need to
  428. + *                heavily restructure.
  429. + *     14/ 1/96 - Found that the definitions of the register numbers of the
  430. + *                FDC were multiplied by 2 in the header for the 16bit words
  431. + *                of the atari so half the writes were going in the wrong place.
  432. + *                Also realised that the FIQ entry didn't make any attempt to
  433. + *                preserve registers or return correctly; now in assembler.
  434. + *
  435. + *     11/ 2/96 - Hmm - doesn't work on real machine.  Auto detect doesn't
  436. + *                and hacking that past seems to wait forever - check motor
  437. + *                being turned on.
  438. + *
  439. + *     17/ 2/96 - still having problems - forcing track to -1 when selecting
  440. + *                new drives seems to allow it to read first few sectors
  441. + *                but then we get solid hangs at apparently random places
  442. + *                which change depending what is happening.
  443. + *
  444. + *      9/ 3/96 - Fiddled a lot of stuff around to move to kernel 1.3.35
  445. + *                A lot of fiddling in DMA stuff. Having problems with it
  446. + *                constnatly thinking its timeing out. Ah - its timeout
  447. + *                was set to (6*HZ) rather than jiffies+(6*HZ).  Now giving
  448. + *                duff data!
  449. + */
  450. +
  451. +#include <linux/config.h>
  452. +#include <linux/sched.h>
  453. +#include <linux/fs.h>
  454. +#include <linux/fcntl.h>
  455. +#include <linux/kernel.h>
  456. +#include <linux/timer.h>
  457. +#include <linux/fd.h>
  458. +#include <linux/fd1772.h>
  459. +#include <linux/errno.h>
  460. +#include <linux/types.h>
  461. +#include <linux/delay.h>
  462. +#include <linux/mm.h>
  463. +
  464. +#include <asm/machdeps.h>
  465. +#include <asm/system.h>
  466. +#include <asm/bitops.h>
  467. +#include <asm/dma.h>
  468. +#include <asm/io.h>
  469. +#include <asm/irq.h>
  470. +#include <asm/irq-no.h>
  471. +#include <asm/pgtable.h>
  472. +
  473. +#define MAJOR_NR FLOPPY_MAJOR
  474. +#define FLOPPY_DMA 0
  475. +#include "blk.h"
  476. +
  477. +extern unsigned char *ioc;
  478. +
  479. +/* Note: FD_MAX_UNITS could be redefined to 2 for the Atari (with
  480. + * little additional rework in this file). But I'm not yet sure if
  481. + * some other code depends on the number of floppies... (It is defined
  482. + * in a public header!)
  483. + */
  484. +#if 0
  485. +#undef FD_MAX_UNITS
  486. +#define    FD_MAX_UNITS    2
  487. +#endif
  488. +
  489. +/* Ditto worries for Arc - DAG */
  490. +#define FD_MAX_UNITS 4
  491. +#define TRACKBUFFER 0
  492. +/*#define DEBUG*/
  493. +
  494. +#ifdef DEBUG
  495. +#define DPRINT(a)    printk a
  496. +#else
  497. +#define DPRINT(a)
  498. +#endif
  499. +
  500. +/* Disk types: DD */
  501. +static struct atari_disk_type {
  502. +    const char    *name;
  503. +    unsigned    spt;        /* sectors per track */
  504. +    unsigned    blocks;        /* total number of blocks */
  505. +    unsigned     stretch;    /* track doubling ? */
  506. +} disk_type[] = {
  507. +    { "d360",  9, 720, 0},    /* 360kB diskette */
  508. +    { "D360",  9, 720, 1},    /* 360kb in 720kb drive */
  509. +    { "D720",  9,1440, 0},    /* 720kb diskette (DD) */    
  510. +    /*{ "D820", 10,1640, 0}, */    /* DD disk with 82 tracks/10 sectors - DAG - can't see how type detect can distinguish this from 720K until it reads block 4 by which time its too late! */
  511. +};
  512. +
  513. +#define    NUM_DISK_TYPES (sizeof(disk_type)/sizeof(*disk_type))
  514. +
  515. +/*
  516. + * Maximum disk size (in kilobytes). This default is used whenever the
  517. + * current disk size is unknown.
  518. + */
  519. +#define MAX_DISK_SIZE 720
  520. +
  521. +static int floppy_sizes[256];
  522. +static int floppy_blocksizes[256] = { 0, };
  523. +
  524. +/* current info on each unit */
  525. +static struct atari_floppy_struct {
  526. +    int connected;                /* !=0 : drive is connected */
  527. +    int autoprobe;                /* !=0 : do autoprobe        */
  528. +
  529. +    struct atari_disk_type    *disktype;    /* current type of disk */
  530. +
  531. +             int            track;        /* current head position or -1
  532. +                                         * if unknown */
  533. +    unsigned int            steprate;    /* steprate setting */
  534. +    unsigned int            wpstat;        /* current state of WP signal
  535. +                                         * (for disk change detection) */
  536. +} unit[FD_MAX_UNITS];
  537. +
  538. +/* DAG: On Arc we spin on a flag being cleared by fdc1772_comendhandler which
  539. +   is an assembler routine */
  540. +extern void fdc1772_comendhandler (void); /* Actually doens't have these parameters - see fd1772.S */
  541. +extern volatile int fdc1772_comendstatus;
  542. +extern volatile int fdc1772_fdc_int_done;
  543. +
  544. +#define FDC1772BASE (0x3210000>>2)
  545. +
  546. +#define FDC1772_READ(reg) inb(FDC1772BASE+(reg/2))
  547. +
  548. +/* DAG: You wouldn't be silly to ask why FDC1772_WRITE is a function rather
  549. +   than the #def below - well simple - the #def won't compile - and I
  550. +   don't understand why (__outwc not defined) */
  551. +/* NOTE: Reg is 0,2,4,6 as opposed to 0,1,2,3 or 0,4,8,12 to keep compatibility
  552. +   with the ST version of fd1772.h */
  553. +/*#define FDC1772_WRITE(reg,val) outw(val,(reg+FDC1772BASE)); */
  554. +void FDC1772_WRITE(int reg, unsigned char val) {
  555. +  if (reg==FDC1772REG_CMD) {
  556. +    DPRINT(("FDC1772_WRITE new command 0x%x\n",val));
  557. +    if (fdc1772_fdc_int_done) {
  558. +      DPRINT(("FDC1772_WRITE: Hmm fdc1772_fdc_int_done true - resetting\n"));
  559. +      fdc1772_fdc_int_done=0;
  560. +    };
  561. +  };
  562. +  outb(val,(reg/2)+FDC1772BASE);
  563. +};
  564. +
  565. +/* Buffering variables:
  566. + * First, there is a DMA buffer in ST-RAM that is used for floppy DMA
  567. + * operations. Second, a track buffer is used to cache a whole track
  568. + * of the disk to save read operations. These are two seperate buffers
  569. + * because that allows write operations without clearing the track buffer.
  570. + */
  571. +
  572. +#define    MAX_SECTORS    22
  573. +
  574. +unsigned char *DMABuffer;              /* buffer for writes */
  575. +/*static unsigned long PhysDMABuffer;*/   /* physical address */
  576. +/* DAG: On Arc we just go straight for the DMA buffer */
  577. +#define PhysDMABuffer DMABuffer
  578. +
  579. +/*
  580. + * These are global variables, as that's the easiest way to give
  581. + * information to interrupts. They are the data used for the current
  582. + * request.
  583. + */
  584. +static int SelectedDrive = 0;
  585. +static int ReqCmd, ReqBlock;
  586. +static int ReqSide, ReqTrack, ReqSector, ReqCnt;
  587. +static int HeadSettleFlag = 0;
  588. +static unsigned char *ReqData, *ReqBuffer;
  589. +static int MotorOn = 0, MotorOffTrys;
  590. +
  591. +/* Synchronization of FDC1772 access. */
  592. +static volatile int fdc_busy = 0;
  593. +static struct wait_queue *fdc_wait = NULL;
  594. +
  595. +
  596. +static unsigned int changed_floppies = 0xff, fake_change = 0;
  597. +#define    CHECK_CHANGE_DELAY    HZ/2
  598. +
  599. +#define    FD_MOTOR_OFF_DELAY    (3*HZ)
  600. +#define    FD_MOTOR_OFF_MAXTRY    (10*20)
  601. +
  602. +#define FLOPPY_TIMEOUT        (6*HZ)
  603. +#define RECALIBRATE_ERRORS    4    /* Atfer this many errors the drive
  604. +                                 * will be recalibrated. */
  605. +#define MAX_ERRORS            8    /* After this many errors the driver
  606. +                                 * will give up. */
  607. +
  608. +
  609. +#define    START_MOTOR_OFF_TIMER(delay)            \
  610. +    do {                                        \
  611. +        motor_off_timer.expires = (delay);        \
  612. +        add_timer( &motor_off_timer );            \
  613. +        MotorOffTrys = 0;                        \
  614. +    } while(0)
  615. +
  616. +#define    START_CHECK_CHANGE_TIMER(delay)                            \
  617. +    do {                                                        \
  618. +        timer_table[FLOPPY_TIMER].expires = jiffies + (delay);    \
  619. +        timer_active |= (1 << FLOPPY_TIMER);                    \
  620. +    } while(0)
  621. +
  622. +#define    START_TIMEOUT()                            \
  623. +    do {                                        \
  624. +        del_timer( &timeout_timer );            \
  625. +        timeout_timer.expires = jiffies + FLOPPY_TIMEOUT;    \
  626. +        add_timer( &timeout_timer );            \
  627. +    } while(0)
  628. +
  629. +#define    STOP_TIMEOUT()                            \
  630. +    do {                                        \
  631. +        del_timer( &timeout_timer );            \
  632. +    } while(0)
  633. +
  634. +#define ENABLE_IRQ() enable_irq(FIQ_FD1772+16);
  635. +
  636. +#define DISABLE_IRQ() disable_irq(FIQ_FD1772+16);
  637. +
  638. +/*
  639. + * The driver is trying to determine the correct media format
  640. + * while Probing is set. fd_rwsec_done() clears it after a
  641. + * successful access.
  642. + */
  643. +static int Probing = 0;
  644. +
  645. +/* This flag is set when a dummy seek is necesary to make the WP
  646. + * status bit accessible.
  647. + */
  648. +static int NeedSeek = 0;
  649. +
  650. +
  651. +/***************************** Prototypes *****************************/
  652. +
  653. +static void fd_select_side( int side );
  654. +static void fd_select_drive( int drive );
  655. +static void fd_deselect( void );
  656. +static void fd_motor_off_timer( unsigned long dummy );
  657. +static void check_change( void );
  658. +static __inline__ void set_head_settle_flag( void );
  659. +static __inline__ int get_head_settle_flag( void );
  660. +static void floppy_irqconsequencehandler (void);
  661. +static void fd_error( void );
  662. +static void do_fd_action( int drive );
  663. +static void fd_calibrate( void );
  664. +static void fd_calibrate_done( int status );
  665. +static void fd_seek( void );
  666. +static void fd_seek_done( int status );
  667. +static void fd_rwsec( void );
  668. +static void fd_rwsec_done( int status );
  669. +static void fd_times_out( unsigned long dummy );
  670. +static void finish_fdc( void );
  671. +static void finish_fdc_done( int dummy );
  672. +static void floppy_off( unsigned int nr);
  673. +static __inline__ void copy_buffer( void *from, void *to);
  674. +static void setup_req_params( int drive );
  675. +static void redo_fd_request( void);
  676. +static int fd_ioctl( struct inode *inode, struct file *filp, unsigned int
  677. +                     cmd, unsigned long param);
  678. +static void fd_probe( int drive );
  679. +static int fd_test_drive_present( int drive );
  680. +static void config_types( void );
  681. +static int floppy_open( struct inode *inode, struct file *filp );
  682. +static void floppy_release( struct inode * inode, struct file * filp );
  683. +
  684. +/************************* End of Prototypes **************************/
  685. +
  686. +static struct timer_list motor_off_timer =
  687. +                         { NULL, NULL, 0, 0, fd_motor_off_timer };
  688. +static struct timer_list timeout_timer =
  689. +                         { NULL, NULL, 0, 0, fd_times_out };
  690. +
  691. +/* DAG: Haven't got a clue what this is? */
  692. +int stdma_islocked(void) {
  693. +  return 0;
  694. +};
  695. +
  696. +/* Select the side to use. */
  697. +
  698. +static void fd_select_side( int side )
  699. +
  700. +{    unsigned long flags;
  701. +
  702. +    save_flags(flags);
  703. +    cli();
  704. +  
  705. +  oldlatch_aupdate(LATCHA_SIDESEL,side?0:LATCHA_SIDESEL);
  706. +    restore_flags(flags);
  707. +}
  708. +
  709. +
  710. +/* Select a drive, update the FDC1772's track register
  711. + */
  712. +
  713. +static void fd_select_drive( int drive )
  714. +
  715. +{
  716. +    unsigned long flags;
  717. +  
  718. +#ifdef DEBUG
  719. +  printk("fd_select_drive:%d\n",drive);
  720. +#endif
  721. +  /* Hmm - nowhere do we seem to turn the motor on - I'm going to do it here! */
  722. +  oldlatch_aupdate(LATCHA_MOTOR|LATCHA_INUSE,0);
  723. +
  724. +    if (drive == SelectedDrive)
  725. +      return;
  726. +
  727. +    save_flags(flags);
  728. +    cli();
  729. +  oldlatch_aupdate(LATCHA_FDSELALL,0xf-(1<<drive));
  730. +    restore_flags(flags);
  731. +
  732. +    /* restore track register to saved value */
  733. +    FDC1772_WRITE( FDC1772REG_TRACK, unit[drive].track );
  734. +    udelay(25);
  735. +
  736. +    SelectedDrive = drive;
  737. +}
  738. +
  739. +
  740. +/* Deselect both drives. */
  741. +
  742. +static void fd_deselect( void )
  743. +
  744. +{    unsigned long flags;
  745. +
  746. +  DPRINT(("fd_deselect\n"));
  747. +
  748. +    save_flags(flags);
  749. +    cli();
  750. +  oldlatch_aupdate(LATCHA_FDSELALL|LATCHA_MOTOR|LATCHA_INUSE,0xf|LATCHA_MOTOR|LATCHA_INUSE);
  751. +    restore_flags(flags);
  752. +
  753. +    SelectedDrive = -1;
  754. +}
  755. +
  756. +
  757. +/* This timer function deselects the drives when the FDC1772 switched the
  758. + * motor off. The deselection cannot happen earlier because the FDC1772
  759. + * counts the index signals, which arrive only if one drive is selected.
  760. + */
  761. +
  762. +static void fd_motor_off_timer( unsigned long dummy )
  763. +
  764. +{    unsigned long flags;
  765. +    unsigned char status;
  766. +    int              delay;
  767. +
  768. +    del_timer( &motor_off_timer );
  769. +    
  770. +    if (SelectedDrive < 0)
  771. +        /* no drive selected, needn't deselect anyone */
  772. +        return;
  773. +
  774. +    save_flags(flags);
  775. +    cli();
  776. +    
  777. +    if (fdc_busy) /* was stdma_islocked */
  778. +        goto retry;
  779. +
  780. +    status = FDC1772_READ( FDC1772REG_STATUS );
  781. +
  782. +    if (!(status & 0x80)) {
  783. +        /* motor already turned off by FDC1772 -> deselect drives */
  784. +        fd_deselect();
  785. +        restore_flags(flags);
  786. +        MotorOn = 0;
  787. +        return;
  788. +   }
  789. +    /* not yet off, try again */
  790. +
  791. +  retry:
  792. +  restore_flags(flags);
  793. +    /* Test again later; if tested too often, it seems there is no disk
  794. +     * in the drive and the FDC1772 will leave the motor on forever (or,
  795. +     * at least until a disk is inserted). So we'll test only twice
  796. +     * per second from then on...
  797. +     */
  798. +    delay = (MotorOffTrys < FD_MOTOR_OFF_MAXTRY) ?
  799. +                (++MotorOffTrys, HZ/20) : HZ/2;
  800. +    START_MOTOR_OFF_TIMER( delay );
  801. +}
  802. +
  803. +
  804. +/* This function is repeatedly called to detect disk changes (as good
  805. + * as possible) and keep track of the current state of the write protection.
  806. + */
  807. +
  808. +static void check_change( void )
  809. +
  810. +{    static int    drive = 0;
  811. +
  812. +    unsigned long flags;
  813. +    int              stat;
  814. +
  815. +  if (fdc_busy) return; /* Don't start poking about if the fdc is busy */
  816. +
  817. +  return; /* lets just forget it for the mo DAG */
  818. +
  819. +    if (++drive > 1 || !unit[drive].connected)
  820. +        drive = 0;
  821. +
  822. +    save_flags(flags);
  823. +    cli();
  824. +
  825. +    if (!stdma_islocked()) {
  826. +    /* DAG: What the heck does this do??? */
  827. +        /*sound_ym.rd_data_reg_sel = 14;
  828. +        old_porta = sound_ym.rd_data_reg_sel;
  829. +        sound_ym.wd_data = (old_porta | DSKDRVNONE) &
  830. +                           ~(drive == 0 ? DSKDRV0 : DSKDRV1); */
  831. +        stat = !!(FDC1772_READ( FDC1772REG_STATUS ) & FDC1772STAT_WPROT);
  832. +/*        sound_ym.wd_data = old_porta; */
  833. +
  834. +        if (stat != unit[drive].wpstat) {
  835. +            DPRINT(( "wpstat[%d] = %d\n", drive, stat ));
  836. +            unit[drive].wpstat = stat;
  837. +            set_bit (drive, &changed_floppies);
  838. +        }
  839. +    }
  840. +    restore_flags(flags);
  841. +
  842. +    START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY );
  843. +}
  844. +
  845. + 
  846. +/* Handling of the Head Settling Flag: This flag should be set after each
  847. + * seek operation, because we dont't use seeks with verify.
  848. + */
  849. +
  850. +static __inline__ void set_head_settle_flag( void )
  851. +
  852. +{
  853. +    HeadSettleFlag = FDC1772CMDADD_E;
  854. +}
  855. +
  856. +static __inline__ int get_head_settle_flag( void )
  857. +
  858. +{
  859. +    int    tmp = HeadSettleFlag;
  860. +    HeadSettleFlag = 0;
  861. +    return( tmp );
  862. +}
  863. +
  864. +  
  865. +  
  866. +
  867. +/* General Interrupt Handling */
  868. +
  869. +static void (*FloppyIRQHandler)( int status ) = NULL;
  870. +
  871. +static void floppy_irqconsequencehandler (void)
  872. +
  873. +{
  874. +    unsigned char status;
  875. +    void (*handler)( int );
  876. +
  877. +  fdc1772_fdc_int_done=0;
  878. +
  879. +    handler = FloppyIRQHandler;
  880. +    FloppyIRQHandler = NULL;
  881. +
  882. +    if (handler) {
  883. +        nop();
  884. +        status = (unsigned char)fdc1772_comendstatus;
  885. +        DPRINT(("FDC1772 irq, status = %02x handler = %08lx\n",(unsigned int)status,(unsigned long)handler));
  886. +        handler( status );
  887. +    }
  888. +    else {
  889. +        DPRINT(("FDC1772 irq, no handler status=%02x\n",fdc1772_comendstatus));
  890. +    }
  891. +  DPRINT(("FDC1772 irq: end of floppy_irq\n"));
  892. +}
  893. +
  894. +
  895. +/* Error handling: If some error happened, retry some times, then
  896. + * recalibrate, then try again, and fail after MAX_ERRORS.
  897. + */
  898. +
  899. +static void fd_error( void )
  900. +
  901. +{
  902. +  DPRINT(("FDC1772: fd_error\n"));
  903. +  /*panic("fd1772: fd_error");*/ /* DAG tmp */
  904. +    if (!CURRENT) return;
  905. +    CURRENT->errors++;
  906. +    if (CURRENT->errors >= MAX_ERRORS) {
  907. +        printk( "fd%d: too many errors.\n", SelectedDrive );
  908. +        end_request( 0 );
  909. +    }
  910. +    else if (CURRENT->errors == RECALIBRATE_ERRORS) {
  911. +        printk( "fd%d: recalibrating\n", SelectedDrive );
  912. +        if (SelectedDrive != -1)
  913. +            unit[SelectedDrive].track = -1;
  914. +    }
  915. +    redo_fd_request();
  916. +}
  917. +
  918. +
  919. +
  920. +#define    SET_IRQ_HANDLER(proc) do { FloppyIRQHandler = (proc); } while(0)
  921. +
  922. +
  923. +/* do_fd_action() is the general procedure for a fd request: All
  924. + * required parameter settings (drive select, side select, track
  925. + * position) are checked and set if needed. For each of these
  926. + * parameters and the actual reading or writing exist two functions:
  927. + * one that starts the setting (or skips it if possible) and one
  928. + * callback for the "done" interrupt. Each done func calls the next
  929. + * set function to propagate the request down to fd_rwsec_done().
  930. + */
  931. +
  932. +static void do_fd_action( int drive )
  933. +
  934. +{
  935. +    DPRINT(("do_fd_action unit[drive].track=%d\n",unit[drive].track));
  936. +
  937. +    if (SelectedDrive != drive) {
  938. +    unit[drive].track=-1; 
  939. +        fd_select_drive( drive );
  940. +  };
  941. +    
  942. +
  943. +    if (unit[drive].track == -1)
  944. +        fd_calibrate();
  945. +    else if (unit[drive].track != ReqTrack << unit[drive].disktype->stretch)
  946. +        fd_seek();
  947. +    else
  948. +        fd_rwsec();
  949. +}
  950. +
  951. +
  952. +/* Seek to track 0 if the current track is unknown */
  953. +
  954. +static void fd_calibrate( void )
  955. +
  956. +{
  957. +    DPRINT(("fd_calibrate\n"));
  958. +    if (unit[SelectedDrive].track >= 0) {
  959. +        fd_calibrate_done( 0 );
  960. +        return;
  961. +    }
  962. +
  963. +    DPRINT(("fd_calibrate (after track compare)\n"));
  964. +    SET_IRQ_HANDLER( fd_calibrate_done );
  965. +    /* we can't verify, since the speed may be incorrect */
  966. +    FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_RESTORE | unit[SelectedDrive].steprate );
  967. +
  968. +    NeedSeek = 1;
  969. +    MotorOn = 1;
  970. +    START_TIMEOUT();
  971. +    /* wait for IRQ */
  972. +}
  973. +
  974. +
  975. +static void fd_calibrate_done( int status )
  976. +
  977. +{
  978. +    DPRINT(("fd_calibrate_done()\n"));
  979. +    STOP_TIMEOUT();
  980. +    
  981. +    /* set the correct speed now */
  982. +    if (status & FDC1772STAT_RECNF) {
  983. +        printk( "fd%d: restore failed\n", SelectedDrive );
  984. +        fd_error();
  985. +    }
  986. +    else {
  987. +        unit[SelectedDrive].track = 0;
  988. +        fd_seek();
  989. +    }
  990. +}
  991. +  
  992. +  
  993. +/* Seek the drive to the requested track. The drive must have been
  994. + * calibrated at some point before this.
  995. + */
  996. +  
  997. +static void fd_seek( void )
  998. +  
  999. +{
  1000. +    DPRINT(("fd_seek() to track %d (unit[SelectedDrive].track=%d)\n",ReqTrack,
  1001. +    unit[SelectedDrive].track));
  1002. +    if (unit[SelectedDrive].track == ReqTrack << 
  1003. +        unit[SelectedDrive].disktype->stretch) {
  1004. +        fd_seek_done( 0 );
  1005. +        return;
  1006. +    }
  1007. +
  1008. +    FDC1772_WRITE( FDC1772REG_DATA, ReqTrack << 
  1009. +        unit[SelectedDrive].disktype->stretch);
  1010. +    udelay(25);
  1011. +    SET_IRQ_HANDLER( fd_seek_done );
  1012. +    FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_SEEK | unit[SelectedDrive].steprate );
  1013. +
  1014. +    MotorOn = 1;
  1015. +    set_head_settle_flag();
  1016. +    START_TIMEOUT();
  1017. +    /* wait for IRQ */
  1018. +}
  1019. +
  1020. +
  1021. +static void fd_seek_done( int status )
  1022. +  
  1023. +{
  1024. +    DPRINT(("fd_seek_done()\n"));
  1025. +    STOP_TIMEOUT();
  1026. +    
  1027. +    /* set the correct speed */
  1028. +    if (status & FDC1772STAT_RECNF) {
  1029. +        printk( "fd%d: seek error (to track %d)\n",
  1030. +                SelectedDrive, ReqTrack );
  1031. +        /* we don't know exactly which track we are on now! */
  1032. +        unit[SelectedDrive].track = -1;
  1033. +        fd_error();
  1034. +    }
  1035. +    else {
  1036. +        unit[SelectedDrive].track = ReqTrack << 
  1037. +            unit[SelectedDrive].disktype->stretch;
  1038. +        NeedSeek = 0;
  1039. +        fd_rwsec();
  1040. +    }
  1041. +}
  1042. +
  1043. +
  1044. +/* This does the actual reading/writing after positioning the head
  1045. + * over the correct track.
  1046. + */
  1047. +
  1048. +static void fd_rwsec( void )
  1049. +    
  1050. +{
  1051. +    unsigned long paddr, flags;
  1052. +    unsigned int  rwflag, old_motoron;
  1053. +    unsigned int track;
  1054. +    
  1055. +    DPRINT(("fd_rwsec(), Sec=%d, Access=%c\n",ReqSector, ReqCmd == WRITE ? 'w' : 'r' ));
  1056. +    if (ReqCmd == WRITE) {
  1057. +        /*cache_push( (unsigned long)ReqData, 512 );*/
  1058. +        paddr = (unsigned long)ReqData;
  1059. +        rwflag = 0x100;
  1060. +    }
  1061. +    else {
  1062. +        paddr = (unsigned long)PhysDMABuffer;
  1063. +        rwflag = 0;
  1064. +    }
  1065. +
  1066. +  DPRINT(("fd_rwsec() before sidesel rwflag=%d sec=%d trk=%d\n",rwflag,
  1067. +          ReqSector,FDC1772_READ( FDC1772REG_TRACK)));
  1068. +    fd_select_side( ReqSide );
  1069. +  
  1070. +  /*DPRINT(("fd_rwsec() before start sector \n")); */
  1071. +    /* Start sector of this operation */
  1072. +    FDC1772_WRITE( FDC1772REG_SECTOR, ReqSector );
  1073. +    /* Cheat for track if stretch != 0 */
  1074. +    if (unit[SelectedDrive].disktype->stretch) {
  1075. +        track = FDC1772_READ( FDC1772REG_TRACK);
  1076. +        FDC1772_WRITE( FDC1772REG_TRACK, track >> 
  1077. +            unit[SelectedDrive].disktype->stretch);
  1078. +    }
  1079. +    udelay(25);
  1080. +  
  1081. +  DPRINT(("fd_rwsec() before setup DMA \n"));
  1082. +    /* Setup DMA - Heavily modified by DAG */
  1083. +    save_flags(flags);  
  1084. +    cliIF();
  1085. +  disable_dma(FLOPPY_DMA);
  1086. +  set_dma_mode(FLOPPY_DMA,rwflag?DMA_MODE_WRITE:DMA_MODE_READ);
  1087. +  set_dma_addr(FLOPPY_DMA,(long)paddr); /* DAG - changed from Atari specific */
  1088. +  set_dma_count(FLOPPY_DMA,512); /* Block/sector size - going to have to change */
  1089. +    SET_IRQ_HANDLER( fd_rwsec_done );
  1090. +    /* Turn on dma int */
  1091. +  enable_dma(FLOPPY_DMA);
  1092. +    restore_flags(flags);
  1093. +  /* Now give it something to do */
  1094. +  FDC1772_WRITE(FDC1772REG_CMD,(rwflag?(FDC1772CMD_WRSEC | FDC1772CMDADD_P):FDC1772CMD_RDSEC));
  1095. +  
  1096. +  DPRINT(("fd_rwsec() after DMA setup flags=0x%08x\n",flags));
  1097. +  /*sti();*/ /* DAG - Hmm */
  1098. +  /* Hmm - should do something DAG */
  1099. +    old_motoron = MotorOn;
  1100. +    MotorOn = 1;
  1101. +    NeedSeek = 1;
  1102. +    /* wait for interrupt */
  1103. +
  1104. +  /*DPRINT(("fd_rwsec() before START_TIMEOUT \n"));*/
  1105. +    START_TIMEOUT();
  1106. +  /*DPRINT(("fd_rwsec() after START_TIMEOUT \n")); */
  1107. +}
  1108. +
  1109. +    
  1110. +static void fd_rwsec_done( int status )
  1111. +  
  1112. +{
  1113. +    unsigned int track;
  1114. +
  1115. +    DPRINT(("fd_rwsec_done() status=%d\n",status));
  1116. +
  1117. +    /* Correct the track if stretch != 0 */
  1118. +    if (unit[SelectedDrive].disktype->stretch) {
  1119. +        track = FDC1772_READ( FDC1772REG_TRACK);
  1120. +        FDC1772_WRITE( FDC1772REG_TRACK, track << 
  1121. +            unit[SelectedDrive].disktype->stretch);
  1122. +    }
  1123. +
  1124. +    if (ReqCmd == WRITE && (status & FDC1772STAT_WPROT)) {
  1125. +        printk( "fd%d: is write protected\n", SelectedDrive );
  1126. +        goto err_end;
  1127. +    }    
  1128. +    if ((status & FDC1772STAT_RECNF)
  1129. +       ) {
  1130. +        if (Probing) {
  1131. +            if (unit[SelectedDrive].disktype > disk_type) {
  1132. +                /* try another disk type */
  1133. +                unit[SelectedDrive].disktype--;
  1134. +                floppy_sizes[SelectedDrive]
  1135. +                  = unit[SelectedDrive].disktype->blocks >> 1;
  1136. +            }
  1137. +            else
  1138. +                Probing=0;
  1139. +        } else {    
  1140. +/* record not found, but not probing. Maybe stretch wrong ? Restart probing */
  1141. +            if (unit[SelectedDrive].autoprobe) {
  1142. +                unit[SelectedDrive].disktype = disk_type + NUM_DISK_TYPES-1;
  1143. +                floppy_sizes[SelectedDrive]
  1144. +                  = unit[SelectedDrive].disktype->blocks >> 1;
  1145. +                Probing = 1;
  1146. +            }
  1147. +        }
  1148. +        if (Probing) {
  1149. +            setup_req_params( SelectedDrive );
  1150. +            do_fd_action( SelectedDrive );
  1151. +            return;
  1152. +        }
  1153. +
  1154. +        printk( "fd%d: sector %d not found (side %d, track %d)\n",
  1155. +               SelectedDrive, FDC1772_READ (FDC1772REG_SECTOR), ReqSide, ReqTrack );
  1156. +        goto err_end;
  1157. +    }
  1158. +    if (status & FDC1772STAT_CRC) {
  1159. +        printk( "fd%d: CRC error (side %d, track %d, sector %d)\n",
  1160. +               SelectedDrive, ReqSide, ReqTrack, FDC1772_READ (FDC1772REG_SECTOR) );
  1161. +        goto err_end;
  1162. +    }
  1163. +    if (status & FDC1772STAT_LOST) {
  1164. +        printk( "fd%d: lost data (side %d, track %d, sector %d)\n",
  1165. +               SelectedDrive, ReqSide, ReqTrack, FDC1772_READ (FDC1772REG_SECTOR) );
  1166. +        goto err_end;
  1167. +    }
  1168. +
  1169. +    Probing = 0;
  1170. +    
  1171. +    if (ReqCmd == READ) {
  1172. +        /*cache_clear( PhysDMABuffer, 512 );*/
  1173. +        copy_buffer( DMABuffer, ReqData );
  1174. +    }
  1175. +  
  1176. +    if (++ReqCnt < CURRENT->current_nr_sectors) {
  1177. +        /* read next sector */
  1178. +        setup_req_params( SelectedDrive );
  1179. +        do_fd_action( SelectedDrive );
  1180. +    }
  1181. +    else {
  1182. +        /* all sectors finished */
  1183. +        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
  1184. +        CURRENT->sector += CURRENT->current_nr_sectors;
  1185. +        end_request( 1 );
  1186. +        redo_fd_request();
  1187. +    }
  1188. +    return;
  1189. +  
  1190. +  err_end:
  1191. +    fd_error();
  1192. +}
  1193. +
  1194. +
  1195. +static void fd_times_out( unsigned long dummy )
  1196. +
  1197. +{
  1198. +    SET_IRQ_HANDLER( NULL );
  1199. +    /* If the timeout occured while the readtrack_check timer was
  1200. +     * active, we need to cancel it, else bad things will happen */
  1201. +    /* del_timer( &readtrack_timer ); DAG: Only seems to be used with the TACKBUFFER */
  1202. +    FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_FORCI );
  1203. +    udelay( 25 );
  1204. +    
  1205. +    printk( "floppy timeout\n" );
  1206. +    fd_error();
  1207. +}
  1208. +
  1209. +
  1210. +/* The (noop) seek operation here is needed to make the WP bit in the
  1211. + * FDC1772 status register accessible for check_change. If the last disk
  1212. + * operation would have been a RDSEC, this bit would always read as 0
  1213. + * no matter what :-( To save time, the seek goes to the track we're
  1214. + * already on.
  1215. + */
  1216. +
  1217. +static void finish_fdc( void )
  1218. +
  1219. +{
  1220. +  if (!NeedSeek) {
  1221. +      finish_fdc_done( 0 );
  1222. +  }
  1223. +  else {
  1224. +        DPRINT(("finish_fdc: dummy seek started\n"));
  1225. +        FDC1772_WRITE (FDC1772REG_DATA, unit[SelectedDrive].track);
  1226. +        SET_IRQ_HANDLER( finish_fdc_done );
  1227. +        FDC1772_WRITE (FDC1772REG_CMD, FDC1772CMD_SEEK);
  1228. +        MotorOn = 1;
  1229. +        START_TIMEOUT();
  1230. +      /* we must wait for the IRQ here, because the ST-DMA is
  1231. +       * released immediatly afterwards and the interrupt may be
  1232. +       * delivered to the wrong driver.
  1233. +       */
  1234. +      }
  1235. +}
  1236. +
  1237. +
  1238. +static void finish_fdc_done( int dummy )
  1239. +
  1240. +{
  1241. +    unsigned long flags;
  1242. +
  1243. +    DPRINT(("finish_fdc_done entered\n"));
  1244. +    STOP_TIMEOUT();
  1245. +    NeedSeek = 0;
  1246. +
  1247. +    if ((timer_active & (1 << FLOPPY_TIMER)) &&
  1248. +        timer_table[FLOPPY_TIMER].expires < jiffies + 5)
  1249. +        /* If the check for a disk change is done too early after this
  1250. +         * last seek command, the WP bit still reads wrong :-((
  1251. +         */
  1252. +        timer_table[FLOPPY_TIMER].expires = jiffies + 5;
  1253. +    else {
  1254. +    /*    START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY ); */
  1255. +  };
  1256. +    del_timer( &motor_off_timer );
  1257. +    START_MOTOR_OFF_TIMER( FD_MOTOR_OFF_DELAY );
  1258. +
  1259. +    save_flags(flags);
  1260. +    cli();
  1261. +    /* stdma_release(); - not sure if I should do something DAG  */
  1262. +    fdc_busy = 0;
  1263. +    wake_up( &fdc_wait );
  1264. +    restore_flags(flags);
  1265. +
  1266. +    DPRINT(("finish_fdc() finished\n"));
  1267. +}
  1268. +
  1269. +
  1270. +/* Prevent "aliased" accesses. */
  1271. +static fd_ref[4] = { 0,0,0,0 };
  1272. +static fd_device[4] = { 0,0,0,0 };
  1273. +
  1274. +/*
  1275. + * Current device number. Taken either from the block header or from the
  1276. + * format request descriptor.
  1277. + */
  1278. +#define CURRENT_DEVICE (CURRENT->rq_dev)
  1279. +
  1280. +/* Current error count. */
  1281. +#define CURRENT_ERRORS (CURRENT->errors)
  1282. +
  1283. +
  1284. +/* dummy for blk.h */
  1285. +static void floppy_off( unsigned int nr) {}
  1286. +
  1287. +
  1288. +/* The detection of disk changes is a dark chapter in Atari history :-(
  1289. + * Because the "Drive ready" signal isn't present in the Atari
  1290. + * hardware, one has to rely on the "Write Protect". This works fine,
  1291. + * as long as no write protected disks are used. TOS solves this
  1292. + * problem by introducing tri-state logic ("maybe changed") and
  1293. + * looking at the serial number in block 0. This isn't possible for
  1294. + * Linux, since the floppy driver can't make assumptions about the
  1295. + * filesystem used on the disk and thus the contents of block 0. I've
  1296. + * choosen the method to always say "The disk was changed" if it is
  1297. + * unsure whether it was. This implies that every open or mount
  1298. + * invalidates the disk buffers if you work with write protected
  1299. + * disks. But at least this is better than working with incorrect data
  1300. + * due to unrecognised disk changes.
  1301. + */
  1302. +
  1303. +static int check_floppy_change (dev_t dev)
  1304. +
  1305. +{    unsigned int drive = (dev & 0x03);
  1306. +
  1307. +    if (MAJOR(dev) != MAJOR_NR) {
  1308. +        printk("floppy_changed: not a floppy\n");
  1309. +        return 0;
  1310. +    }
  1311. +    
  1312. +    if (test_bit (drive, &fake_change)) {
  1313. +        /* simulated change (e.g. after formatting) */
  1314. +        return 1;
  1315. +    }
  1316. +    if (test_bit (drive, &changed_floppies)) {
  1317. +        /* surely changed (the WP signal changed at least once) */
  1318. +        return 1;
  1319. +    }
  1320. +    if (unit[drive].wpstat) {
  1321. +        /* WP is on -> could be changed: to be sure, buffers should be
  1322. +         * invalidated...
  1323. +         */
  1324. +        return 1;
  1325. +    }
  1326. +
  1327. +    return 0;
  1328. +}
  1329. +
  1330. +static int floppy_revalidate (dev_t dev)
  1331. +{
  1332. +  int drive = dev & 3;
  1333. +
  1334. +  if (test_bit (drive, &changed_floppies) || test_bit (drive, &fake_change)
  1335. +      || unit[drive].disktype == 0)
  1336. +    {
  1337. +      clear_bit (drive, &fake_change);
  1338. +      clear_bit (drive, &changed_floppies);
  1339. +      unit[drive].disktype = 0;
  1340. +    }
  1341. +  return 0;
  1342. +}
  1343. +
  1344. +static __inline__ void copy_buffer(void *from, void *to)
  1345. +
  1346. +{    ulong    *p1 = (ulong *)from, *p2 = (ulong *)to;
  1347. +    int        cnt;
  1348. +
  1349. +    for( cnt = 512/4; cnt; cnt-- )
  1350. +        *p2++ = *p1++;
  1351. +}
  1352. +
  1353. +
  1354. +/* This sets up the global variables describing the current request. */
  1355. +
  1356. +static void setup_req_params( int drive )
  1357. +
  1358. +{    int block = ReqBlock + ReqCnt;
  1359. +
  1360. +    ReqTrack = block / unit[drive].disktype->spt;
  1361. +    ReqSector = block - ReqTrack * unit[drive].disktype->spt + 1;
  1362. +    ReqSide = ReqTrack & 1;
  1363. +    ReqTrack >>= 1;
  1364. +    ReqData = ReqBuffer + 512 * ReqCnt;
  1365. +
  1366. +    DPRINT(("Request params: Si=%d Tr=%d Se=%d Data=%08lx\n",ReqSide,
  1367. +            ReqTrack, ReqSector, (unsigned long)ReqData ));
  1368. +}
  1369. +
  1370. +
  1371. +static void redo_fd_request(void)
  1372. +
  1373. +{
  1374. +    int device, drive, type;
  1375. +    struct atari_floppy_struct *floppy;
  1376. +  
  1377. +    DPRINT(("redo_fd_request: CURRENT=%08lx CURRENT->rq_dev=%04x CURRENT->sector=%ld\n",
  1378. +        (unsigned long)CURRENT, CURRENT ? CURRENT->rq_dev : 0,
  1379. +        CURRENT ? CURRENT->sector : 0 ));
  1380. +
  1381. +    if (CURRENT && CURRENT->rq_dev < 0)
  1382. +        goto the_end;
  1383. +
  1384. +repeat:
  1385. +    
  1386. +    if (!CURRENT)
  1387. +        goto the_end;
  1388. +
  1389. +    if (MAJOR(CURRENT->rq_dev) != MAJOR_NR)
  1390. +        panic(DEVICE_NAME ": request list destroyed");
  1391. +
  1392. +    if (CURRENT->bh) {
  1393. +        if (!CURRENT->bh->b_lock)
  1394. +            panic(DEVICE_NAME ": block not locked");
  1395. +    }
  1396. +
  1397. +    device = MINOR(CURRENT_DEVICE);
  1398. +    drive = device & 3;
  1399. +    type = device >> 2;
  1400. +    floppy = &unit[drive];
  1401. +    
  1402. +    if (!floppy->connected) {
  1403. +        /* drive not connected */
  1404. +        printk( "Unknown Device: fd%d\n", drive );
  1405. +        end_request(0);
  1406. +        goto repeat;
  1407. +    }
  1408. +        
  1409. +    if (type == 0) {
  1410. +        if (!floppy->disktype) {
  1411. +            Probing = 1;
  1412. +            floppy->disktype  = disk_type + NUM_DISK_TYPES-1;
  1413. +            floppy_sizes[drive] = floppy->disktype->blocks >> 1;
  1414. +            floppy->autoprobe = 1;
  1415. +        }
  1416. +    } 
  1417. +    else {
  1418. +        /* user supplied disk type */
  1419. +        --type;
  1420. +        if (type >= NUM_DISK_TYPES) {
  1421. +            printk( "fd%d: invalid disk format", drive );
  1422. +            end_request( 0 );
  1423. +            goto repeat;
  1424. +        }
  1425. +        floppy->disktype = &disk_type[type];
  1426. +        floppy_sizes[drive] = disk_type[type].blocks >> 1;
  1427. +        floppy->autoprobe = 0;
  1428. +    }
  1429. +    
  1430. +    if (CURRENT->sector + 1 > floppy->disktype->blocks) {
  1431. +            end_request(0);
  1432. +            goto repeat;
  1433. +        }
  1434. +
  1435. +    /* stop deselect timer */
  1436. +    del_timer( &motor_off_timer );
  1437. +        
  1438. +    ReqCnt = 0;
  1439. +    ReqCmd = CURRENT->cmd;
  1440. +    ReqBlock = CURRENT->sector;
  1441. +    ReqBuffer = CURRENT->buffer;
  1442. +    setup_req_params( drive );
  1443. +    do_fd_action( drive );
  1444. +
  1445. +    return;
  1446. +
  1447. +  the_end:
  1448. +    finish_fdc();
  1449. +}
  1450. +
  1451. +
  1452. +void do_fd_request(void)
  1453. +
  1454. +{     unsigned long flags;
  1455. +
  1456. +    DPRINT(("do_fd_request for pid %d\n",current->pid));
  1457. +  if (fdc_busy) panic("do_fd_request while already busy\n");
  1458. +    save_flags(flags);
  1459. +    cli();
  1460. +    while( fdc_busy ) sleep_on( &fdc_wait );
  1461. +    fdc_busy = 1;
  1462. +    /*stdma_lock( floppy_irq, 0 ); Hmm DAG */
  1463. +    ENABLE_IRQ();
  1464. +    restore_flags(flags);
  1465. +
  1466. +  fdc1772_fdc_int_done=0;
  1467. +
  1468. +    redo_fd_request();
  1469. +
  1470. +  save_flags(flags);
  1471. +  sti();
  1472. +  while (fdc_busy) {
  1473. +    /*int stat=FDC1772_READ( FDC1772REG_STATUS );
  1474. +    DPRINT(("do_fd_request: busy process loop start %x %x %x %x\n",ioc[0x30],ioc[0x34],ioc[0x38],stat)); */
  1475. +    if (fdc1772_fdc_int_done) floppy_irqconsequencehandler();
  1476. +    /*DPRINT(("do_fd_request: busy process loop end\n"));  */
  1477. +  };
  1478. +  DPRINT(("do_fd_request: end\n"));
  1479. +  restore_flags(flags);
  1480. +}
  1481. +
  1482. +
  1483. +static int
  1484. +invalidate_drive (int rdev)
  1485. +{
  1486. +  /* invalidate the buffer track to force a reread */
  1487. +  set_bit (rdev & 3, &fake_change);
  1488. +  check_disk_change (rdev);
  1489. +  return 0;
  1490. +}
  1491. +
  1492. +static int fd_ioctl(struct inode *inode, struct file *filp,
  1493. +                    unsigned int cmd, unsigned long param)
  1494. +{
  1495. +#define IOCTL_MODE_BIT 8
  1496. +#define OPEN_WRITE_BIT 16
  1497. +#define IOCTL_ALLOWED (filp && (filp->f_mode & IOCTL_MODE_BIT))
  1498. +
  1499. +  int drive, device;
  1500. +
  1501. +  device = inode->i_rdev;
  1502. +  switch (cmd)
  1503. +    {
  1504. +      RO_IOCTLS (inode->i_rdev, param);
  1505. +    }
  1506. +  drive = MINOR (device);
  1507. +  if (!IOCTL_ALLOWED)
  1508. +    return -EPERM;
  1509. +  switch (cmd)
  1510. +    {
  1511. +    case FDFMTBEG:
  1512. +      return 0;
  1513. +    /* case FDC1772LRPRM:  ??? DAG what does this do?? 
  1514. +      unit[drive].disktype = NULL;
  1515. +      floppy_sizes[drive] = MAX_DISK_SIZE;
  1516. +      return invalidate_drive (device); */
  1517. +    case FDFMTEND:
  1518. +    case FDFLUSH:
  1519. +      return invalidate_drive (drive);
  1520. +    }
  1521. +  if (!suser ())
  1522. +    return -EPERM;
  1523. +  if (drive < 0 || drive > 3)
  1524. +    return -EINVAL;
  1525. +  switch (cmd)
  1526. +    {
  1527. +    default:
  1528. +      return -EINVAL;
  1529. +    }
  1530. +  return 0;
  1531. +}
  1532. +
  1533. +
  1534. +/* Initialize the 'unit' variable for drive 'drive' */
  1535. +
  1536. +static void fd_probe( int drive )
  1537. +{
  1538. +    unit[drive].connected = 0;
  1539. +    unit[drive].disktype  = NULL;
  1540. +
  1541. +    if (!fd_test_drive_present( drive ))
  1542. +        return;
  1543. +
  1544. +    unit[drive].connected = 1;
  1545. +    unit[drive].track     = 0;
  1546. +    unit[drive].steprate  = FDC1772STEP_6;
  1547. +    MotorOn = 1;    /* from probe restore operation! */
  1548. +}
  1549. +
  1550. +
  1551. +/* This function tests the physical presence of a floppy drive (not
  1552. + * whether a disk is inserted). This is done by issuing a restore
  1553. + * command, waiting max. 2 seconds (that should be enough to move the
  1554. + * head across the whole disk) and looking at the state of the "TR00"
  1555. + * signal. This should now be raised if there is a drive connected
  1556. + * (and there is no hardware failure :-) Otherwise, the drive is
  1557. + * declared absent.
  1558. + */
  1559. +
  1560. +static int fd_test_drive_present( int drive )
  1561. +
  1562. +{    unsigned long timeout;
  1563. +    unsigned char status;
  1564. +    int              ok;
  1565. +    
  1566. +  printk("fd_test_drive_present %d\n",drive);
  1567. +    if (drive > 1) return( 0 );
  1568. +  return(1); /* Simple hack for the moment - the autodetect doesn't seem to work on arc */
  1569. +    fd_select_drive( drive );
  1570. +
  1571. +    /* disable interrupt temporarily */
  1572. +    DISABLE_IRQ();
  1573. +    FDC1772_WRITE (FDC1772REG_TRACK, 0x00); /* was ff00 why? */
  1574. +    FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_RESTORE | FDC1772CMDADD_H | FDC1772STEP_6 );
  1575. +
  1576. +  /*printk("fd_test_drive_present: Going into timeout loop\n");*/
  1577. +    for( ok = 0, timeout = jiffies + 2*HZ+HZ/2; jiffies < timeout; ) {
  1578. +    /*  What does this piece of atariism do? - query for an interrupt? */
  1579. +    /*    if (!(mfp.par_dt_reg & 0x20))
  1580. +        break; */
  1581. +    /* Well this is my nearest guess - quit when we get an FDC interrupt */
  1582. +    if (ioc[0x30] & 2) break;
  1583. +    }
  1584. +
  1585. +  /*printk("fd_test_drive_present: Coming out of timeout loop\n");*/
  1586. +    status = FDC1772_READ( FDC1772REG_STATUS );
  1587. +    ok = (status & FDC1772STAT_TR00) != 0;
  1588. +
  1589. +  /*printk("fd_test_drive_present: ok=%d\n",ok); */
  1590. +    /* force interrupt to abort restore operation (FDC1772 would try
  1591. +     * about 50 seconds!) */
  1592. +    FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_FORCI );
  1593. +    udelay(500);
  1594. +    status = FDC1772_READ( FDC1772REG_STATUS );
  1595. +    udelay(20);
  1596. +  /*printk("fd_test_drive_present: just before OK code %d\n",ok);*/
  1597. +
  1598. +    if (ok) {
  1599. +        /* dummy seek command to make WP bit accessible */
  1600. +        FDC1772_WRITE( FDC1772REG_DATA, 0 );
  1601. +        FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_SEEK );
  1602. +    printk("fd_test_drive_present: just before wait for int\n");
  1603. +    /* DAG: Guess means wait for interrupt */
  1604. +        while( !(ioc[0x30] &2) ) ;
  1605. +    printk("fd_test_drive_present: just after wait for int\n");
  1606. +        status = FDC1772_READ( FDC1772REG_STATUS );
  1607. +    }
  1608. +
  1609. +  printk("fd_test_drive_present: just before ENABLE_IRQ\n");
  1610. +  ENABLE_IRQ();
  1611. +  printk("fd_test_drive_present: about to return\n");
  1612. +    return( ok );
  1613. +}
  1614. +
  1615. +
  1616. +/* Look how many and which kind of drives are connected. If there are
  1617. + * floppies, additionally start the disk-change and motor-off timers.
  1618. + */
  1619. +
  1620. +static void config_types( void )
  1621. +
  1622. +{
  1623. +    int drive, cnt = 0;
  1624. +
  1625. +    printk("Probing floppy drive(s):\n");
  1626. +    for( drive = 0; drive < FD_MAX_UNITS; drive++ ) {
  1627. +        fd_probe( drive );
  1628. +        if (unit[drive].connected) {
  1629. +            printk("fd%d\n", drive);
  1630. +            ++cnt;
  1631. +        }
  1632. +    }
  1633. +
  1634. +    if (FDC1772_READ( FDC1772REG_STATUS ) & FDC1772STAT_BUSY) {
  1635. +        /* If FDC1772 is still busy from probing, give it another FORCI
  1636. +         * command to abort the operation. If this isn't done, the FDC1772
  1637. +         * will interrupt later and its IRQ line stays low, because
  1638. +         * the status register isn't read. And this will block any
  1639. +         * interrupts on this IRQ line :-(
  1640. +         */
  1641. +        FDC1772_WRITE( FDC1772REG_CMD, FDC1772CMD_FORCI );
  1642. +        udelay(500);
  1643. +        FDC1772_READ( FDC1772REG_STATUS );
  1644. +        udelay(20);
  1645. +    }
  1646. +    
  1647. +    if (cnt > 0) {
  1648. +        START_MOTOR_OFF_TIMER( FD_MOTOR_OFF_DELAY );
  1649. +        if (cnt == 1) fd_select_drive( 0 );
  1650. +        /*START_CHECK_CHANGE_TIMER( CHECK_CHANGE_DELAY ); */
  1651. +    }
  1652. +}
  1653. +
  1654. +/*
  1655. + * floppy_open check for aliasing (/dev/fd0 can be the same as
  1656. + * /dev/PS0 etc), and disallows simultaneous access to the same
  1657. + * drive with different device numbers.
  1658. + */
  1659. +
  1660. +static int floppy_open( struct inode *inode, struct file *filp )
  1661. +
  1662. +{
  1663. +  int drive;
  1664. +  int old_dev;
  1665. +
  1666. +  if (!filp)
  1667. +    {
  1668. +      DPRINT (("Weird, open called with filp=0\n"));
  1669. +      return -EIO;
  1670. +    }
  1671. +
  1672. +  drive = MINOR (inode->i_rdev) & 3;
  1673. +  if ((MINOR (inode->i_rdev) >> 2) > NUM_DISK_TYPES)
  1674. +    return -ENXIO;
  1675. +
  1676. +  old_dev = fd_device[drive];
  1677. +
  1678. +  if (fd_ref[drive])
  1679. +    if (old_dev != inode->i_rdev)
  1680. +      return -EBUSY;
  1681. +
  1682. +  if (fd_ref[drive] == -1 || (fd_ref[drive] && filp->f_flags & O_EXCL))
  1683. +    return -EBUSY;
  1684. +
  1685. +  if (filp->f_flags & O_EXCL)
  1686. +    fd_ref[drive] = -1;
  1687. +  else
  1688. +    fd_ref[drive]++;
  1689. +
  1690. +  fd_device[drive] = inode->i_rdev;
  1691. +
  1692. +  if (old_dev && old_dev != inode->i_rdev)
  1693. +    invalidate_buffers(old_dev);
  1694. +
  1695. +  /* Allow ioctls if we have write-permissions even if read-only open */
  1696. +  if (filp->f_mode & 2 || permission (inode, 2) == 0)
  1697. +    filp->f_mode |= IOCTL_MODE_BIT;
  1698. +  if (filp->f_mode & 2)
  1699. +    filp->f_mode |= OPEN_WRITE_BIT;
  1700. +
  1701. +  if (filp->f_flags & O_NDELAY)
  1702. +    return 0;
  1703. +
  1704. +    if (filp->f_mode & 3) {
  1705. +        check_disk_change( inode->i_rdev );
  1706. +        if (filp->f_mode & 2) {
  1707. +            if (unit[drive].wpstat) {
  1708. +                floppy_release(inode, filp);
  1709. +                return -EROFS;
  1710. +            }
  1711. +        }
  1712. +    }
  1713. +
  1714. +  return 0;
  1715. +}
  1716. +
  1717. +
  1718. +static void floppy_release( struct inode * inode, struct file * filp )
  1719. +
  1720. +{
  1721. +  int drive;
  1722. +
  1723. +  drive = inode->i_rdev & 3;
  1724. +
  1725. +  if (!filp || (filp->f_mode & (2 | OPEN_WRITE_BIT)))
  1726. +    /* if the file is mounted OR (writable now AND writable at open
  1727. +       time) Linus: Does this cover all cases? */
  1728. +    block_fsync (inode, filp);
  1729. +
  1730. +  if (fd_ref[drive] < 0)
  1731. +    fd_ref[drive] = 0;
  1732. +  else if (!fd_ref[drive]--)
  1733. +    {
  1734. +      printk("floppy_release with fd_ref == 0");
  1735. +      fd_ref[drive] = 0;
  1736. +    }
  1737. +}
  1738. +
  1739. +static struct file_operations floppy_fops = {
  1740. +    NULL,            /* lseek - default */
  1741. +    block_read,        /* read - general block-dev read */
  1742. +    block_write,        /* write - general block-dev write */
  1743. +    NULL,            /* readdir - bad */
  1744. +    NULL,            /* select */
  1745. +    fd_ioctl,        /* ioctl */
  1746. +    NULL,            /* mmap */
  1747. +    floppy_open,        /* open */
  1748. +    floppy_release,     /* release */
  1749. +    block_fsync,        /* fsync */
  1750. +    NULL,            /* fasync */
  1751. +    check_floppy_change,    /* media_change */
  1752. +    floppy_revalidate,    /* revalidate */
  1753. +};
  1754. +
  1755. +
  1756. +void
  1757. +fd1772_init (void)
  1758. +
  1759. +{    int i;
  1760. +
  1761. +    if (register_blkdev(MAJOR_NR,"fd",&floppy_fops)) {
  1762. +        printk("Unable to get major %d for floppy\n",MAJOR_NR);
  1763. +        return ;
  1764. +    }
  1765. +
  1766. +  /* Actually this does almost nothing - we actually do this by starting DMA
  1767. +     on channel 1 */
  1768. +  /*if (request_irq(FIQ_FD1772+16,fdc1772_comendhandler,SA_INTERRUPT,"fd1772")) {
  1769. +    printk("Unable to grab IRQ%d for the floppy (1772) driver\n",FIQ_FD1772+16);
  1770. +    return ;
  1771. +  };*/
  1772. +
  1773. +  if (request_dma(FLOPPY_DMA,"fd1772")) {
  1774. +    printk("Unable to grab DMA%d for the floppy (1772) driver\n", FLOPPY_DMA);
  1775. +    free_irq(FIQ_FD1772+16);
  1776. +    return ;
  1777. +  };
  1778. +
  1779. +  if (request_dma(FIQ_FD1772,"fd1772 end")) {
  1780. +    printk("Unable to grab DMA%d for the floppy (1772) driver\n", FIQ_FD1772);
  1781. +    free_irq(FIQ_FD1772+16);
  1782. +    return ;
  1783. +  };
  1784. +  enable_dma(FIQ_FD1772); /* This inserts a call to our command end routine */
  1785. +
  1786. +    /* initialize variables */
  1787. +    SelectedDrive = -1;
  1788. +
  1789. +    /* initialize check_change timer */
  1790. +    timer_table[FLOPPY_TIMER].fn = check_change;
  1791. +    timer_active &= ~(1 << FLOPPY_TIMER);
  1792. +
  1793. +  /* Allocate memory for the DMAbuffer - on the Atari this takes it
  1794. +     out of some special memory...*/
  1795. +    DMABuffer = (char *)vmalloc(2048);/* Copes with pretty large sectors */
  1796. +
  1797. +    for (i = 0; i < FD_MAX_UNITS; i++) {
  1798. +        unit[i].track = -1;
  1799. +  }
  1800. +
  1801. +    for (i = 0; i < 256; i++)
  1802. +        if ((i >> 2) > 0 && (i >> 2) <= NUM_DISK_TYPES)
  1803. +            floppy_sizes[i] = disk_type[(i >> 2) - 1].blocks >> 1;
  1804. +        else
  1805. +            floppy_sizes[i] = MAX_DISK_SIZE;
  1806. +
  1807. +    blk_size[MAJOR_NR] = floppy_sizes;
  1808. +    blksize_size[MAJOR_NR] = floppy_blocksizes;
  1809. +    blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  1810. +
  1811. +    config_types();
  1812. +
  1813. +    return ;
  1814. +}
  1815. diff -urN linux.store/linux/arch/arm/drivers/block/hd.c linux/arch/arm/drivers/block/hd.c
  1816. --- linux.store/linux/arch/arm/drivers/block/hd.c    Sun Mar  3 12:24:12 1996
  1817. +++ linux/arch/arm/drivers/block/hd.c    Mon Mar 11 22:48:13 1996
  1818. @@ -118,8 +118,7 @@
  1819.      unsigned long t, flags;
  1820.      int i;
  1821.  
  1822. -    save_flags(flags);
  1823. -    cli();
  1824. +    save_flags_cli (flags);
  1825.      t = jiffies * 11932;
  1826.          outb_p(0, 0x43);
  1827.      i = inb_p(0x40);
  1828. @@ -732,11 +731,11 @@
  1829.          return;
  1830.  repeat:
  1831.      timer_active &= ~(1<<HD_TIMER);
  1832. -    sti();
  1833. +    sti ();
  1834.      INIT_REQUEST;
  1835.      if (reset) {
  1836. -        cli();
  1837. -        reset_hd();
  1838. +        cli ();
  1839. +        reset_hd ();
  1840.          return;
  1841.      }
  1842.      dev = MINOR(CURRENT->rq_dev);
  1843. @@ -745,44 +744,43 @@
  1844.      if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects || ((block+nsect) > hd[dev].nr_sects)) {
  1845.  #ifdef DEBUG
  1846.          if (dev >= (NR_HD<<6))
  1847. -            printk("hd: bad minor number: device=0x%04x\n", CURRENT->rq_dev);
  1848. +            printk ("hd: bad minor number: device=0x%04x\n", CURRENT->rq_dev);
  1849.          else
  1850. -            printk("hd%c: bad access: block=%d, count=%d\n",
  1851. +            printk ("hd%c: bad access: block=%d, count=%d\n",
  1852.                  (dev>>6)+'a', block, nsect);
  1853.  #endif
  1854. -        end_request(0);
  1855. +        end_request (0);
  1856.          goto repeat;
  1857.      }
  1858.      block += hd[dev].start_sect;
  1859. -    if(dev & 0x3f)
  1860. -    { /* map sectors block to block+nsect to frags, 
  1861. -       */
  1862. -        if(!image_file_check(CURRENT->rq_dev,CURRENT->cmd))
  1863. +    if (dev & 0x3f) {
  1864. +     /* map sectors block to block+nsect to frags, 
  1865. +      */
  1866. +        if (!image_file_check(CURRENT->rq_dev,CURRENT->cmd)) {
  1867. +            end_request (0);
  1868.              goto repeat;
  1869. +        }
  1870.          frag_count = image_file_map(CURRENT->rq_dev, block, nsect, MAX_FRAGS, 
  1871.                          frag_start, frag_len);
  1872. -        if(!frag_count)
  1873. -        {
  1874. +        if (!frag_count) {
  1875. +            end_request (0);
  1876.              goto repeat;
  1877.          }
  1878.          
  1879.          block = frag_start[0];
  1880.          frag_sectors = nsect = frag_len[0];
  1881.          frag_pos = 0;
  1882. -    }
  1883. -    else
  1884. -    {
  1885. +    } else {
  1886.          frag_pos = 0;
  1887.          frag_count = 1;
  1888.          frag_sectors = nsect;
  1889. -        if(CURRENT->cmd == WRITE)
  1890. -        { /* Protect normal HD from writes */
  1891. +        if (CURRENT->cmd == WRITE) { /* Protect normal HD from writes */
  1892.              printk("hd%d : attempted write on protected drive\n",dev);
  1893.              end_request(0);
  1894.              goto repeat;
  1895.          }
  1896.      }
  1897. -    if(issue_request(dev,block,nsect, CURRENT))
  1898. +    if (issue_request(dev, block, nsect, CURRENT))
  1899.          goto repeat;
  1900.  }
  1901.  
  1902. @@ -829,7 +827,7 @@
  1903.  int issue_request(int dev, unsigned int block, unsigned int nsect, struct request *current_req)
  1904.  {
  1905.      unsigned int sec, track, head, cyl;
  1906. -int d = dev;
  1907. +    int d = dev;
  1908.      dev >>= 6;
  1909.      if (special_op[dev]) {
  1910.          if (do_special_op(dev))
  1911. @@ -856,7 +854,6 @@
  1912.          return 0;
  1913.      }
  1914.      if (current_req->cmd == WRITE) {
  1915. -#if 1
  1916.  #if 0
  1917.          if (mult_count[dev])
  1918.              hd_out(dev,nsect,sec,head,cyl,WIN_MULTWRITE,&multwrite_intr);
  1919. @@ -876,14 +873,6 @@
  1920.          } else
  1921.  #endif
  1922.              outsw(HD_DATA,current_req->buffer,256);
  1923. -if(d == 1 && block < 10) while(1);
  1924. -#else
  1925. -if(d == 1)
  1926. -        printk("write: buffer = %p (%08lX)\n", current_req->buffer, *(unsigned long *)current_req->buffer);
  1927. -{int i; for(i=0; i<0x003fffff; i++); }
  1928. -        end_request(0);
  1929. -        return 1;
  1930. -#endif
  1931.          return 0;
  1932.      }
  1933.      panic("unknown hd-command");
  1934. @@ -978,8 +967,7 @@
  1935.          case HDIO_SET_MULTCOUNT:
  1936.              if (!suser()) return -EACCES;
  1937.              if (MINOR(inode->i_rdev) & 0x3F) return -EINVAL;
  1938. -            save_flags(flags);
  1939. -            cli();    /* a prior request might still be in progress */
  1940. +            save_flags_cli (flags);    /* a prior request might still be in progress */
  1941.              if (arg > max_mult[dev])
  1942.                  err = -EINVAL;    /* out of range for device */
  1943.              else if (mult_req[dev] != mult_count[dev]) {
  1944. @@ -1067,25 +1055,25 @@
  1945.  }
  1946.  
  1947.  
  1948. -void set_hdinfo(int dev,unsigned char secsptrack,unsigned char heads,
  1949. +void hd_set_geometry (kdev_t dev,unsigned char secsptrack,unsigned char heads,
  1950.                      unsigned long discsize,unsigned int secsize)
  1951.  {
  1952. -  dev=MINOR(dev);
  1953. -  if(hd_info[dev>>6].cyl==1)
  1954. -  {
  1955. -    hd_info[dev>>6].cyl=discsize/(secsptrack*heads*secsize);
  1956. -    hd_info[dev>>6].head=heads;
  1957. -    hd_info[dev>>6].wpcom=-1;
  1958. -    hd_info[dev>>6].ctl=8;
  1959. -    hd_info[dev>>6].lzone=hd_info[dev>>6].cyl-1;
  1960. -    hd_info[dev>>6].sect=secsptrack;
  1961. -  }
  1962. -  hd[dev].start_sect=0;
  1963. -  hd[dev].nr_sects=discsize/secsize;
  1964. -#if 0
  1965. -  printk("hd%c: %d cylinders, %d heads, %d sectors (%d total)\n",'a'+(dev>>6),
  1966. -    hd_info[dev>>6].cyl, heads, secsptrack, discsize);
  1967. -#endif
  1968. +    int minor = MINOR(dev);
  1969. +    /*
  1970. +     * Only set the number of cylinders if the
  1971. +     * drive hasn't reported its geometery to the
  1972. +     * driver code yet.
  1973. +     */
  1974. +    if (hd_info[minor>>6].cyl == 1) {
  1975. +    hd_info[minor>>6].cyl = discsize/(secsptrack*heads*secsize);
  1976. +    hd_info[minor>>6].head = heads;
  1977. +    hd_info[minor>>6].wpcom = -1;
  1978. +    hd_info[minor>>6].ctl = 8;
  1979. +    hd_info[minor>>6].lzone = hd_info[dev>>6].cyl-1;
  1980. +    hd_info[minor>>6].sect = secsptrack;
  1981. +    }
  1982. +    hd[minor].start_sect = 0;
  1983. +    hd[minor].nr_sects = discsize / secsize;
  1984.  }
  1985.  
  1986.  /*
  1987. @@ -1099,53 +1087,63 @@
  1988.   */
  1989.  static void hd_geninit(struct gendisk *dev)
  1990.  {
  1991. -    int drive, i;
  1992. -
  1993. -NR_HD = 0;
  1994. -    if (!NR_HD) {
  1995. -    /* Default settings */
  1996. -        for (drive=0 ; drive<2 ; drive++) {
  1997. -            bios_info[drive].cyl    = hd_info[drive].cyl    = 1;
  1998. -            bios_info[drive].head    = hd_info[drive].head    = 1;
  1999. -            bios_info[drive].wpcom    = hd_info[drive].wpcom    = -1;
  2000. -            bios_info[drive].ctl    = hd_info[drive].ctl    = 8;
  2001. -            bios_info[drive].lzone    = hd_info[drive].lzone    = 1;
  2002. -            bios_info[drive].sect    = hd_info[drive].sect    = 17;
  2003. -            if(hd_info[drive].cyl && NR_HD == drive)
  2004. -                NR_HD++;
  2005. -        }
  2006. -        }
  2007. +    int drive, i;
  2008.  
  2009. +    if (!NR_HD) {
  2010. +    /*
  2011. +     * Default settings
  2012. +     *
  2013. +     * If we don't know anything about the drive, then set it
  2014. +     * so that we have enough to read the boot sector of the
  2015. +     * ADFS drive.  This means that you *MUST* specify the
  2016. +     * drive parameters of *all* drives if you have one IDE
  2017. +     * drive that is not ADFS formatted.
  2018. +     */
  2019. +    for (drive=0 ; drive<2 ; drive++) {
  2020. +        bios_info[drive].cyl    = hd_info[drive].cyl    = 1;
  2021. +        bios_info[drive].head    = hd_info[drive].head    = 1;
  2022. +        bios_info[drive].wpcom    = hd_info[drive].wpcom    = -1;
  2023. +        bios_info[drive].ctl    = hd_info[drive].ctl    = 8;
  2024. +        bios_info[drive].lzone    = hd_info[drive].lzone    = 1;
  2025. +        bios_info[drive].sect    = hd_info[drive].sect    = 17;
  2026. +    }
  2027. +    /*
  2028. +     * We only set this to the one that the host OS gave us
  2029. +     * if the user has not defined any types.
  2030. +     */
  2031.      NR_HD = no_hds;
  2032. +    }
  2033.  
  2034. -    i = NR_HD;
  2035. -    while (i-- > 0) {
  2036. -        /*
  2037. -         * The newer E-IDE BIOSs handle drives larger than 1024
  2038. -         * cylinders by increasing the number of logical heads
  2039. -         * to keep the number of logical cylinders below the
  2040. -         * sacred INT13 limit of 1024 (10 bits).  If that is
  2041. -         * what's happening here, we'll find out and correct
  2042. -         * it later when "identifying" the drive.
  2043. -         */
  2044. -        hd[i<<6].nr_sects = bios_info[i].head *
  2045. -                bios_info[i].sect * bios_info[i].cyl;
  2046. -        hd_ident_info[i] = (struct hd_driveid *) kmalloc(512,GFP_KERNEL);
  2047. -        special_op[i] = 1;
  2048. -    }
  2049. -    if (NR_HD) {
  2050. -        if (request_irq(HD_IRQ, hd_interrupt, SA_INTERRUPT, "hd")) {
  2051. -            printk("hd: unable to get IRQ%d for the harddisk driver\n",HD_IRQ);
  2052. -            NR_HD = 0;
  2053. -        } else {
  2054. -            request_region(HD_DATA, 8, "hd");
  2055. -            request_region(HD_CMD, 1, "hd(cmd)");
  2056. -        }
  2057. +    i = NR_HD;
  2058. +    while (i-- > 0) {
  2059. +    /*
  2060. +     * The newer E-IDE BIOSs handle drives larger than 1024
  2061. +     * cylinders by increasing the number of logical heads
  2062. +     * to keep the number of logical cylinders below the
  2063. +     * sacred INT13 limit of 1024 (10 bits).  If that is
  2064. +     * what's happening here, we'll find out and correct
  2065. +     * it later when "identifying" the drive.
  2066. +     */
  2067. +    hd[i<<6].nr_sects = bios_info[i].head *
  2068. +        bios_info[i].sect * bios_info[i].cyl;
  2069. +    hd_ident_info[i] = (struct hd_driveid *) kmalloc(512,GFP_KERNEL);
  2070. +    special_op[i] = 1;
  2071. +    }
  2072. +
  2073. +    if (NR_HD) {
  2074. +    if (request_irq(HD_IRQ, hd_interrupt, SA_INTERRUPT, "hd")) {
  2075. +        printk("hd: unable to get IRQ%d for the harddisk driver\n",HD_IRQ);
  2076. +        NR_HD = 0;
  2077. +    } else {
  2078. +        request_region(HD_DATA, 8, "hd");
  2079. +        request_region(HD_CMD, 1, "hd(cmd)");
  2080.      }
  2081. -    hd_gendisk.nr_real = NR_HD;
  2082. +    }
  2083. +    hd_gendisk.nr_real = NR_HD;
  2084.  
  2085. -    for(i=0;i<(MAX_HD << 6);i++) hd_blocksizes[i] = 1024;
  2086. -    blksize_size[MAJOR_NR] = hd_blocksizes;
  2087. +    for (i = 0; i < (MAX_HD << 6); i++)
  2088. +    hd_blocksizes[i] = 1024;
  2089. +    blksize_size[MAJOR_NR] = hd_blocksizes;
  2090.  }
  2091.  
  2092.  static struct file_operations hd_fops = {
  2093. @@ -1203,8 +1201,7 @@
  2094.      target =  DEVICE_NR(dev);
  2095.      gdev = &GENDISK_STRUCT;
  2096.  
  2097. -    save_flags(flags);
  2098. -    cli();
  2099. +    save_flags_cli (flags);
  2100.      if (DEVICE_BUSY || USAGE > maxusage) {
  2101.          restore_flags(flags);
  2102.          return -EBUSY;
  2103. diff -urN linux.store/linux/arch/arm/drivers/block/hdsrch.c linux/arch/arm/drivers/block/hdsrch.c
  2104. --- linux.store/linux/arch/arm/drivers/block/hdsrch.c    Sun Mar  3 12:29:41 1996
  2105. +++ linux/arch/arm/drivers/block/hdsrch.c    Mon Mar 11 23:51:02 1996
  2106. @@ -11,6 +11,8 @@
  2107.  #include <linux/ctype.h>
  2108.  #include <linux/kernel.h>
  2109.  #include <linux/mm.h>
  2110. +#include <linux/kdev_t.h>
  2111. +#include <linux/major.h>
  2112.  #include <linux/malloc.h>
  2113.  #include <linux/string.h>
  2114.  #include <linux/genhd.h>
  2115. @@ -19,8 +21,6 @@
  2116.  
  2117.  #define MAX_BLK_FRAGS 64
  2118.  
  2119. -extern void print_minor_name (struct gendisk *hd, int minor);
  2120. -
  2121.  struct boot_block
  2122.  {
  2123.    unsigned char  log2secsize;
  2124. @@ -42,31 +42,32 @@
  2125.  };
  2126.  
  2127.  static struct boot_block *boot=NULL;
  2128. +static void *map=NULL;
  2129.  static unsigned int zonesize;
  2130.  static unsigned int idsperzone;
  2131.  static long rootaddr;
  2132.  static long mapaddr;
  2133.  static long maplen;
  2134. -static void *map=NULL;
  2135. -static char ignoring;
  2136. +static kdev_t ignoring;
  2137.  
  2138. -static int read_sectors(int dev,void *ptr,long address,int size)
  2139. +static int read_sectors(kdev_t dev, void *ptr, long address, int size)
  2140.  {
  2141.    struct buffer_head *bh;
  2142. -  char *p=ptr;
  2143. -  while(size>0) {
  2144. -    if((bh=bread(dev,address/1024,1024))) {
  2145. -      memcpy(p,bh->b_data+((address & 0x200)?512:0),(address & 0x200 || size<1024)?512:1024);
  2146. -      if(address & 0x200) {
  2147. +  char *p = ptr;
  2148. +  while (size > 0) {
  2149. +    if ((bh = bread(dev, address / 1024, 1024))) {
  2150. +      memcpy (p, bh->b_data + ((address & 0x200) ? 512 : 0),
  2151. +        (address & 0x200 || size < 1024) ? 512 : 1024);
  2152. +      if (address & 0x200) {
  2153.            p -= 512;
  2154.          address -= 512;
  2155.          size += 512;
  2156.        }
  2157.      } else {
  2158. -      printk("hda%c: bread failed\n",'a'+((dev & 0xc0)>>6));
  2159. +      printk ("Device %s: bread failed\n", kdevname(dev));
  2160.        return 0;
  2161.      }
  2162. -    brelse(bh);
  2163. +    brelse (bh);
  2164.      p += 1024;
  2165.      address += 1024;
  2166.      size -= 1024;
  2167. @@ -74,27 +75,46 @@
  2168.    return 1;
  2169.  }
  2170.  
  2171. +static void set_hdinfo (kdev_t dev, unsigned char sectspertrack, unsigned char heads,
  2172. +        unsigned long disksize, unsigned int sectorsize)
  2173. +{
  2174. +    extern void hd_set_geometry (kdev_t dev, unsigned char, unsigned char, unsigned long, unsigned int);
  2175. +    extern void xd_set_geometry (kdev_t dev, unsigned char, unsigned char, unsigned long, unsigned int);
  2176. +
  2177. +    switch (MAJOR(dev)) {
  2178. +#ifdef CONFIG_BLK_DEV_HD
  2179. +    case HD_MAJOR:
  2180. +    hd_set_geometry (dev, sectspertrack, heads, disksize, sectorsize);
  2181. +    break;
  2182. +#endif
  2183. +
  2184. +#ifdef CONFIG_BLK_DEV_XD
  2185. +    case XD_MAJOR:
  2186. +    xd_set_geometry (dev, sectspertrack, heads, disksize, sectorsize);
  2187. +    break;
  2188. +#endif
  2189. +    }
  2190. +}
  2191. +
  2192.  /* + Read boot block at disc address &C00 (sector 6)
  2193.   * + Calculate map address & length
  2194.   */
  2195. -
  2196. -static int getdiskinfo(int dev)
  2197. +static int getdiskinfo(kdev_t dev)
  2198.  {
  2199.    char *ptr;
  2200. -  extern void set_hdinfo(int,unsigned char,unsigned char,unsigned long,unsigned int);
  2201.  
  2202.    if(boot)
  2203.        return 1;
  2204.  
  2205.    boot=(struct boot_block *)kmalloc(sizeof(struct boot_block),GFP_KERNEL);
  2206. -  if(!boot) {
  2207. -    printk("hda%c: out of memory for bootblock\n",(dev>>6)+'a');
  2208. +  if (!boot) {
  2209. +    printk("Device %s: out of memory for bootblock\n", kdevname(dev));
  2210.      return 0;
  2211.    }
  2212.  
  2213.    ptr=(char *)kmalloc(1024,GFP_KERNEL);
  2214. -  if(!ptr) {
  2215. -    printk("hda%c: out of memory for bootblock\n",(dev>>6)+'a');
  2216. +  if (!ptr) {
  2217. +    printk("Device %s: out of memory for bootblock\n", kdevname(dev));
  2218.      return 0;
  2219.    }
  2220.  
  2221. @@ -126,7 +146,7 @@
  2222.    return check;
  2223.  }
  2224.  
  2225. -static int get_map(int dev)
  2226. +static int get_map(kdev_t dev)
  2227.  {
  2228.    if(!getdiskinfo(dev))
  2229.      return 0;
  2230. @@ -146,7 +166,7 @@
  2231.        return 0;
  2232.      if(map_cross_valid_byte()!=0xFF) {
  2233.        printk("Map 2 has invalid cross check - ignoring drive\n");
  2234. -      ignoring=dev;
  2235. +      ignoring = dev;
  2236.        return 0;
  2237.      }
  2238.    }
  2239. @@ -250,7 +270,7 @@
  2240.    }
  2241.  }
  2242.  
  2243. -static unsigned long scandir(int dev,unsigned long diraddress,char *file,int *type,
  2244. +static unsigned long scandir(kdev_t dev,unsigned long diraddress,char *file,int *type,
  2245.         unsigned long *length)
  2246.  {
  2247.    unsigned char *dir;
  2248. @@ -289,7 +309,7 @@
  2249.    return addr;
  2250.  }
  2251.  
  2252. -static int search_path(int dev,char *path,unsigned long *start,unsigned long *length, int maxbits)
  2253. +static int search_path(kdev_t dev,char *path,unsigned long *start,unsigned long *length, int maxbits)
  2254.  {
  2255.    unsigned long dir,iad,len;
  2256.    int type,i,n,fzones[MAX_BLK_FRAGS],fstart[MAX_BLK_FRAGS],fend[MAX_BLK_FRAGS];
  2257. @@ -386,7 +406,6 @@
  2258.  }
  2259.  
  2260.  #define MAX_HD_IMAGES    8
  2261. -#define TWO_HDS
  2262.  #define MAX_HD_BITS    128
  2263.  
  2264.  static int initialised[MAX_HD_IMAGES];
  2265. @@ -409,75 +428,122 @@
  2266.    {0,},
  2267.    {0,},
  2268.    {0,},
  2269. +  {0,},
  2270. +  {0,},
  2271. +  {0,},
  2272. +  {0,},
  2273.    {0,}
  2274.  };
  2275.  
  2276. +/* 
  2277. + * This function  maps a device major/minor to the internal image file number
  2278. + */
  2279. +static inline int get_dev (kdev_t dev, char *where)
  2280. +{
  2281. +    switch (MAJOR(dev)) {
  2282. +#ifdef CONFIG_BLK_DEV_HD
  2283. +    case HD_MAJOR:    /* IDE drives */
  2284. +#elif defined(CONFIG_BLK_DEV_XD)
  2285. +    case XD_MAJOR:    /* ST506 drives (map onto IDE at the moment) */
  2286. +#endif
  2287. +    if ((MINOR(dev) & 0x3f) < 1 || (MINOR(dev) & 0x3f) > 0x14) {
  2288. +        printk ("%s: bad device %s\n", where, kdevname (dev));
  2289. +        return -1;
  2290. +    }
  2291. +    switch (MINOR(dev) & 0xc0) {
  2292. +    case 0x00:  return (MINOR(dev) - 1) & 3;
  2293. +    case 0x40:  return ((MINOR(dev) - 1) & 3) + 4;
  2294. +    default:
  2295. +        printk ("%s: bad device %s\n", where, kdevname (dev));
  2296. +        return -1;
  2297. +    }
  2298. +
  2299. +    default:
  2300. +        printk ("%s: unsupported device %s\n", where, kdevname (dev));
  2301. +        return -1;
  2302. +    }
  2303. +}
  2304. +
  2305.  /*
  2306.   * Get the sectors used by device 'dev'
  2307.   */
  2308. -int image_allocate_list(int dev,int devno,struct hd_struct *part)
  2309. +int image_allocate_list(kdev_t dev, int devno, struct hd_struct *part)
  2310.  {
  2311. -    unsigned long chk1=0,chk2=0;
  2312. -    int i,sects=0;
  2313. +    unsigned long chk1 = 0, chk2 = 0;
  2314. +    int i, sects = 0;
  2315.  
  2316. -#ifndef TWO_HDS
  2317. -    if(dev!=0x300)
  2318. -    {
  2319. -        printk("Can't cope with >1 hd!\n");
  2320. +    switch (MAJOR(dev)) {
  2321. +#ifdef CONFIG_BLK_DEV_HD
  2322. +    case HD_MAJOR:    /* IDE drives */
  2323. +#elif defined(CONFIG_BLK_DEV_XD)
  2324. +    case XD_MAJOR:    /* ST506 drives (map onto IDE at the moment) */
  2325. +#endif    
  2326. +    switch (MINOR(dev) & 0xc0) {
  2327. +    case 0x00:
  2328. +        if (devno == 0 || devno > 4) {
  2329. +        printk ("image_allocate_list: only 4 images per drive allowed\n");
  2330.          return 0;
  2331. -    }
  2332. -#else
  2333. -    if(dev!=0x300 && dev!=0x340)
  2334. -    {
  2335. -        printk("Can't cope with >2 hds! (device %02X:%02X)\n",dev>>8,dev & 255);
  2336. +        }
  2337. +        devno = devno - 1;
  2338. +        break;
  2339. +    case 0x40:
  2340. +        devno &= 0x3f;
  2341. +        if (devno == 0 || devno > 4) {
  2342. +        printk ("image_allocate_list: only 4 images per drive allowed\n");
  2343.          return 0;
  2344. +        }
  2345. +        devno = devno + 3;
  2346. +        break;
  2347. +    default:
  2348. +        printk ("image_allocate_list: only two IDE drives supported\n");
  2349. +        return 0;
  2350.      }
  2351. -    if(dev == 0x340)
  2352. -      devno=(devno & 0x3f) + 4;
  2353. -#endif
  2354. -
  2355. -    if(ignoring==dev)
  2356. -        return 0;
  2357. +    break;
  2358. +    default:
  2359. +    printk ("image_allocate_list: only IDE drives supported: %s\n", kdevname (dev));
  2360. +    return 0;
  2361. +    }
  2362.  
  2363. -    devno--;
  2364. +    if (ignoring == dev)
  2365. +    return 0;
  2366.  
  2367. -    if(devno > MAX_HD_IMAGES)
  2368. -        return 0;
  2369. +    if (devno > MAX_HD_IMAGES)
  2370. +    return 0;
  2371.  
  2372. -    if(!arc_hd_files[devno][0])
  2373. -        return 0;
  2374. +    if (!arc_hd_files[devno][0])
  2375. +    return 0;
  2376.  
  2377.  #ifndef NOT_YET_TESTED
  2378. -    maxblock[devno]=search_path(dev,arc_hd_files[devno],startaddr[devno],lengthaddr[devno],MAX_HD_BITS);
  2379. +    maxblock[devno] = search_path(dev, arc_hd_files[devno], startaddr[devno], lengthaddr[devno], MAX_HD_BITS);
  2380.  #else
  2381. -    maxblock[devno]=search_path(dev,arc_hd_files[devno],startaddr[devno],lengthaddr[devno],0);
  2382. +    maxblock[devno] = search_path(dev, arc_hd_files[devno], startaddr[devno], lengthaddr[devno], 0);
  2383.  #endif
  2384. -    if(maxblock[devno]>MAX_HD_BITS)
  2385. -        panic("image allocator: image file is too fragmented\n");
  2386. -    if(!maxblock[devno])
  2387. -        return 0;
  2388. +    if (maxblock[devno] > MAX_HD_BITS)
  2389. +    panic ("image_allocate_list: image file is too fragmented\n");
  2390. +
  2391. +    if (!maxblock[devno])
  2392. +    return 0;
  2393.  
  2394. -    for(i=0; i<maxblock[devno]; i++)
  2395. -    {
  2396. -        /* convert to blocks & calculate checksums */
  2397. +    for (i = 0; i < maxblock[devno]; i++) {
  2398. +    /* convert to blocks & calculate checksums */
  2399.  #define ADDR2BLOCK(x) ((x)>>9)
  2400. -        startaddr[devno][i]=ADDR2BLOCK(startaddr[devno][i]);
  2401. -        lengthaddr[devno][i]=ADDR2BLOCK(lengthaddr[devno][i]);
  2402. -        chk1^=startaddr[devno][i];
  2403. -        chk2^=lengthaddr[devno][i];
  2404. -        sects+=lengthaddr[devno][i];
  2405. -    }
  2406. -    startchk[devno]=chk1;
  2407. -    lengthchk[devno]=chk2;
  2408. -    initialised[devno]=1;
  2409. -    part->start_sect=0;
  2410. -    part->nr_sects=sects;
  2411. +    startaddr[devno][i] = ADDR2BLOCK(startaddr[devno][i]);
  2412. +    lengthaddr[devno][i] = ADDR2BLOCK(lengthaddr[devno][i]);
  2413. +    chk1 ^= startaddr[devno][i];
  2414. +    chk2 ^= lengthaddr[devno][i];
  2415. +    sects += lengthaddr[devno][i];
  2416. +    }
  2417. +    startchk[devno] = chk1;
  2418. +    lengthchk[devno] = chk2;
  2419. +    initialised[devno] = 1;
  2420. +    part->start_sect = 0;
  2421. +    part->nr_sects = sects;
  2422.  
  2423.  #ifdef DEBUG
  2424. -    for(i=0;i<n;i++)
  2425. -        printk("%10X : %10X\n",start[devno][i],length[devno][i]);
  2426. +    for (i = 0; i < n; i++)
  2427. +    printk ("%10X : %10X\n",start[devno][i],length[devno][i]);
  2428.  #endif
  2429. -    return 1;
  2430. +    return 1;
  2431.  }
  2432.  
  2433.  /*
  2434. @@ -486,80 +552,58 @@
  2435.   * This must be called before accessing a new device
  2436.   */
  2437.  
  2438. -void image_release_dev(int dev)
  2439. +void image_release_dev (kdev_t dev)
  2440.  {
  2441. -  if(boot) {
  2442. -    kfree_s(boot,sizeof(struct boot_block));
  2443. -    boot=NULL;
  2444. -  }
  2445. +    if(boot) {
  2446. +    kfree (boot);
  2447. +    boot = NULL;
  2448. +    }
  2449.  
  2450. -  if(map) {
  2451. -    vfree(map);
  2452. -    map = NULL;
  2453. -  }
  2454. +    if(map) {
  2455. +    vfree (map);
  2456. +    map = NULL;
  2457. +    }
  2458.  
  2459. -  ignoring=0;
  2460. +    ignoring = 0;
  2461.  }
  2462.  
  2463.  /* 
  2464. - * This macro maps a device major/minor to the internal image file number
  2465. - */
  2466. -#ifndef TWO_HDS
  2467. -#define GET_DEV(dev) \
  2468. -    if((dev)<0x301 || (dev)>0x314) \
  2469. -    { \
  2470. -        printk("Bad device %X passed to image_file_check\n",(dev)); \
  2471. -        return 0; \
  2472. -    } \
  2473. -    (dev)=((dev)-1) & 3;
  2474. -#else
  2475. -#define GET_DEV(dev) \
  2476. -    if(((dev) & 0x33F)<0x301 || ((dev) & 0x33F)>0x314) \
  2477. -    { \
  2478. -        printk("Bad device %X passed to image_file_check\n",(dev)); \
  2479. -        return 0; \
  2480. -    } \
  2481. -    switch((dev) & 0xC0) \
  2482. -    { \
  2483. -        case 0x00: (dev)=((dev) -1) & 3;     break;\
  2484. -        case 0x40: (dev)=(((dev) -1) & 3)+4; break;\
  2485. -    }
  2486. -#endif
  2487. -
  2488. -/* 
  2489.   * This function is called to perform checks on the image file.
  2490.   *  Checks made: Image file has been initialised, and
  2491.   *     for writes, the checksums on the start/length data are correct.
  2492.   */
  2493. -int image_file_check(int dev,int cmd)
  2494. +int image_file_check (kdev_t dev,int cmd)
  2495.  {
  2496. -    long chk1=0,chk2=0;
  2497. -    int i;
  2498. +    unsigned long chk1 = 0, chk2 = 0;
  2499. +    int i, internal_dev;
  2500.  
  2501. -    GET_DEV(dev);
  2502. +    internal_dev = get_dev (dev, "image_file_check");
  2503.  
  2504. -    if (!initialised[dev]) {
  2505. -        printk("hd%c%d: %s of uninitialised image file.\n",(dev>>6)+'a',dev & 0x3f,
  2506. -          cmd==WRITE?"write":"read");
  2507. -        return 0;
  2508. -    }
  2509. +    if (internal_dev < 0)
  2510. +    return 0;
  2511.  
  2512. -    if (cmd==WRITE) {
  2513. -        /*
  2514. -         * Check the table! Just in case. We don't want to write to a part of the HD that
  2515. -         * is not allocated to us! It might be the map or something!
  2516. -         */
  2517. -        for(i=0; i<maxblock[dev]; i++) {
  2518. -              chk1^=startaddr[dev][i];
  2519. -              chk2^=lengthaddr[dev][i];
  2520. -        }
  2521. -        if(chk1!=startchk[dev] || chk2!=lengthchk[dev]) {
  2522. -            printk("hda%c%d: mapping tables corrupted on write.",
  2523. -                (dev>>6)+'a',dev & 0x3f);
  2524. -            return 0;
  2525. -        }
  2526. +    if (!initialised[internal_dev]) {
  2527. +    printk ("hd%c%d: %s of uninitialised image file.\n",
  2528. +        (dev >> 6) + 'a', dev & 0x3f, cmd == WRITE ? "write" : "read");
  2529. +    return 0;
  2530. +    }
  2531. +
  2532. +    if (cmd == WRITE) {
  2533. +    /*
  2534. +     * Check the table! Just in case. We don't want to write to a part of the HD that
  2535. +     * is not allocated to us! It might be the map or something!
  2536. +     */
  2537. +    for(i = 0; i < maxblock[internal_dev]; i++) {
  2538. +        chk1 ^= startaddr[internal_dev][i];
  2539. +        chk2 ^= lengthaddr[internal_dev][i];
  2540.      }
  2541. -    return 1;
  2542. +    if (chk1 != startchk[internal_dev] || chk2 != lengthchk[internal_dev]) {
  2543. +        printk ("hda%c%d: mapping tables corrupted on write.",
  2544. +            (dev >> 6) + 'a', dev & 0x3f);
  2545. +        return 0;
  2546. +    }
  2547. +    }
  2548. +    return 1;
  2549.  }
  2550.  
  2551.  /*
  2552. @@ -567,43 +611,43 @@
  2553.   * or the number of entries.  This is called quite often when accessing
  2554.   * image files.
  2555.   */
  2556. -int image_file_map(int dev,unsigned long reqblock,unsigned long reqlength,
  2557. -            unsigned long max_reqs,
  2558. -                    unsigned long *block,unsigned long *length)
  2559. -{
  2560. -    int i,num=0;
  2561. -    unsigned long blk=reqblock,totlen=0;
  2562. -
  2563. -    GET_DEV(dev);
  2564. -
  2565. -    for(i=0; i<maxblock[dev]; i++)
  2566. -    {
  2567. -        long remainder;
  2568. -        totlen+=lengthaddr[dev][i];
  2569. -        if(reqblock >= lengthaddr[dev][i])
  2570. -        {
  2571. -            reqblock-=lengthaddr[dev][i];
  2572. -            continue;
  2573. -        }
  2574. -        block[num]=reqblock+startaddr[dev][i];
  2575. -        remainder=reqblock+reqlength-lengthaddr[dev][i];
  2576. -        if(remainder<=0)
  2577. -        {
  2578. -            length[num]=reqlength;
  2579. -            return num+1;
  2580. -        }
  2581. -        length[num]=lengthaddr[dev][i]-reqblock;
  2582. -        if(num+1 >= max_reqs)
  2583. -            return num+1;
  2584. -        reqblock=0;
  2585. -        reqlength=remainder;
  2586. -        num++;
  2587. -    }
  2588. +int image_file_map(kdev_t dev, unsigned long reqblock, unsigned long reqlength,
  2589. +            unsigned long max_reqs, unsigned long *block, unsigned long *length)
  2590. +{
  2591. +    unsigned long blk = reqblock, totlen = 0;
  2592. +    int i, num = 0;
  2593. +    int internal_dev;
  2594. +
  2595. +    internal_dev = get_dev (dev, "image_file_map");
  2596.  
  2597. -    printk("hd%c%d: attempted read for sector %ld past end if image file at %ld.\n",
  2598. -        (dev>>6)+'a',dev & 0x3f,blk,totlen);
  2599. -        /* Should never happen! */
  2600. +    if (internal_dev < 0)
  2601.      return 0;
  2602. +
  2603. +    for (i = 0; i < maxblock[internal_dev]; i++) {
  2604. +    long remainder;
  2605. +    totlen += lengthaddr[internal_dev][i];
  2606. +    if (reqblock >= lengthaddr[internal_dev][i]) {
  2607. +        reqblock -= lengthaddr[internal_dev][i];
  2608. +        continue;
  2609. +    }
  2610. +    block[num] = reqblock + startaddr[internal_dev][i];
  2611. +    remainder = reqblock + reqlength - lengthaddr[internal_dev][i];
  2612. +    if (remainder <= 0) {
  2613. +        length[num] = reqlength;
  2614. +        return num + 1;
  2615. +    }
  2616. +    length[num] = lengthaddr[internal_dev][i] - reqblock;
  2617. +    if (num + 1 >= max_reqs)
  2618. +        return num + 1;
  2619. +    reqblock = 0;
  2620. +    reqlength = remainder;
  2621. +    num++;
  2622. +    }
  2623. +
  2624. +    printk ("hd%c%d: attempted read for sector %ld past end if image file at %ld.\n",
  2625. +    (dev >> 6) + 'a', dev & 0x3f, blk, totlen);
  2626. +    /* Should never happen! */
  2627. +    return 0;
  2628.  }
  2629.  
  2630.  
  2631. diff -urN linux.store/linux/arch/arm/drivers/block/ll_rw_blk.c linux/arch/arm/drivers/block/ll_rw_blk.c
  2632. --- linux.store/linux/arch/arm/drivers/block/ll_rw_blk.c    Thu Jan  1 01:00:00 1970
  2633. +++ linux/arch/arm/drivers/block/ll_rw_blk.c    Wed Mar 13 14:45:40 1996
  2634. @@ -0,0 +1,649 @@
  2635. +/*
  2636. + *  linux/drivers/block/ll_rw_blk.c
  2637. + *
  2638. + * Copyright (C) 1991, 1992 Linus Torvalds
  2639. + * Copyright (C) 1994,      Karl Keyte: Added support for disk statistics
  2640. + */
  2641. +
  2642. +/*
  2643. + * This handles all read/write requests to block devices
  2644. + */
  2645. +#include <linux/sched.h>
  2646. +#include <linux/kernel.h>
  2647. +#include <linux/kernel_stat.h>
  2648. +#include <linux/errno.h>
  2649. +#include <linux/string.h>
  2650. +#include <linux/config.h>
  2651. +#include <linux/locks.h>
  2652. +#include <linux/mm.h>
  2653. +
  2654. +#include <asm/system.h>
  2655. +#include <asm/io.h>
  2656. +#include "blk.h"
  2657. +
  2658. +/*
  2659. + * The request-struct contains all necessary data
  2660. + * to load a nr of sectors into memory
  2661. + */
  2662. +static struct request all_requests[NR_REQUEST];
  2663. +
  2664. +/*
  2665. + * used to wait on when there are no free requests
  2666. + */
  2667. +struct wait_queue * wait_for_request = NULL;
  2668. +
  2669. +/* This specifies how many sectors to read ahead on the disk.  */
  2670. +
  2671. +int read_ahead[MAX_BLKDEV] = {0, };
  2672. +
  2673. +/* blk_dev_struct is:
  2674. + *    do_request-address
  2675. + *    next-request
  2676. + */
  2677. +struct blk_dev_struct blk_dev[MAX_BLKDEV] = {
  2678. +    { NULL, NULL },        /* 0 no_dev */
  2679. +    { NULL, NULL },        /* 1 dev mem */
  2680. +    { NULL, NULL },        /* 2 dev fd */
  2681. +    { NULL, NULL },        /* 3 dev ide0 or hd */
  2682. +    { NULL, NULL },        /* 4 dev ttyx */
  2683. +    { NULL, NULL },        /* 5 dev tty */
  2684. +    { NULL, NULL },        /* 6 dev lp */
  2685. +    { NULL, NULL },        /* 7 dev pipes */
  2686. +    { NULL, NULL },        /* 8 dev sd */
  2687. +    { NULL, NULL },        /* 9 dev st */
  2688. +    { NULL, NULL },        /* 10 */
  2689. +    { NULL, NULL },        /* 11 */
  2690. +    { NULL, NULL },        /* 12 */
  2691. +    { NULL, NULL },        /* 13 */
  2692. +    { NULL, NULL },        /* 14 */
  2693. +    { NULL, NULL },        /* 15 */
  2694. +    { NULL, NULL },        /* 16 */
  2695. +    { NULL, NULL },        /* 17 */
  2696. +    { NULL, NULL },        /* 18 */
  2697. +    { NULL, NULL },        /* 19 */
  2698. +    { NULL, NULL },        /* 20 */
  2699. +    { NULL, NULL },        /* 21 */
  2700. +    { NULL, NULL }        /* 22 dev ide1 */
  2701. +};
  2702. +
  2703. +/*
  2704. + * blk_size contains the size of all block-devices in units of 1024 byte
  2705. + * sectors:
  2706. + *
  2707. + * blk_size[MAJOR][MINOR]
  2708. + *
  2709. + * if (!blk_size[MAJOR]) then no minor size checking is done.
  2710. + */
  2711. +int * blk_size[MAX_BLKDEV] = { NULL, NULL, };
  2712. +
  2713. +/*
  2714. + * blksize_size contains the size of all block-devices:
  2715. + *
  2716. + * blksize_size[MAJOR][MINOR]
  2717. + *
  2718. + * if (!blksize_size[MAJOR]) then 1024 bytes is assumed.
  2719. + */
  2720. +int * blksize_size[MAX_BLKDEV] = { NULL, NULL, };
  2721. +
  2722. +/*
  2723. + * hardsect_size contains the size of the hardware sector of a device.
  2724. + *
  2725. + * hardsect_size[MAJOR][MINOR]
  2726. + *
  2727. + * if (!hardsect_size[MAJOR])
  2728. + *        then 512 bytes is assumed.
  2729. + * else
  2730. + *        sector_size is hardsect_size[MAJOR][MINOR]
  2731. + * This is currently set by some scsi device and read by the msdos fs driver
  2732. + * This might be a some uses later.
  2733. + */
  2734. +int * hardsect_size[MAX_BLKDEV] = { NULL, NULL, };
  2735. +
  2736. +/*
  2737. + * "plug" the device if there are no outstanding requests: this will
  2738. + * force the transfer to start only after we have put all the requests
  2739. + * on the list.
  2740. + */
  2741. +static void plug_device(struct blk_dev_struct * dev, struct request * plug)
  2742. +{
  2743. +    unsigned long flags;
  2744. +
  2745. +    plug->rq_status = RQ_INACTIVE;
  2746. +    plug->cmd = -1;
  2747. +    plug->next = NULL;
  2748. +    save_flags(flags);
  2749. +    cli();
  2750. +    if (!dev->current_request)
  2751. +        dev->current_request = plug;
  2752. +    restore_flags(flags);
  2753. +}
  2754. +
  2755. +/*
  2756. + * remove the plug and let it rip..
  2757. + */
  2758. +static void unplug_device(struct blk_dev_struct * dev)
  2759. +{
  2760. +    struct request * req;
  2761. +    unsigned long flags;
  2762. +
  2763. +    save_flags(flags);
  2764. +    cli();
  2765. +    req = dev->current_request;
  2766. +    if (req && req->rq_status == RQ_INACTIVE && req->cmd == -1) {
  2767. +        dev->current_request = req->next;
  2768. +        (dev->request_fn)();
  2769. +    }
  2770. +    restore_flags(flags);
  2771. +}
  2772. +
  2773. +/*
  2774. + * look for a free request in the first N entries.
  2775. + * NOTE: interrupts must be disabled on the way in, and will still
  2776. + *       be disabled on the way out.
  2777. + */
  2778. +static inline struct request * get_request(int n, kdev_t dev)
  2779. +{
  2780. +    static struct request *prev_found = NULL, *prev_limit = NULL;
  2781. +    register struct request *req, *limit;
  2782. +
  2783. +    if (n <= 0)
  2784. +        panic("get_request(%d): impossible!\n", n);
  2785. +
  2786. +    limit = all_requests + n;
  2787. +    if (limit != prev_limit) {
  2788. +        prev_limit = limit;
  2789. +        prev_found = all_requests;
  2790. +    }
  2791. +    req = prev_found;
  2792. +    for (;;) {
  2793. +        req = ((req > all_requests) ? req : limit) - 1;
  2794. +        if (req->rq_status == RQ_INACTIVE)
  2795. +            break;
  2796. +        if (req == prev_found)
  2797. +            return NULL;
  2798. +    }
  2799. +    prev_found = req;
  2800. +    req->rq_status = RQ_ACTIVE;
  2801. +    req->rq_dev = dev;
  2802. +    return req;
  2803. +}
  2804. +
  2805. +/*
  2806. + * wait until a free request in the first N entries is available.
  2807. + */
  2808. +static struct request * __get_request_wait(int n, kdev_t dev)
  2809. +{
  2810. +    register struct request *req;
  2811. +    struct wait_queue wait = { current, NULL };
  2812. +
  2813. +    add_wait_queue(&wait_for_request, &wait);
  2814. +    for (;;) {
  2815. +        unplug_device(MAJOR(dev)+blk_dev);
  2816. +        current->state = TASK_UNINTERRUPTIBLE;
  2817. +        cli();
  2818. +        req = get_request(n, dev);
  2819. +        sti();
  2820. +        if (req)
  2821. +            break;
  2822. +        schedule();
  2823. +    }
  2824. +    remove_wait_queue(&wait_for_request, &wait);
  2825. +    current->state = TASK_RUNNING;
  2826. +    return req;
  2827. +}
  2828. +
  2829. +static inline struct request * get_request_wait(int n, kdev_t dev)
  2830. +{
  2831. +    register struct request *req;
  2832. +
  2833. +    cli();
  2834. +    req = get_request(n, dev);
  2835. +    sti();
  2836. +    if (req)
  2837. +        return req;
  2838. +    return __get_request_wait(n, dev);
  2839. +}
  2840. +
  2841. +/* RO fail safe mechanism */
  2842. +
  2843. +static long ro_bits[MAX_BLKDEV][8];
  2844. +
  2845. +int is_read_only(kdev_t dev)
  2846. +{
  2847. +    int minor,major;
  2848. +
  2849. +    major = MAJOR(dev);
  2850. +    minor = MINOR(dev);
  2851. +    if (major < 0 || major >= MAX_BLKDEV) return 0;
  2852. +    return ro_bits[major][minor >> 5] & (1 << (minor & 31));
  2853. +}
  2854. +
  2855. +void set_device_ro(kdev_t dev,int flag)
  2856. +{
  2857. +    int minor,major;
  2858. +
  2859. +    major = MAJOR(dev);
  2860. +    minor = MINOR(dev);
  2861. +    if (major < 0 || major >= MAX_BLKDEV) return;
  2862. +    if (flag) ro_bits[major][minor >> 5] |= 1 << (minor & 31);
  2863. +    else ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
  2864. +}
  2865. +
  2866. +/*
  2867. + * add-request adds a request to the linked list.
  2868. + * It disables interrupts so that it can muck with the
  2869. + * request-lists in peace.
  2870. + */
  2871. +static void add_request(struct blk_dev_struct * dev, struct request * req)
  2872. +{
  2873. +    struct request * tmp;
  2874. +    short         disk_index;
  2875. +
  2876. +    switch (MAJOR(req->rq_dev)) {
  2877. +        case SCSI_DISK_MAJOR:
  2878. +            disk_index = (MINOR(req->rq_dev) & 0x0070) >> 4;
  2879. +            if (disk_index < 4)
  2880. +                kstat.dk_drive[disk_index]++;
  2881. +            break;
  2882. +        case IDE0_MAJOR:    /* same as HD_MAJOR */
  2883. +        case XT_DISK_MAJOR:
  2884. +            disk_index = (MINOR(req->rq_dev) & 0x0040) >> 6;
  2885. +            kstat.dk_drive[disk_index]++;
  2886. +            break;
  2887. +        case IDE1_MAJOR:
  2888. +            disk_index = ((MINOR(req->rq_dev) & 0x0040) >> 6) + 2;
  2889. +            kstat.dk_drive[disk_index]++;
  2890. +        default:
  2891. +            break;
  2892. +    }
  2893. +
  2894. +    req->next = NULL;
  2895. +    cli();
  2896. +    if (req->bh)
  2897. +        mark_buffer_clean(req->bh);
  2898. +    if (!(tmp = dev->current_request)) {
  2899. +        dev->current_request = req;
  2900. +        (dev->request_fn)();
  2901. +        sti();
  2902. +        return;
  2903. +    }
  2904. +    for ( ; tmp->next ; tmp = tmp->next) {
  2905. +        if ((IN_ORDER(tmp,req) ||
  2906. +            !IN_ORDER(tmp,tmp->next)) &&
  2907. +            IN_ORDER(req,tmp->next))
  2908. +            break;
  2909. +    }
  2910. +    req->next = tmp->next;
  2911. +    tmp->next = req;
  2912. +
  2913. +/* for SCSI devices, call request_fn unconditionally */
  2914. +    if (scsi_major(MAJOR(req->rq_dev)))
  2915. +        (dev->request_fn)();
  2916. +
  2917. +    sti();
  2918. +}
  2919. +
  2920. +static void make_request(int major,int rw, struct buffer_head * bh)
  2921. +{
  2922. +    unsigned int sector, count;
  2923. +    struct request * req;
  2924. +    int rw_ahead, max_req;
  2925. +
  2926. +/* WRITEA/READA is special case - it is not really needed, so if the */
  2927. +/* buffer is locked, we just forget about it, else it's a normal read */
  2928. +    rw_ahead = (rw == READA || rw == WRITEA);
  2929. +    if (rw_ahead) {
  2930. +        if (bh->b_lock)
  2931. +            return;
  2932. +        if (rw == READA)
  2933. +            rw = READ;
  2934. +        else
  2935. +            rw = WRITE;
  2936. +    }
  2937. +    if (rw!=READ && rw!=WRITE) {
  2938. +        printk("Bad block dev command, must be R/W/RA/WA\n");
  2939. +        return;
  2940. +    }
  2941. +    count = bh->b_size >> 9;
  2942. +    sector = bh->b_blocknr * count;
  2943. +    if (blk_size[major])
  2944. +        if (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
  2945. +            bh->b_dirt = bh->b_uptodate = 0;
  2946. +            bh->b_req = 0;
  2947. +            printk("attempt to access beyond end of device\n");
  2948. +            return;
  2949. +        }
  2950. +    /* Uhhuh.. Nasty dead-lock possible here.. */
  2951. +    if (bh->b_lock)
  2952. +        return;
  2953. +    /* Maybe the above fixes it, and maybe it doesn't boot. Life is interesting */
  2954. +    lock_buffer(bh);
  2955. +    if ((rw == WRITE && !bh->b_dirt) || (rw == READ && bh->b_uptodate)) {
  2956. +        unlock_buffer(bh);
  2957. +        return;
  2958. +    }
  2959. +
  2960. +/* we don't allow the write-requests to fill up the queue completely:
  2961. + * we want some room for reads: they take precedence. The last third
  2962. + * of the requests are only for reads.
  2963. + */
  2964. +    max_req = (rw == READ) ? NR_REQUEST : ((NR_REQUEST*2)/3);
  2965. +
  2966. +/* look for a free request. */
  2967. +    cli();
  2968. +
  2969. +/* The scsi disk drivers and the IDE driver completely remove the request
  2970. + * from the queue when they start processing an entry.  For this reason
  2971. + * it is safe to continue to add links to the top entry for those devices.
  2972. + */
  2973. +    if ((   major == IDE0_MAJOR    /* same as HD_MAJOR */
  2974. +         || major == IDE1_MAJOR
  2975. +         || major == FLOPPY_MAJOR
  2976. +         || major == SCSI_DISK_MAJOR
  2977. +         || major == SCSI_CDROM_MAJOR
  2978. +         || major == IDE2_MAJOR
  2979. +         || major == IDE3_MAJOR)
  2980. +        && (req = blk_dev[major].current_request))
  2981. +    {
  2982. +#ifdef CONFIG_BLK_DEV_HD
  2983. +            if (major == HD_MAJOR || major == FLOPPY_MAJOR)
  2984. +#else
  2985. +        if (major == FLOPPY_MAJOR)
  2986. +#endif CONFIG_BLK_DEV_HD
  2987. +            req = req->next;
  2988. +        while (req) {
  2989. +            if (req->rq_dev == bh->b_dev &&
  2990. +                !req->sem &&
  2991. +                req->cmd == rw &&
  2992. +                req->sector + req->nr_sectors == sector &&
  2993. +                req->nr_sectors < 244)
  2994. +            {
  2995. +                req->bhtail->b_reqnext = bh;
  2996. +                req->bhtail = bh;
  2997. +                req->nr_sectors += count;
  2998. +                mark_buffer_clean(bh);
  2999. +                sti();
  3000. +                return;
  3001. +            }
  3002. +
  3003. +            if (req->rq_dev == bh->b_dev &&
  3004. +                !req->sem &&
  3005. +                req->cmd == rw &&
  3006. +                req->sector - count == sector &&
  3007. +                req->nr_sectors < 244)
  3008. +            {
  3009. +                    req->nr_sectors += count;
  3010. +                    bh->b_reqnext = req->bh;
  3011. +                    req->buffer = bh->b_data;
  3012. +                    req->current_nr_sectors = count;
  3013. +                    req->sector = sector;
  3014. +                mark_buffer_clean(bh);
  3015. +                    req->bh = bh;
  3016. +                    sti();
  3017. +                    return;
  3018. +            }    
  3019. +
  3020. +            req = req->next;
  3021. +        }
  3022. +    }
  3023. +
  3024. +/* find an unused request. */
  3025. +    req = get_request(max_req, bh->b_dev);
  3026. +    sti();
  3027. +
  3028. +/* if no request available: if rw_ahead, forget it; otherwise try again blocking.. */
  3029. +    if (!req) {
  3030. +        if (rw_ahead) {
  3031. +            unlock_buffer(bh);
  3032. +            return;
  3033. +        }
  3034. +        req = __get_request_wait(max_req, bh->b_dev);
  3035. +    }
  3036. +
  3037. +/* fill up the request-info, and add it to the queue */
  3038. +    req->cmd = rw;
  3039. +    req->errors = 0;
  3040. +    req->sector = sector;
  3041. +    req->nr_sectors = count;
  3042. +    req->current_nr_sectors = count;
  3043. +    req->buffer = bh->b_data;
  3044. +    req->sem = NULL;
  3045. +    req->bh = bh;
  3046. +    req->bhtail = bh;
  3047. +    req->next = NULL;
  3048. +    add_request(major+blk_dev,req);
  3049. +}
  3050. +
  3051. +void ll_rw_page(int rw, kdev_t dev, unsigned long page, char * buffer)
  3052. +{
  3053. +    struct request * req;
  3054. +    unsigned int major = MAJOR(dev);
  3055. +    unsigned long sector = page * (PAGE_SIZE / 512);
  3056. +    struct semaphore sem = MUTEX_LOCKED;
  3057. +
  3058. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  3059. +        printk("Trying to read nonexistent block-device %s (%ld)\n",
  3060. +               kdevname(dev), sector);
  3061. +        return;
  3062. +    }
  3063. +    if (rw!=READ && rw!=WRITE)
  3064. +        panic("Bad block dev command, must be R/W");
  3065. +    if (rw == WRITE && is_read_only(dev)) {
  3066. +        printk("Can't page to read-only device %s\n",
  3067. +               kdevname(dev));
  3068. +        return;
  3069. +    }
  3070. +    req = get_request_wait(NR_REQUEST, dev);
  3071. +/* fill up the request-info, and add it to the queue */
  3072. +    req->cmd = rw;
  3073. +    req->errors = 0;
  3074. +    req->sector = sector;
  3075. +    req->nr_sectors = PAGE_SIZE / 512;
  3076. +    req->current_nr_sectors = PAGE_SIZE / 512;
  3077. +    req->buffer = buffer;
  3078. +    req->sem = &sem;
  3079. +    req->bh = NULL;
  3080. +    req->next = NULL;
  3081. +    add_request(major+blk_dev,req);
  3082. +    down(&sem);
  3083. +}
  3084. +
  3085. +/* This function can be used to request a number of buffers from a block
  3086. +   device. Currently the only restriction is that all buffers must belong to
  3087. +   the same device */
  3088. +
  3089. +void ll_rw_block(int rw, int nr, struct buffer_head * bh[])
  3090. +{
  3091. +    unsigned int major;
  3092. +    struct request plug;
  3093. +    int correct_size;
  3094. +    struct blk_dev_struct * dev;
  3095. +    int i;
  3096. +
  3097. +    /* Make sure that the first block contains something reasonable */
  3098. +    while (!*bh) {
  3099. +        bh++;
  3100. +        if (--nr <= 0)
  3101. +            return;
  3102. +    };
  3103. +
  3104. +    dev = NULL;
  3105. +    if ((major = MAJOR(bh[0]->b_dev)) < MAX_BLKDEV)
  3106. +        dev = blk_dev + major;
  3107. +    if (!dev || !dev->request_fn) {
  3108. +        printk(
  3109. +    "ll_rw_block: Trying to read nonexistent block-device %s (%ld)\n",
  3110. +        kdevname(bh[0]->b_dev), bh[0]->b_blocknr);
  3111. +        goto sorry;
  3112. +    }
  3113. +
  3114. +    /* Determine correct block size for this device.  */
  3115. +    correct_size = BLOCK_SIZE;
  3116. +    if (blksize_size[major]) {
  3117. +        i = blksize_size[major][MINOR(bh[0]->b_dev)];
  3118. +        if (i)
  3119. +            correct_size = i;
  3120. +    }
  3121. +
  3122. +    /* Verify requested block sizes.  */
  3123. +    for (i = 0; i < nr; i++) {
  3124. +        if (bh[i] && bh[i]->b_size != correct_size) {
  3125. +            printk(
  3126. +            "ll_rw_block: only %d-char blocks implemented (%lu)\n",
  3127. +                   correct_size, bh[i]->b_size);
  3128. +            goto sorry;
  3129. +        }
  3130. +    }
  3131. +
  3132. +    if ((rw == WRITE || rw == WRITEA) && is_read_only(bh[0]->b_dev)) {
  3133. +        printk("Can't write to read-only device %s\n",
  3134. +               kdevname(bh[0]->b_dev));
  3135. +        goto sorry;
  3136. +    }
  3137. +
  3138. +    /* If there are no pending requests for this device, then we insert
  3139. +       a dummy request for that device.  This will prevent the request
  3140. +       from starting until we have shoved all of the blocks into the
  3141. +       queue, and then we let it rip.  */
  3142. +
  3143. +    if (nr > 1)
  3144. +        plug_device(dev, &plug);
  3145. +    for (i = 0; i < nr; i++) {
  3146. +        if (bh[i]) {
  3147. +            bh[i]->b_req = 1;
  3148. +            make_request(major, rw, bh[i]);
  3149. +            if (rw == READ || rw == READA)
  3150. +                kstat.pgpgin++;
  3151. +            else
  3152. +                kstat.pgpgout++;
  3153. +        }
  3154. +    }
  3155. +    unplug_device(dev);
  3156. +    return;
  3157. +
  3158. +      sorry:
  3159. +    for (i = 0; i < nr; i++) {
  3160. +        if (bh[i])
  3161. +            bh[i]->b_dirt = bh[i]->b_uptodate = 0;
  3162. +    }
  3163. +    return;
  3164. +}
  3165. +
  3166. +void ll_rw_swap_file(int rw, kdev_t dev, unsigned int *b, int nb, char *buf)
  3167. +{
  3168. +    int i, j;
  3169. +    int buffersize;
  3170. +    struct request * req[8];
  3171. +    unsigned int major = MAJOR(dev);
  3172. +    struct semaphore sem = MUTEX_LOCKED;
  3173. +
  3174. +    if (major >= MAX_BLKDEV || !(blk_dev[major].request_fn)) {
  3175. +        printk("ll_rw_swap_file: trying to swap nonexistent block-device\n");
  3176. +        return;
  3177. +    }
  3178. +
  3179. +    if (rw != READ && rw != WRITE) {
  3180. +        printk("ll_rw_swap: bad block dev command, must be R/W");
  3181. +        return;
  3182. +    }
  3183. +    if (rw == WRITE && is_read_only(dev)) {
  3184. +        printk("Can't swap to read-only device %s\n",
  3185. +               kdevname(dev));
  3186. +        return;
  3187. +    }
  3188. +    
  3189. +    buffersize = PAGE_SIZE / nb;
  3190. +
  3191. +    for (j=0, i=0; i<nb;)
  3192. +    {
  3193. +        for (; j < 8 && i < nb; j++, i++, buf += buffersize)
  3194. +        {
  3195. +            if (j == 0) {
  3196. +                req[j] = get_request_wait(NR_REQUEST, dev);
  3197. +            } else {
  3198. +                cli();
  3199. +                req[j] = get_request(NR_REQUEST, dev);
  3200. +                sti();
  3201. +                if (req[j] == NULL)
  3202. +                    break;
  3203. +            }
  3204. +            req[j]->cmd = rw;
  3205. +            req[j]->errors = 0;
  3206. +            req[j]->sector = (b[i] * buffersize) >> 9;
  3207. +            req[j]->nr_sectors = buffersize >> 9;
  3208. +            req[j]->current_nr_sectors = buffersize >> 9;
  3209. +            req[j]->buffer = buf;
  3210. +            req[j]->sem = &sem;
  3211. +            req[j]->bh = NULL;
  3212. +            req[j]->next = NULL;
  3213. +            add_request(major+blk_dev,req[j]);
  3214. +        }
  3215. +        while (j > 0) {
  3216. +            j--;
  3217. +            down(&sem);
  3218. +        }
  3219. +    }
  3220. +}
  3221. +
  3222. +int blk_dev_init(void)
  3223. +{
  3224. +    struct request * req;
  3225. +
  3226. +    req = all_requests + NR_REQUEST;
  3227. +    while (--req >= all_requests) {
  3228. +        req->rq_status = RQ_INACTIVE;
  3229. +        req->next = NULL;
  3230. +    }
  3231. +    memset(ro_bits,0,sizeof(ro_bits));
  3232. +#ifdef CONFIG_BLK_DEV_IDE
  3233. +    ide_init();        /* this MUST preceed hd_init */
  3234. +#endif
  3235. +#ifdef CONFIG_BLK_DEV_HD
  3236. +    hd_init();
  3237. +#endif
  3238. +#ifdef CONFIG_BLK_DEV_XD
  3239. +    xd_init();
  3240. +#endif
  3241. +#ifdef CONFIG_BLK_DEV_FD
  3242. +#ifdef CONFIG_ARCH_ARC
  3243. +    fd1772_init();
  3244. +#else
  3245. +    floppy_init();
  3246. +#endif
  3247. +#else
  3248. +#ifndef CONFIG_ARCH_ARC
  3249. +    outb_p(0xc, 0x3f2);
  3250. +#endif
  3251. +#endif
  3252. +#ifdef CONFIG_CDU31A
  3253. +    cdu31a_init();
  3254. +#endif CONFIG_CDU31A
  3255. +#ifdef CONFIG_MCD
  3256. +    mcd_init();
  3257. +#endif CONFIG_MCD
  3258. +#ifdef CONFIG_MCDX
  3259. +    mcdx_init();
  3260. +#endif CONFIG_MCDX
  3261. +#ifdef CONFIG_SBPCD
  3262. +    sbpcd_init();
  3263. +#endif CONFIG_SBPCD
  3264. +#ifdef CONFIG_AZTCD
  3265. +        aztcd_init();
  3266. +#endif CONFIG_AZTCD
  3267. +#ifdef CONFIG_CDU535
  3268. +    sony535_init();
  3269. +#endif CONFIG_CDU535
  3270. +#ifdef CONFIG_GSCD
  3271. +    gscd_init();
  3272. +#endif CONFIG_GSCD
  3273. +#ifdef CONFIG_CM206
  3274. +    cm206_init();
  3275. +#endif
  3276. +#ifdef CONFIG_OPTCD
  3277. +    optcd_init();
  3278. +#endif CONFIG_OPTCD
  3279. +#ifdef CONFIG_SJCD
  3280. +    sjcd_init();
  3281. +#endif CONFIG_SJCD
  3282. +    return 0;
  3283. +}
  3284. diff -urN linux.store/linux/arch/arm/drivers/block/mfmhd.c linux/arch/arm/drivers/block/mfmhd.c
  3285. --- linux.store/linux/arch/arm/drivers/block/mfmhd.c    Sun Mar  3 12:30:30 1996
  3286. +++ linux/arch/arm/drivers/block/mfmhd.c    Mon Mar 11 23:11:51 1996
  3287. @@ -1,11 +1,33 @@
  3288.  /*
  3289.   * linux/arch/arm/drivers/block/mfmhd.c
  3290.   *
  3291. - * Copyright (C) 1995, 1996 Russell King
  3292. + * Copyright (C) 1995, 1996 Russell King, Dave Alan Gilbert (gilbertd@cs.man.ac.uk)
  3293.   *
  3294.   * MFM hard drive code [experimental]
  3295.   */
  3296.  
  3297. +/*
  3298. + * Change list:
  3299. + *
  3300. + *  3/2/96:DAG: Started a change list :-)
  3301. + *              Set the hardsect_size pointers up since we are running 256 byte
  3302. + *                sectors
  3303. + *              Added DMA code, put it into the rw_intr
  3304. + *              Moved RCAL out of generic interrupt code - don't want to do it
  3305. + *                while DMA'ing - its now in individual handlers.
  3306. + *              Took interrupt handlers off task queue lists and called
  3307. + *                directly - not sure of implications.
  3308. + *
  3309. + *  18/2/96:DAG: Well its reading OK I think, well enough for image file code
  3310. + *              to find the image file; but now I've discovered that I actually
  3311. + *              have to put some code in for image files.
  3312. + *
  3313. + *              Added stuff for image files; seems to work, but I've not
  3314. + *              got a multisegment image file (I don't think!).
  3315. + *              Put in a hack (yep a real hack) for multiple cylinder reads.
  3316. + *              Not convinced its working.
  3317. + */
  3318. +
  3319.  #ifdef MODULE
  3320.  #include <linux/module.h>
  3321.  #include <linux/version.h>
  3322. @@ -19,18 +41,34 @@
  3323.  #include <linux/tqueue.h>
  3324.  #include <linux/mm.h>
  3325.  
  3326. -#include <linux/xd.h>
  3327.  #include <linux/errno.h>
  3328.  #include <linux/genhd.h>
  3329.  #include <linux/major.h>
  3330. +#include <linux/xd.h>
  3331.  
  3332.  #include <asm/system.h>
  3333.  #include <asm/io.h>
  3334. +#include <asm/irq-no.h>
  3335.  #include <asm/segment.h>
  3336. +#include <asm/delay.h>
  3337.  #include <asm/dma.h>
  3338.  
  3339.  #include <asm/ecard.h>
  3340.  
  3341. +#define MAX_FRAGS          16
  3342. +static unsigned long frag_start[MAX_FRAGS];        /* start of fragments */
  3343. +static unsigned long frag_len[MAX_FRAGS];          /* Fragment length */
  3344. +static int frag_count;                             /* Number of fragments to go */
  3345. +static int frag_pos;                               /* Position in fragment arrays */
  3346. +static unsigned int frag_sectors;
  3347. +
  3348. +static unsigned int PartFragRead;   /* The number of sectors which have been read
  3349. +                                       during a partial read split over two
  3350. +                                       cylinders.  If 0 it means a partial
  3351. +                                       read did not occur. */
  3352. +
  3353. +static unsigned int PartFragRead_RestartBlock; /* Where to restart on a split access */
  3354. +static unsigned int PartFragRead_SectorsLeft; /* Where to restart on a split access */
  3355.  #define MFM_DISK_MAJOR    13
  3356.  #undef  XT_DISK_MAJOR
  3357.  #define XT_DISK_MAJOR    -1
  3358. @@ -39,14 +77,14 @@
  3359.  
  3360.  XD_INFO mfm_info[XD_MAXDRIVES];
  3361.  
  3362. -#define DEBUG
  3363. +/*#define DEBUG */
  3364.  
  3365.  #define MFM_COMMAND (mfm_addr + 0)
  3366.  #define MFM_DATAOUT (mfm_addr + 1)
  3367.  #define MFM_STATUS  (mfm_addr + 8)
  3368.  #define MFM_DATAIN  (mfm_addr + 9)
  3369.  
  3370. -static void mfm_geninit (void);
  3371. +static void mfm_geninit (struct gendisk *dev);
  3372.  static int  mfm_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg);
  3373.  static int  mfm_open (struct inode *inode,struct file *file);
  3374.  static void mfm_release (struct inode *inode, struct file *file);
  3375. @@ -56,8 +94,10 @@
  3376.  static void mfm_request (void);
  3377.  static int  mfm_reread_partitions (int dev);
  3378.  static void mfm_request (void);
  3379. +static void mfm_specify (void);
  3380.  
  3381.  #define mfm_init xd_init
  3382. +#define mfm_setup xd_setup
  3383.  
  3384.  static struct hd_struct mfm[XD_MAXDRIVES << 6];
  3385.  static int mfm_sizes[XD_MAXDRIVES << 6], mfm_access[XD_MAXDRIVES] = { 0, 0 };
  3386. @@ -67,6 +107,8 @@
  3387.  
  3388.  static int mfm_irq;        /* Interrupt number */
  3389.  static int mfm_addr;        /* Controller address */
  3390. +static unsigned char *mfm_IRQPollLoc;  /* Address to read for IRQ information */
  3391. +static char mfm_IRQMask;    /* AND with *mfm_IRQPollLoc to find if there is an interrupt */
  3392.  static int mfm_drives = 0;    /* drives available */
  3393.  static int mfm_status = 0;    /* interrupt status */
  3394.  static char mfm_busy = 0;    /* mfm busy */
  3395. @@ -132,7 +174,16 @@
  3396.  #define NEED_1_RECAL -2
  3397.  #define NEED_2_RECAL -3
  3398.  
  3399. +int mfm_sectsizes[256]; /* We have to do this because we don't have 512 byte sectors */
  3400.  
  3401. +/* Stuff from the assembly routines */
  3402. +extern unsigned int hdc63463_baseaddress;    /* Controller base address */
  3403. +extern unsigned int hdc63463_irqpolladdress; /* Address to read to test for int */
  3404. +extern unsigned int hdc63463_irqpollmask;    /* Mask for irq register */
  3405. +extern unsigned int hdc63463_dataptr;        /* Pointer to kernel data space to DMA */
  3406. +extern int hdc63463_dataleft;                /* Number of bytes left to transfer */
  3407. +
  3408. +extern unsigned char *ioc;
  3409.  /* ------------------------------------------------------------------------------------------ */
  3410.  /*
  3411.   * From the HD63463 data sheet from Hitachi Ltd.
  3412. @@ -204,43 +255,105 @@
  3413.  static int mfm_prods[] = { 0x000b };
  3414.  static int mfm_manus[] = { 0x0000 };
  3415.  
  3416. -unsigned long mfm_init (unsigned long mem_start, unsigned long mem_end)
  3417. +int mfm_init (void)
  3418.  {
  3419. +  unsigned int i;
  3420. +/* DAG */
  3421. +#ifdef CONFIG_MFM_ONMAINBOARD
  3422. +  mfm_irq = IRQ_HARDDISK;
  3423. +  mfm_addr=(0x3250000>>2); /* Motherboard HDC address  - thats probably slow - what should it be? */
  3424. +  mfm_IRQPollLoc=ioc+0x20;
  3425. +  mfm_IRQMask=0x08; /* IL3 pin */
  3426. +#else
  3427.      ecs = ecard_find(0, sizeof(mfm_prods), mfm_prods, mfm_manus);
  3428.      if(!ecs)
  3429. -        return mem_start;
  3430. +        return -1;
  3431.  
  3432.      mfm_irq = ecs->irq;
  3433.      mfm_addr= ((((int)ecs->r_podaddr) & 0x03eff000) + 0x2000)>>2;
  3434.  
  3435. +  /* DAG: Temporary until I examine a podule a bit */
  3436. +  printk("mfm_init: Sorry podule based MFM cards aren't supported - need IRQ poll loc and mask\n");
  3437. +  return -1;
  3438. +
  3439. +
  3440.      ecard_claim(ecs);
  3441. +#endif
  3442.  
  3443. -    printk("mfm: controller found at address %X, interrupt %d\n", mfm_addr, mfm_irq);
  3444. +  /* Stuff for the assembler routines to get to */
  3445. +  hdc63463_baseaddress=(unsigned int)(mfm_addr<<2);
  3446. +  hdc63463_irqpolladdress=(int)mfm_IRQPollLoc;
  3447. +  hdc63463_irqpollmask=mfm_IRQMask;
  3448. +
  3449. +    printk("mfm: controller found at address %X, interrupt %d\n", mfm_addr<<2, mfm_irq);
  3450.  
  3451.      if(register_blkdev(MAJOR_NR, "mfm", &mfm_fops)) {
  3452.          printk("mfm_init: unable to get major number %d\n", MAJOR_NR);
  3453. -        return mem_start;
  3454. +        return -1;
  3455.      }
  3456.      blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
  3457. -    read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB) read ahread */
  3458. +    read_ahead[MAJOR_NR] = 8; /* 8 sector (4kB?) read ahread */
  3459. +
  3460. +  /* This stops MSDOS trying to mount it - but ll_rw_blk has tons of >>9
  3461. +     presuming 512 byte sectors - its upto us to fix it! */
  3462. +  hardsect_size[MAJOR_NR]=mfm_sectsizes;
  3463. +  for(i=0;i<256;i++)
  3464. +    mfm_sectsizes[i]=256;
  3465. +
  3466.  #ifndef MODULE
  3467.      mfm_gendisk.next = gendisk_head;
  3468.      gendisk_head = & mfm_gendisk;
  3469.  #endif
  3470.  
  3471. -    return mem_start;
  3472. +    return 0;
  3473.  }
  3474.  
  3475. +/* DAG: Gets called by the genhd code to set up the number of sectors etc. */
  3476. +void xt_set_geometry(int dev,unsigned char secsptrack,unsigned char heads,
  3477. +                   unsigned long discsize, unsigned int secsize)
  3478. +{
  3479. +  dev=MINOR(dev);
  3480. +  /* The HD version checks to see if the number of cylinders are unset */
  3481. +  /* and then causes them to be set... */
  3482. +  /* Need to set up the precomp etc. */
  3483. +  if (mfm_info[dev>>6].cylinders==1)
  3484. +  {
  3485. +    mfm_info[dev>>6].sectors=secsptrack;
  3486. +    mfm_info[dev>>6].heads=heads;
  3487. +    mfm_info[dev>>6].cylinders=discsize/(secsptrack*heads*secsize);
  3488. +
  3489. +    mfm_drive_param[dev>>6].nosectors=secsptrack;
  3490. +    mfm_drive_param[dev>>6].noheads=heads;
  3491. +    mfm_drive_param[dev>>6].nocylinders=discsize/(secsptrack*heads*secsize);
  3492. +
  3493. +    printk("mfm%c: %d cylinders, %d heads, %d sectors secsize=%d (%ld total)\n",'a'+(dev>>6),
  3494. +        mfm_info[dev>>6].cylinders, heads, secsptrack, secsize, discsize);
  3495. +    /* Should probably do a specify command here....*/
  3496. +    printk("mfm: at end of set_hdinfo: About to do a specify\n");
  3497. +    if ((heads<1) || (mfm_drive_param[dev>>6].nocylinders>1024)) {
  3498. +      /* Shouldn't be a panic - but easiest for initial debug */
  3499. +      panic("xt_set_hdinfo: Invalid heads/cylinders count\n"); 
  3500. +    };
  3501. +    mfm_specify();
  3502. +    printk("mfm: set_hdinfo after the specify\n");
  3503. +  };
  3504. +
  3505. +  mfm[dev].start_sect=0;
  3506. +  mfm[dev].nr_sects=(discsize/secsize)/2; /* This is 512 byte sectors - I want 256 but where does this get set for image files? */
  3507. +  printk("mfm set_hdinfo: mfm[%d].nr_sects=%ld\n",dev,mfm[dev].nr_sects);
  3508. +
  3509. +}
  3510. +    
  3511.  static int mfm_initdrives (void)
  3512.  {
  3513.      mfm_info[0].heads = 4;
  3514. -    mfm_info[0].cylinders = 615;
  3515. +    mfm_info[0].cylinders = 1; /* its going to have to figure it out from the drive */
  3516.      mfm_info[0].sectors = 32;
  3517.      mfm_info[0].control = 0;
  3518.      return 1;
  3519.  }
  3520.  
  3521. -static void mfm_geninit (void)
  3522. +static void mfm_geninit (struct gendisk *dev)
  3523.  {
  3524.      int i;
  3525.  
  3526. @@ -250,11 +363,14 @@
  3527.          printk("mfm%d: heads = %d, cylinders = %d, sectors = %d\n", i,
  3528.               mfm_info[i].heads, mfm_info[i].cylinders, mfm_info[i].sectors);
  3529.  
  3530. +  /*printk("mfm: Before irq register\n");*/
  3531.      if(request_irq(mfm_irq, mfm_interrupt_handler, SA_INTERRUPT, "MFM harddisk"))
  3532.          printk("mfm: unable to get IRQ%d\n", mfm_irq);
  3533.  
  3534. -    outw(0x80, mfm_addr + (0x1000 >> 2));
  3535. +  /*printk("mfm: Before wierd write\n"); */
  3536. +    /*outw(0x80, mfm_addr + (0x1000 >> 2)); *//* Pardon? DAG */
  3537.  
  3538. +  /*printk("mfm: Before data init\n");*/
  3539.      for(i = 0; i < mfm_drives; i++) {
  3540.          mfm[i << 6].nr_sects = mfm_info[i].heads * mfm_info[i].cylinders *
  3541.                  mfm_info[i].sectors;
  3542. @@ -263,16 +379,18 @@
  3543.      }
  3544.      mfm_gendisk.nr_real = mfm_drives;
  3545.  
  3546. +  /*printk("mfm: Before init blocksizes\n");*/
  3547.      for(i=0; i<(XD_MAXDRIVES << 6); i++)
  3548.          mfm_blocksizes[i] = 1024;
  3549.      blksize_size[MAJOR_NR] = mfm_blocksizes;
  3550. +  /*printk("mfm: End of init\n");*/
  3551.  }
  3552.  
  3553.  static int mfm_open (struct inode *inode,struct file *file)
  3554.  {
  3555.      int dev = DEVICE_NR(MINOR(inode->i_rdev));
  3556.  
  3557. -    if (dev < mfm_drives) {
  3558. +    if ((dev) < mfm_drives) {
  3559.          while (!mfm_valid[dev])
  3560.              sleep_on(&mfm_wait_open);
  3561.  
  3562. @@ -443,19 +561,27 @@
  3563.      do {
  3564.          status = inw(MFM_STATUS);
  3565.      } while(status & (STAT_BSY|STAT_POL));
  3566. -    if(status & STAT_CPR)
  3567. +  /*printk("issue_command: status after pol/bsy loop: %02X:\n ",status>>8); */
  3568. +    if(status & (STAT_CPR|STAT_CED|STAT_SED|STAT_DER|STAT_ABN))
  3569.      {
  3570.          outw(CMD_RCAL, MFM_COMMAND);
  3571.          while(inw(MFM_STATUS) & STAT_BSY);
  3572.      }
  3573.  
  3574. +    status = inw(MFM_STATUS);
  3575. +  /*printk("issue_command: status before parameter issue: %02X:\n ",status>>8);*/
  3576.      while(len > 0)
  3577.      {
  3578.          outw(cmdb[1] | (cmdb[0] << 8), MFM_DATAOUT);
  3579.          len -= 2;
  3580.          cmdb += 2;
  3581.      }
  3582. +    status = inw(MFM_STATUS);
  3583. +  /*printk("issue_command: status before command issue: %02X:\n ",status>>8);*/
  3584.      outw(command, MFM_COMMAND);
  3585. +    status = inw(MFM_STATUS);
  3586. +  /*printk("issue_command: status immediatly after command issue: %02X:\n ",status>>8);*/
  3587. +  udelay(20);
  3588.  }
  3589.  
  3590.  static void wait_for_completion (void)
  3591. @@ -467,17 +593,83 @@
  3592.  
  3593.  static void mfm_rw_intr (void)
  3594.  {
  3595. -    printk("mfm_rw_intr...\n");
  3596. -    if (cont)
  3597. -    {
  3598. -        cont->done(1);
  3599. -    }
  3600. -    mfm_request();
  3601. +#ifdef DEBUG
  3602. +    printk("mfm_rw_intr...dataleft=%d\n",hdc63463_dataleft);
  3603. +  print_status();
  3604. +#endif
  3605. +
  3606. +  if (mfm_status & (STAT_DER | STAT_ABN)) {
  3607. +    /* Something has gone wrong - lets try that again */
  3608. +    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  3609. +    if (cont) {
  3610. +      cont->error();
  3611. +      cont->redo();
  3612. +    };
  3613. +    return;
  3614. +  };
  3615. +
  3616. +  /* OK so what ever happend its not an error, now I reckon we are left between
  3617. +     a choice of command end or some data which is ready to be collected */
  3618. +  /* I think we have to transfer data while the interrupt line is on and its
  3619. +     not any other type of interrupt */
  3620. +  if (CURRENT->cmd==WRITE) {
  3621. +    extern void hdc63463_writedma(void);
  3622. +    if ((hdc63463_dataleft<=0) && (!(mfm_status & STAT_CED))) {
  3623. +      printk("mfm_rw_intr: Apparent DMA write request when no more to DMA\n");
  3624. +      if (cont) {
  3625. +        cont->error();
  3626. +        cont->redo();
  3627. +      };
  3628. +      return;
  3629. +    };
  3630. +    hdc63463_writedma();
  3631. +  } else {
  3632. +    extern void hdc63463_readdma(void);
  3633. +    if ((hdc63463_dataleft<=0) && (!(mfm_status & STAT_CED))) {
  3634. +      printk("mfm_rw_intr: Apparent DMA read request when no more to DMA\n");
  3635. +      if (cont) {
  3636. +        cont->error();
  3637. +        cont->redo();
  3638. +      };
  3639. +      return;
  3640. +    };
  3641. +    /*printk("Going to try read dma..............status=0x%x\n",mfm_status); */
  3642. +    hdc63463_readdma();
  3643. +  }; /* Read */
  3644. +
  3645. +    mfm_status = inw(MFM_STATUS);
  3646. +  if (mfm_status & (STAT_DER | STAT_ABN)) {
  3647. +    /* Something has gone wrong - lets try that again */
  3648. +    if (cont) {
  3649. +      cont->error();
  3650. +      cont->redo();
  3651. +    };
  3652. +    return;
  3653. +  };
  3654. +
  3655. +  /* If end of command move on */
  3656. +  if (mfm_status & (STAT_CED)) {
  3657. +    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  3658. +    /* End of command - trigger the next command */
  3659. +    if (cont)
  3660. +    {
  3661. +      cont->done(1);
  3662. +    }
  3663. +    /*mfm_request(); - DAG - took out because we might not have finished the whole command */
  3664. +#ifdef DEBUG
  3665. +    printk("mfm_rw_intr: returned from cont->done\n");
  3666. +#endif
  3667. +  } else {
  3668. +    /* Its going to generate another interrupt */
  3669. +    SET_INTR(mfm_rw_intr);
  3670. +  };
  3671.  }
  3672.  
  3673.  static void mfm_setup_rw (void)
  3674.  {
  3675. +#ifdef DEBUG
  3676.      printk("setting up for rw...\n");
  3677. +#endif
  3678.  #if 1
  3679.      SET_INTR(mfm_rw_intr);
  3680.      issue_command(raw_cmd.cmdcode, raw_cmd.cmddata, raw_cmd.cmdlen);
  3681. @@ -492,8 +684,11 @@
  3682.  
  3683.  static void mfm_recal_intr (void)
  3684.  {
  3685. +#ifdef DEBUG
  3686.      printk("recal intr - status = ");
  3687.      print_status();
  3688. +#endif
  3689. +  outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  3690.      if(mfm_status & (STAT_DER|STAT_ABN)) {
  3691.          printk("recal failed\n");
  3692.          MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  3693. @@ -504,12 +699,15 @@
  3694.          }
  3695.          return;
  3696.      }
  3697. +  /* Thats seek end - we are finished */
  3698.      if(mfm_status & STAT_SED) {
  3699.          issue_command(CMD_POD, NULL, 0);
  3700.          MFM_DRV_PARAM.cylinder = 0;
  3701.          mfm_seek();
  3702.          return;
  3703.      }
  3704. +  /* Command end without seek end (see data sheet p.20) for parallel seek
  3705. +     - we have to send a POL command to wait for the seek */
  3706.      if(mfm_status & STAT_CED) {
  3707.          SET_INTR(mfm_recal_intr);
  3708.          issue_command(CMD_POL, NULL, 0);
  3709. @@ -520,8 +718,11 @@
  3710.  
  3711.  static void mfm_seek_intr (void)
  3712.  {
  3713. +#ifdef DEBUG
  3714.      printk("seek intr - status = ");
  3715. -    print_status();
  3716. +    print_status();  
  3717. +#endif
  3718. +  outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  3719.      if(mfm_status & (STAT_DER|STAT_ABN)) {
  3720.          printk("seek failed\n");
  3721.          MFM_DRV_PARAM.cylinder = NEED_2_RECAL;
  3722. @@ -548,23 +749,35 @@
  3723.  
  3724.  static void mfm_specify (void)
  3725.  {
  3726. +  /* IDEA2 seems to work better - its what RiscOS sets my
  3727. +  disc to - on its SECOND call to specify! */
  3728. +#define IDEA2
  3729.      unsigned char cmdb[16];
  3730.      printk("specify...\n");
  3731. -    cmdb[0] = 0x1F;
  3732. -    cmdb[1] = 0xC3;
  3733. -    cmdb[2] = 0x16;
  3734. -    cmdb[3] = 0x02;
  3735. -    cmdb[4] = 0xFC | ((MFM_DRV_PARAM.nocylinders - 1) >> 8);
  3736. -    cmdb[5] = MFM_DRV_PARAM.nocylinders - 1;
  3737. -    cmdb[6] = MFM_DRV_PARAM.noheads - 1;
  3738. -    cmdb[7] = MFM_DRV_PARAM.nosectors - 1;
  3739. -    cmdb[8] = 0xA9;
  3740. -    cmdb[9] = 0x0A;
  3741. -    cmdb[10]= 0x0D;
  3742. -    cmdb[11]= 0x0C;
  3743. -    cmdb[12]= (MFM_DRV_PARAM.precompcylinder - 1) >> 8;
  3744. +    cmdb[0] = 0x1F; /* OM0 - !SECT,!MOD,!DIF,PADP,ECD,CRCP,CRCI,ACOR */
  3745. +    cmdb[1] = 0xC3; /* OM1 - DTM,BRST,!CEDM,!SEDM,!DERM,0,AMEX,PSK */
  3746. +#ifndef IDEA2
  3747. +    cmdb[2] = 0x16; /* OM2 - SL - step pulse low */
  3748. +#else
  3749. +    cmdb[2] = 0; /* OM2 - SL - step pulse low */
  3750. +#endif
  3751. +    cmdb[3] = 0x02; /* Connected unit list */
  3752. +    cmdb[4] = 0xFC | ((MFM_DRV_PARAM.nocylinders - 1) >> 8); /* RW time over/high part of number of cylinders */
  3753. +    cmdb[5] = MFM_DRV_PARAM.nocylinders - 1; /* low part of number of cylinders */
  3754. +    cmdb[6] = MFM_DRV_PARAM.noheads - 1; /* Number of heads */
  3755. +    cmdb[7] = MFM_DRV_PARAM.nosectors - 1; /* Number of sectors */
  3756. +#ifndef IDEA2
  3757. +    cmdb[8] = 0xA9; /* Step pulse high=21, Record Length=001 (256 bytes) */
  3758. +#else
  3759. +    cmdb[8] = 0x21; /* Step pulse high=4, Record Length=001 (256 bytes) */
  3760. +#endif
  3761. +    cmdb[9] = 0x0A; /* gap length 1 */
  3762. +    cmdb[10]= 0x0D; /* gap length 2 */
  3763. +    cmdb[11]= 0x0C; /* gap length 3 */
  3764. +  /* DAG: Note my data sheet shows precomp and low current the other way around */
  3765. +    cmdb[12]= (MFM_DRV_PARAM.precompcylinder - 1) >> 8; /* pre comp cylinder */
  3766.      cmdb[13]= MFM_DRV_PARAM.precompcylinder - 1;
  3767. -    cmdb[14]= (MFM_DRV_PARAM.lowcurrentcylinder - 1) >> 8;
  3768. +    cmdb[14]= (MFM_DRV_PARAM.lowcurrentcylinder - 1) >> 8; /* Low current cylinder */
  3769.      cmdb[15]= MFM_DRV_PARAM.lowcurrentcylinder - 1;
  3770.  
  3771.      issue_command(CMD_SPC, cmdb, 16);
  3772. @@ -574,20 +787,24 @@
  3773.  static void mfm_seek (void)
  3774.  {
  3775.      unsigned char cmdb[4];
  3776. +#ifdef DEBUG
  3777.      printk("seeking...\n");
  3778. +#endif
  3779.      if(MFM_DRV_PARAM.cylinder < 0) {
  3780.          cmdb[0] = raw_cmd.dev + 1;
  3781.          cmdb[1] = raw_cmd.head;
  3782.  
  3783.          SET_INTR(mfm_recal_intr);
  3784. +    printk("mfm_seek: about to call specify\n");
  3785. +    mfm_specify(); /* DAG added this */
  3786.          issue_command(CMD_RCLB, cmdb, 2);
  3787.          return;
  3788.      }
  3789. -    mfm_specify();
  3790. +    /*mfm_specify();*//* DAG took this out */
  3791.      if(MFM_DRV_PARAM.cylinder != raw_cmd.cylinder)
  3792.      {
  3793.          cmdb[0] = raw_cmd.dev + 1;
  3794. -        cmdb[1] = raw_cmd.head;
  3795. +        cmdb[1] = 0; /* raw_cmd.head; DAG: My data sheet says this should be 0 */
  3796.          cmdb[2] = raw_cmd.cylinder >> 8;
  3797.          cmdb[3] = raw_cmd.cylinder;
  3798.  
  3799. @@ -600,7 +817,9 @@
  3800.  
  3801.  static void mfm_initialise (void)
  3802.  {
  3803. +#ifdef DEBUG
  3804.      printk("init...\n");
  3805. +#endif
  3806.      if(raw_cmd.flags & NEED_SEEK)
  3807.          mfm_seek();
  3808.      else
  3809. @@ -616,7 +835,84 @@
  3810.          return;
  3811.      }
  3812.      if(uptodate) {
  3813. -        end_request (1);
  3814. +    /* Apparently worked - lets check bytes left to DMA */
  3815. +    if (hdc63463_dataleft!=(PartFragRead_SectorsLeft*256)) {
  3816. +      printk("mfm: request_done - dataleft=%d - should be %d\n",hdc63463_dataleft,PartFragRead_SectorsLeft*256);
  3817. +      end_request (0);
  3818. +    } else {
  3819. +      /* Potentially this means that we've done; but we might be doing
  3820. +         a partial access, (over two cylinders) or we may have a number
  3821. +         of fragments in an image file.  First lets deal with partial accesss
  3822. +      */
  3823. +      if (PartFragRead) {
  3824. +        /* Yep - a partial access */
  3825. +        CURRENT->buffer+=PartFragRead*256; /* Increment pointer to write */
  3826. +
  3827. +        /* and issue the remainder */
  3828. +        issue_request(MINOR(CURRENT->rq_dev),PartFragRead_RestartBlock,PartFragRead_SectorsLeft,CURRENT);
  3829. +        return;
  3830. +      };
  3831. +
  3832. +      /* ah well - perhaps there is another fragment to go */
  3833. +
  3834. +      /* Increment pointers/counts to start of next fragment */
  3835. +      CURRENT->nr_sectors-=frag_len[frag_pos];
  3836. +      CURRENT->sector+=frag_len[frag_pos];
  3837. +      CURRENT->buffer+=frag_len[frag_pos]*512;
  3838. +
  3839. +      if (CURRENT->nr_sectors>0) {
  3840. +        unsigned int dev,block,nsect;
  3841. +        dev=MINOR(CURRENT->rq_dev);
  3842. +
  3843. +        printk("mfm: Now about to issue fragment %d\n",frag_pos+1);
  3844. +        /* OK - time to issue another fragment */
  3845. +        /* Increment the place where we are going to store the data */
  3846. +        /* Move onto the next fragment */
  3847. +        frag_pos++;
  3848. +
  3849. +        /* But there is a possibility that we are actually going to have to
  3850. +           ask for some more fragments */
  3851. +        if (frag_pos>=MAX_FRAGS)
  3852. +        {
  3853. +          printk("mfm: Getting another block of fragments\n");
  3854. +          block=CURRENT->sector*2;
  3855. +          block+=mfm[dev].start_sect;
  3856. +          nsect=CURRENT->nr_sectors*2;
  3857. +          if (!image_file_check(CURRENT->rq_dev,CURRENT->cmd))
  3858. +          {
  3859. +            end_request(0);
  3860. +            /* Should I initiate another request here? */
  3861. +            return;
  3862. +          }
  3863. +          frag_count=image_file_map(CURRENT->rq_dev,block/2,nsect/2,MAX_FRAGS,frag_start,frag_len);
  3864. +          if (!frag_count)
  3865. +          {
  3866. +            end_request(0);
  3867. +            /* Should I initiate another request here? */
  3868. +            return;
  3869. +          };
  3870. +          frag_pos++;
  3871. +        }; /* More fragments ? */
  3872. +
  3873. +        block=frag_start[frag_pos]*2;
  3874. +        frag_sectors=nsect=frag_len[frag_pos]*2;
  3875. +
  3876. +        /* and issue it */
  3877. +        issue_request(dev,block,nsect,CURRENT);
  3878. +      } else {
  3879. +        /* No - its the end of the line */
  3880. +        end_request (1);
  3881. +
  3882. +#ifdef DEBUG
  3883. +        printk("request_done: About to mfm_request\n");
  3884. +#endif
  3885. +        /* Next one please */
  3886. +        mfm_request(); /* Moved from mfm_rw_intr */
  3887. +#ifdef DEBUG
  3888. +        printk("request_done: returned from mfm_request\n");
  3889. +#endif
  3890. +      }; 
  3891. +    };
  3892.      }
  3893.      else {
  3894.          end_request (0);
  3895. @@ -628,6 +924,7 @@
  3896.      int i;
  3897.      printk("error detected... status = ");
  3898.      print_status();
  3899. +  /*panic("mfm error");*/ /* DAG tmp */
  3900.      (*errors) ++;
  3901.      if(*errors > MFM_DRV_PARAM.errors.abort)
  3902.          cont->done(0);
  3903. @@ -637,6 +934,7 @@
  3904.  
  3905.  static void rw_interrupt(void)
  3906.  {
  3907. +  printk("rw_interrupt\n");
  3908.  }
  3909.  
  3910.  static struct cont rw_cont ={
  3911. @@ -646,62 +944,64 @@
  3912.      request_done
  3913.  };
  3914.  
  3915. -static void mfm_request (void)
  3916. +/*
  3917. + * Actually gets round to issuing the request - note everything at this
  3918. + * point is in 256 byte sectors not Linux 512 byte blocks
  3919. + */
  3920. +static void issue_request (int dev, unsigned int block, unsigned int nsect,
  3921. +                           struct request *current)
  3922.  {
  3923. -    unsigned int dev, block, nsect, track;
  3924. +    int track,start_head,start_sector;
  3925. +    int sectors_to_next_cyl;
  3926.  
  3927. -    if(CURRENT && CURRENT->dev < 0)
  3928. -        return;
  3929. +        dev >>= 6;
  3930.  
  3931. -    while(1){
  3932. -        sti();
  3933. +        track = block / mfm_info[dev].sectors;
  3934. +    start_sector=block % mfm_info[dev].sectors;
  3935. +    start_head=track % mfm_info[dev].heads;
  3936.  
  3937. -        INIT_REQUEST;
  3938. -        dev = MINOR(CURRENT->dev);
  3939. -        block = CURRENT->sector;
  3940. -        nsect = CURRENT->nr_sectors;
  3941. +    /* First get the number of whole tracks which are free before the next
  3942. +    track */
  3943. +    sectors_to_next_cyl=(mfm_info[dev].heads-(start_head+1))*mfm_info[dev].sectors;
  3944. +    /* Then add in the number of sectors left on this track */
  3945. +    sectors_to_next_cyl+=(mfm_info[dev].sectors-start_sector);
  3946.  
  3947. -        if(dev >= (mfm_drives << 6) ||
  3948. -            block >= mfm[dev].nr_sects || ((block+nsect) > mfm[dev].nr_sects)) {
  3949.  #ifdef DEBUG
  3950. -            if(dev >= (mfm_drives << 6))
  3951. -                printk("mfm: bad minor number: device=0x%04x\n", CURRENT->dev);
  3952. -            else
  3953. -                printk("mfm%c: bad access: block=%d, count=%d\n", (dev>>6)+'a',
  3954. -                    block, nsect);
  3955. +    printk("issue_request: mfm_info[dev].sectors=%d track=%d\n",mfm_info[dev].sectors,track);
  3956.  #endif
  3957. -            end_request(0);
  3958. -            continue;
  3959. -        }
  3960. -        block += mfm[dev].start_sect;
  3961. -
  3962. -        if(CURRENT->cmd != READ && CURRENT->cmd != WRITE)
  3963. -        {
  3964. -            printk("unknown mfm-command %d\n", CURRENT->cmd);
  3965. -            end_request(0);
  3966. -            continue;
  3967. -        }
  3968.  
  3969. -        dev >>= 6;
  3970. -
  3971. -        track = block / mfm_info[dev].sectors;
  3972.          raw_cmd.flags        = NEED_SEEK;
  3973.          raw_cmd.dev        = dev;
  3974. -        raw_cmd.sector        = block % mfm_info[dev].sectors;
  3975. -        raw_cmd.head        = track % mfm_info[dev].heads;
  3976. +        raw_cmd.sector        = start_sector;
  3977. +        raw_cmd.head        = start_head;
  3978.          raw_cmd.cylinder    = track / mfm_info[dev].heads;
  3979.          raw_cmd.cmdtype     = CURRENT->cmd;
  3980.          raw_cmd.cmdcode     = CURRENT->cmd == WRITE ? CMD_WD : CMD_RD;
  3981. -        raw_cmd.cmddata[0]    = dev;
  3982. +        raw_cmd.cmddata[0]    = dev+1; /* DAG: +1 to get US */
  3983.          raw_cmd.cmddata[1]    = raw_cmd.head;
  3984.          raw_cmd.cmddata[2]    = raw_cmd.cylinder >> 8;
  3985.          raw_cmd.cmddata[3]    = raw_cmd.cylinder;
  3986.          raw_cmd.cmddata[4]    = raw_cmd.head;
  3987.          raw_cmd.cmddata[5]    = raw_cmd.sector;
  3988. -        raw_cmd.cmddata[6]    = nsect >> 8;
  3989. -        raw_cmd.cmddata[7]    = nsect;
  3990. +    if (nsect<=sectors_to_next_cyl) {
  3991. +      raw_cmd.cmddata[6]    = nsect >> 8;
  3992. +      raw_cmd.cmddata[7]    = nsect;
  3993. +      PartFragRead=0; /* All in one */
  3994. +      PartFragRead_SectorsLeft=0; /* Must set this - used in DMA calcs */
  3995. +    } else {
  3996. +      raw_cmd.cmddata[6]    = sectors_to_next_cyl >> 8;
  3997. +      raw_cmd.cmddata[7]    = sectors_to_next_cyl;
  3998. +      PartFragRead=sectors_to_next_cyl; /* only do this many this time */
  3999. +      PartFragRead_RestartBlock=block+sectors_to_next_cyl; /* Where to restart from */
  4000. +      PartFragRead_SectorsLeft=nsect-sectors_to_next_cyl;
  4001. +    };
  4002.          raw_cmd.cmdlen        = 8;
  4003.  
  4004. +    /* Setup DMA pointers */
  4005. +    hdc63463_dataptr=CURRENT->buffer;
  4006. +    hdc63463_dataleft=nsect*256; /* Better way? */
  4007. +
  4008. +
  4009.  #ifdef DEBUG
  4010.          printk("mfm%c: %sing: CHS=%d/%d/%d, sectors=%d, buffer=0x%08lx (%p)\n",
  4011.              raw_cmd.dev+'a', (CURRENT->cmd == READ)?"read":"writ",
  4012. @@ -713,12 +1013,113 @@
  4013.          errors = &(CURRENT->errors);
  4014.          mfm_tq.routine = (void (*)(void *))mfm_initialise;
  4015.          queue_task(&mfm_tq, &tq_timer);
  4016. +}; /* issue_request */
  4017. +
  4018. +static void mfm_request (void)
  4019. +{
  4020. +    unsigned int dev, block, nsect;
  4021. +
  4022. +#ifdef DEBUG
  4023. +  printk("mfm_request CURRENT=%p\n",CURRENT);
  4024. +#endif
  4025. +    if(CURRENT && CURRENT->rq_dev < 0) {
  4026. +    printk("mfm_request: exit due to (CURRENT && CURRENT->rq_dev < 0)\n");
  4027. +        return;
  4028. +  };
  4029. +
  4030. +    while(1){
  4031. +#ifdef DEBUG
  4032. +    printk("mfm_request: loop start\n");
  4033. +#endif
  4034. +    /* DAG: I wonder if there wshould be a store flags here? */
  4035. +        sti();
  4036. +
  4037. +#ifdef DEBUG
  4038. +    printk("mfm_request: before INIT_REQUEST\n");
  4039. +#endif
  4040. +        INIT_REQUEST;
  4041. +#ifdef DEBUG
  4042. +    printk("mfm_request: before arg extraction\n");
  4043. +#endif
  4044. +        dev = MINOR(CURRENT->rq_dev);
  4045. +        block = CURRENT->sector;
  4046. +        nsect = CURRENT->nr_sectors;
  4047. +
  4048. +#ifdef DEBUG
  4049. +    printk("mfm_request: raw vals: dev=%d block=%d nsect=%d\n",dev,block,nsect);
  4050. +#endif
  4051. +
  4052. +    /* DAG: Linux doesn't cope with this - even though it has an array telling
  4053. +       it the hardware block size - silly */
  4054. +    block *= 2; /* Now in 256 byte sectors */
  4055. +    nsect *= 2; /* Ditto */
  4056. +
  4057. +        if(dev >= (mfm_drives << 6) ||
  4058. +            block >= (mfm[dev].nr_sects*2) || ((block+nsect) > (mfm[dev].nr_sects*2))) {
  4059. +      printk("mfm: oops dev=0x%04x mfm_drives=%d block=%d mfm[dev].nr_sects=%d nsect=%d\n",
  4060. +             dev,mfm_drives,block,mfm[dev].nr_sects,nsect);
  4061. +            if(dev >= (mfm_drives << 6))
  4062. +                printk("mfm: bad minor number: device=0x%04x\n", CURRENT->rq_dev);
  4063. +            else
  4064. +                printk("mfm%c: bad access: block=%d, count=%d\n", (dev>>6)+'a',
  4065. +                    block, nsect);
  4066. +            end_request(0);
  4067. +            continue;
  4068. +        }
  4069. +        block += mfm[dev].start_sect;
  4070. +
  4071. +    if (dev & 0x3f)
  4072. +    {
  4073. +      /* map sectors block to block+nsect to frags.
  4074. +       */
  4075. +      if (!image_file_check(CURRENT->rq_dev,CURRENT->cmd)) continue;
  4076. +      frag_count = image_file_map(CURRENT->rq_dev,block/2,nsect/2,MAX_FRAGS,frag_start,frag_len);
  4077. +      if(!frag_count)
  4078. +      {
  4079. +        continue;
  4080. +      }
  4081. +      block=frag_start[0]*2;
  4082. +      frag_sectors=nsect=frag_len[0]*2;
  4083. +      frag_pos=0;
  4084. +    } else {
  4085. +      /* OK - its not an image file - lets just push it through */
  4086. +      frag_pos=0;
  4087. +      frag_count=1;
  4088. +      frag_sectors=nsect;
  4089. +      frag_len[frag_pos]=frag_sectors/2;
  4090. +      if (CURRENT->cmd==WRITE)
  4091. +      {
  4092. +         /* Stop writing to the raw drive */
  4093. +         printk("mfm%d: attempted write on protected drive\n",dev);
  4094. +         end_request(0);
  4095. +         continue;
  4096. +      };
  4097. +    }; /* image file/normal if */
  4098. +#ifdef DEBUG
  4099. +    printk("mfm_request: block after offset=%d\n",block);
  4100. +#endif
  4101. +
  4102. +        if(CURRENT->cmd != READ && CURRENT->cmd != WRITE)
  4103. +        {
  4104. +            printk("unknown mfm-command %d\n", CURRENT->cmd);
  4105. +            end_request(0);
  4106. +            continue;
  4107. +        }
  4108. +
  4109. +    issue_request(dev,block,nsect,CURRENT);
  4110. +
  4111.          break;
  4112.      }
  4113. +#ifdef DEBUG
  4114. +  printk("mfm_request: Dropping out bottom\n");
  4115. +#endif
  4116.  }
  4117.  
  4118.  static void do_mfm_request (void)
  4119.  {
  4120. +#ifdef DEBUG
  4121. +  printk("do_mfm_request: about to mfm_request\n");
  4122. +#endif
  4123.      mfm_request();
  4124.  }
  4125.  
  4126. @@ -726,6 +1127,7 @@
  4127.  {
  4128.      printk("mfm: unexpected interrupt - status = ");
  4129.      print_status();
  4130. +  while(1);
  4131.  }
  4132.  
  4133.  static void mfm_interrupt_handler (int unused, struct pt_regs *regs)
  4134. @@ -733,9 +1135,14 @@
  4135.      int i;
  4136.      void (*handler)(void) = DEVICE_INTR;
  4137.  
  4138. +#ifdef DEBUG
  4139. +  printk("mfm_interrupt_handler (handler=0x%p)\n",handler);
  4140. +#endif
  4141.      CLEAR_INTR;
  4142.      mfm_status = inw(MFM_STATUS);
  4143.  
  4144. +  /* If CPR (Command Parameter Reject) and not busy it means that the command
  4145. +     has some return message to give us */
  4146.      if((mfm_status & (STAT_CPR|STAT_BSY)) == STAT_CPR)
  4147.      {
  4148.          int len = 0;
  4149. @@ -748,14 +1155,22 @@
  4150.          }
  4151.      }
  4152.  
  4153. -    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  4154.  
  4155.      if(!handler) {
  4156. +    outw(CMD_RCAL, MFM_COMMAND);    /* Clear interrupt condition */
  4157.          mfm_unexpected_interrupt();
  4158.          return;
  4159.      }
  4160. -    mfm_tq.routine = (void (*)(void *))handler;
  4161. -    queue_task_irq(&mfm_tq, &tq_timer);
  4162. +    /*mfm_tq.routine = (void (*)(void *))handler;
  4163. +    queue_task_irq(&mfm_tq, &tq_timer); */
  4164. +  handler();
  4165. +}
  4166. +
  4167. +/* DAG: Called presumably to accept command line parameters */
  4168. +/* Ignore for the moment! */
  4169. +void mfm_setup(char *str, int *ints)
  4170. +{
  4171. +  return;
  4172.  }
  4173.  
  4174.  #ifdef MODULE
  4175. diff -urN linux.store/linux/arch/arm/drivers/char/Makefile linux/arch/arm/drivers/char/Makefile
  4176. --- linux.store/linux/arch/arm/drivers/char/Makefile    Sat Feb 24 14:18:57 1996
  4177. +++ linux/arch/arm/drivers/char/Makefile    Wed Mar 13 14:31:04 1996
  4178. @@ -19,12 +19,25 @@
  4179.  
  4180.  L_TARGET := char.a
  4181.  M_OBJS   :=
  4182. -L_OBJS   := tty_io.o n_tty.o console.o keyboard.o serial.o \
  4183. -    tty_ioctl.o pty.o vt.o mem.o vc_screen.o random.o \
  4184. -    defkeymap.o consolemap.o iic.o
  4185. +L_OBJS   := tty_io.o n_tty.o console.o keyboard.o tty_ioctl.o \
  4186. +        pty.o vt.o mem.o vc_screen.o random.o defkeymap.o \
  4187. +        consolemap.o iic.o
  4188.  
  4189. -# vesa_blank.o selection.o
  4190. +# Architecture dependencies
  4191.  
  4192. +ifeq ($(MACHINE),a5k)
  4193. +  SERIAL = serial.o
  4194. +else
  4195. +ifeq ($(MACHINE),arc)
  4196. +endif
  4197. +  SERIAL = serial6850.o
  4198. +endif
  4199. +
  4200. +# Common dependencies
  4201. +
  4202. +ifdef SERIAL
  4203. +  L_OBJS += $(SERIAL)
  4204. +endif
  4205.  
  4206.  ifeq ($(CONFIG_PRINTER),y)
  4207.    L_OBJS += lp.o
  4208. Binary files linux.store/linux/arch/arm/drivers/char/conmakehash and linux/arch/arm/drivers/char/conmakehash differ
  4209. diff -urN linux.store/linux/arch/arm/drivers/char/console.c linux/arch/arm/drivers/char/console.c
  4210. --- linux.store/linux/arch/arm/drivers/char/console.c    Sun Mar  3 12:31:06 1996
  4211. +++ linux/arch/arm/drivers/char/console.c    Mon Mar 11 22:31:14 1996
  4212. @@ -70,8 +70,7 @@
  4213.  /* ARM Extensions */
  4214.  extern void memc_write (int reg, int val);
  4215.  extern void vidc_write (int reg, int val);
  4216. -extern void ll_char_write(unsigned long ps, int ch, unsigned char forec,
  4217. -             unsigned char backc, unsigned char flgs);
  4218. +extern void ll_write_char(unsigned long ps, unsigned long chinfo);
  4219.  extern void memfastset (void *ptr, unsigned long word, int length);
  4220.  extern void prints (const char *, ...);
  4221.  extern void map_screen_mem (unsigned long vid_base, int remap);
  4222. @@ -445,12 +444,12 @@
  4223.  
  4224.    flgs=FLAGS;
  4225.  
  4226. -  if(currcons == fg_console)
  4227. -    ll_char_write(ps, ch, forecol, backcol, flgs);
  4228. -
  4229.    index = (x + y * video_num_columns);
  4230.  
  4231.    buffer[index] = (flgs<<24)|(backcol<<16)|(forecol<<8)|ch;
  4232. +
  4233. +  if (currcons == fg_console)
  4234. +    ll_write_char(ps, buffer[index]);
  4235.  }
  4236.  
  4237.  static char cursor_on=0;
  4238. @@ -460,8 +459,7 @@
  4239.  {
  4240.    unsigned long flags;
  4241.  
  4242. -  save_flags(flags);
  4243. -  cli();
  4244. +  save_flags_cli (flags);
  4245.    if(--cursoron==0 && currcons == fg_console)
  4246.      put_cursor(0, cp);
  4247.    restore_flags(flags);
  4248. @@ -471,8 +469,7 @@
  4249.  {
  4250.    unsigned long flags;
  4251.  
  4252. -  save_flags(flags);
  4253. -  cli();
  4254. +  save_flags_cli (flags);
  4255.    if(++cursoron==1 && cursor_on && currcons == fg_console)
  4256.      put_cursor(1,cp);
  4257.    restore_flags(flags);
  4258. @@ -604,7 +601,7 @@
  4259.  {
  4260.    unsigned long flags;
  4261.    clear_selection();
  4262. -  save_flags(flags); cli();
  4263. +  save_flags_cli (flags);
  4264.    __origin = offset;
  4265.  
  4266.    memc_write(0,offset>>2);
  4267. @@ -647,8 +644,7 @@
  4268.  
  4269.      if(__real_origin != __origin)
  4270.          __set_origin(__real_origin);
  4271. -    save_flags(flags);
  4272. -    cli();
  4273. +    save_flags_cli (flags);
  4274.  
  4275.      if(deccm)
  4276.          cp = pos + video_num_columns * bytes_per_char_h * (bytes_per_char_v - 1);
  4277. @@ -1962,21 +1958,18 @@
  4278.      console_driver.throttle = con_throttle;
  4279.      console_driver.unthrottle = con_unthrottle;
  4280.  
  4281. -    if(tty_register_driver(&console_driver))
  4282. +    if (tty_register_driver(&console_driver))
  4283.            panic("Couldn't register console driver\n");
  4284.  
  4285.      con_setsize(ORIG_VIDEO_LINES,ORIG_VIDEO_COLS);
  4286.  
  4287.      timer_table[BLANK_TIMER].fn=blank_screen;
  4288.      timer_table[BLANK_TIMER].expires=0;
  4289. -    if(blankinterval) {
  4290. +    if (blankinterval) {
  4291.            timer_table[BLANK_TIMER].expires=jiffies+blankinterval;
  4292.          timer_active|=1<<BLANK_TIMER;
  4293.      }
  4294.  
  4295. -    for(i=0; i<17; i++)
  4296. -        vidc_write(i<<2, default_palette_entries[i]);
  4297. -
  4298.      /* Use ORIG_VIDEO_MODE */
  4299.      video_addr_mask= (video_num_lines * video_num_columns * bytes_per_char_h *
  4300.                   bytes_per_char_v - 1) | (PAGE_SIZE-1);
  4301. @@ -1986,13 +1979,15 @@
  4302.      map_screen_mem (video_mem_base, 1);
  4303.  
  4304.      can_do_color=1;
  4305. -    if(bytes_per_char_h == 8)
  4306. -    {
  4307. +    if (bytes_per_char_h == 8) {
  4308.          default_palette_entries = palette_8;
  4309.          color_table = color_8;
  4310.      }
  4311.  
  4312. -    for(currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
  4313. +    for (i = 0; i < 17; i++)
  4314. +        vidc_write (i << 2, default_palette_entries[i]);
  4315. +
  4316. +    for (currcons = 0; currcons < MIN_NR_CONSOLES; currcons++) {
  4317.          vc_cons[currcons].d = (struct vc_data *) kmem_start;
  4318.          kmem_start += sizeof(struct vc_data);
  4319.          vt_cons[currcons] = (struct vt_struct *) kmem_start;
  4320. @@ -2024,7 +2019,7 @@
  4321.            (MIN_NR_CONSOLES == 1) ? "":"s",
  4322.            MAX_NR_CONSOLES);
  4323.      register_console (console_print);
  4324. -    if(request_irq (IRQ_VSYNCPULSE, vsync_irq, 0, "console"))
  4325. +    if (request_irq (IRQ_VSYNCPULSE, vsync_irq, 0, "console"))
  4326.          panic ("Unable to get VSYNC irq for console\n");
  4327.      return kmem_start;
  4328.  }
  4329. @@ -2057,8 +2052,7 @@
  4330.              pp = p + sx * bytes_per_char_h;
  4331.              for (; sx < video_num_columns; sx++)
  4332.              {
  4333. -                ll_char_write (pp, buffer[0] & 0xff, (buffer[0] >> 8) & 0xff,
  4334. -                    (buffer[0] >> 16) & 0xff, (buffer[0] >> 24) & 0xff);
  4335. +                ll_write_char (pp, *buffer);
  4336.                  pp += bytes_per_char_h;
  4337.                  buffer ++;
  4338.              }
  4339. @@ -2070,8 +2064,7 @@
  4340.      {
  4341.          for (; sx < ex; sx++)
  4342.          {
  4343. -            ll_char_write (p, buffer[0] & 0xff, (buffer[0] >> 8) & 0xff,
  4344. -                (buffer[0] >> 16) & 0xff, (buffer[0] >> 24) & 0xff);
  4345. +            ll_write_char (p, *buffer);
  4346.              p += bytes_per_char_h;
  4347.              buffer ++;
  4348.          }
  4349. @@ -2080,37 +2073,35 @@
  4350.  
  4351.  void set_scrmem(int currcons,long offset)
  4352.  {
  4353. -    unsigned long p,pp,mx,my;
  4354. +    unsigned long p, pp, my, by;
  4355.      unsigned long *buffer;
  4356.      int i;
  4357.  
  4358.      p = origin;
  4359.      buffer = (unsigned long *)vc_scrbuf[currcons];
  4360.  
  4361. -    for(my = 0; my < video_num_lines ; my++)
  4362. -    {
  4363. +    by = video_size_row;
  4364. +    for (my = video_num_lines; my > 0; my--) {
  4365. +        int mx, bx = bytes_per_char_h;
  4366.          pp = p;
  4367. -        for(mx = 0; mx < video_num_columns; mx++)
  4368. -        {
  4369. -            ll_char_write(pp,buffer[0] & 0xff,(buffer[0] >> 8) & 0xff,
  4370. -                     (buffer[0] >> 16) & 0xff,(buffer[0] >> 24) & 0xff);
  4371. -            pp+=bytes_per_char_h;
  4372. -            buffer+=1;
  4373. +        for (mx = video_num_columns; mx > 0; mx--) {
  4374. +            ll_write_char (pp, *buffer);
  4375. +            pp += bx;
  4376. +            buffer += 1;
  4377.          }
  4378. -        p+=video_size_row;
  4379. +        p += by;
  4380.      }
  4381.      pp = origin + ((video_screen_size + 0x7FFF) & PAGE_MASK);
  4382. -    while(p<pp)
  4383. -    {
  4384. -        *(unsigned long *)p=0;
  4385. -        p+=4;
  4386. -    }
  4387. -    if(!paletteentries || vcmode != KD_GRAPHICS)
  4388. -        for(i=0; i<17; i++)
  4389. -            vidc_write(i<<2, default_palette_entries[i]);
  4390. +    while (p < pp) {
  4391. +        *(unsigned long *)p = 0;
  4392. +        p += 4;
  4393. +    }
  4394. +    if (!paletteentries || vcmode != KD_GRAPHICS)
  4395. +        for (i = 0; i < 17; i++)
  4396. +            vidc_write(i << 2, default_palette_entries[i]);
  4397.      else
  4398. -        for(i=0; i<17; i++)
  4399. -            vidc_write(i<<2, paletteentries[i] & 0x1fff);
  4400. +        for (i = 0; i < 17; i++)
  4401. +            vidc_write(i << 2, paletteentries[i] & 0x1fff);
  4402.  }
  4403.  
  4404.  /* ------------------------------------------------------------------------------------- *
  4405. @@ -2408,9 +2399,9 @@
  4406.              pp = p + (hx * bytes_per_char_h);
  4407.              for(mx = hx; mx < ((my == hey)?hex+1:video_num_columns); mx++)
  4408.              {
  4409. -                ll_char_write(pp,buffer[0],buffer[1],buffer[2],buffer[3]);
  4410. -                pp+=bytes_per_char_h;
  4411. -                buffer+=4;
  4412. +                ll_write_char (pp, *(unsigned long *)buffer);
  4413. +                pp += bytes_per_char_h;
  4414. +                buffer += 4;
  4415.                  hx = 0;
  4416.              }
  4417.              p+=video_size_row;
  4418. diff -urN linux.store/linux/arch/arm/drivers/char/kbdmouse.c linux/arch/arm/drivers/char/kbdmouse.c
  4419. --- linux.store/linux/arch/arm/drivers/char/kbdmouse.c    Sun Mar  3 12:39:09 1996
  4420. +++ linux/arch/arm/drivers/char/kbdmouse.c    Mon Mar 11 22:32:06 1996
  4421. @@ -67,8 +67,7 @@
  4422.      if (mouse_active++)
  4423.      return 0;
  4424.  
  4425. -    save_flags (flags);
  4426. -    cli ();
  4427. +    save_flags_cli (flags);
  4428.      mouse_active  = 1;
  4429.      mouse_ready   = 0;
  4430.      mouse_dxpos   = 0;
  4431. @@ -98,8 +97,7 @@
  4432.      if (!mouse_ready)
  4433.      return -EAGAIN;
  4434.  
  4435. -    save_flags (flags);
  4436. -    cli ();
  4437. +    save_flags_cli (flags);
  4438.  
  4439.      dxpos = mouse_dxpos;
  4440.      dypos = mouse_dypos;
  4441. @@ -162,8 +160,7 @@
  4442.  {
  4443.      unsigned long flags;
  4444.  
  4445. -    save_flags (flags);
  4446. -    cli ();
  4447. +    save_flags_cli (flags);
  4448.  
  4449.      mouse_buttons=0;
  4450.      mouse_dxpos  =0;
  4451. diff -urN linux.store/linux/arch/arm/drivers/char/keyboard.c linux/arch/arm/drivers/char/keyboard.c
  4452. --- linux.store/linux/arch/arm/drivers/char/keyboard.c    Sun Mar  3 12:39:34 1996
  4453. +++ linux/arch/arm/drivers/char/keyboard.c    Mon Mar 11 22:32:27 1996
  4454. @@ -1219,17 +1219,18 @@
  4455.      tty = ttytab[fg_console];
  4456.      kbd = kbd_table + fg_console;
  4457.  
  4458. -    if (rep && kbd_repeatkey != -1) {
  4459. -        /*
  4460. -         * This prevents the kbd_key routine from being called
  4461. -         * twice, once by this BH, and once by the interrupt
  4462. -         * routine.  Maybe we should put the key press in a
  4463. -         * buffer or variable, and then call the BH...
  4464. -         */
  4465. +    if (rep) {
  4466. +    /*
  4467. +     * This prevents the kbd_key routine from being called
  4468. +     * twice, once by this BH, and once by the interrupt
  4469. +     * routine.  Maybe we should put the key press in a
  4470. +     * buffer or variable, and then call the BH...
  4471. +     */
  4472.          disable_irq (IRQ_KEYBOARDRX);
  4473. -    kbd_key (kbd_repeatkey, kbd_repeatrate);
  4474. +    if (kbd_repeatkey != -1)
  4475. +        kbd_key (kbd_repeatkey, kbd_repeatrate);
  4476.      enable_irq (IRQ_KEYBOARDRX);
  4477. -        rep = 0;
  4478. +    rep = 0;
  4479.      }
  4480.  
  4481.      if(want_console >= 0) {
  4482. @@ -1250,8 +1251,7 @@
  4483.      leds = ((leds & (1<<VC_SCROLLOCK))?4:0) | ((leds & (1<<VC_NUMLOCK))?2:0) |
  4484.             ((leds & (1<<VC_CAPSLOCK))?1:0);
  4485.  
  4486. -    save_flags(flags);
  4487. -    cli();
  4488. +    save_flags_cli (flags);
  4489.      intr_count -= 1;
  4490.  
  4491.      kbd_sendval(leds);
  4492. @@ -1283,8 +1283,7 @@
  4493.  
  4494.      bh_base[KEYBOARD_BH].routine = kbd_bh;
  4495.  
  4496. -    save_flags (flags);
  4497. -    cli ();
  4498. +    save_flags_cli (flags);
  4499.      if (request_irq (IRQ_KEYBOARDRX, kbd_rx, 0, "keyboard")!=0)
  4500.      panic("Could not allocate keyboard receive IRQ!");
  4501.      if (request_irq (IRQ_KEYBOARDTX, kbd_tx, 0, "Keyboard")!=0)
  4502. diff -urN linux.store/linux/arch/arm/drivers/char/serial.c linux/arch/arm/drivers/char/serial.c
  4503. --- linux.store/linux/arch/arm/drivers/char/serial.c    Sun Mar  3 12:47:09 1996
  4504. +++ linux/arch/arm/drivers/char/serial.c    Mon Mar 11 22:34:23 1996
  4505. @@ -242,7 +242,7 @@
  4506.      if (serial_paranoia_check(info, tty->device, "rs_stop"))
  4507.          return;
  4508.      
  4509. -    save_flags(flags); cli();
  4510. +    save_flags_cli (flags);
  4511.      if (info->IER & UART_IER_THRI) {
  4512.          info->IER &= ~UART_IER_THRI;
  4513.          serial_out(info, UART_IER, info->IER);
  4514. @@ -258,7 +258,7 @@
  4515.      if (serial_paranoia_check(info, tty->device, "rs_start"))
  4516.          return;
  4517.      
  4518. -    save_flags(flags); cli();
  4519. +    save_flags_cli (flags);
  4520.      if (info->xmit_cnt && info->xmit_buf && !(info->IER & UART_IER_THRI)) {
  4521.          info->IER |= UART_IER_THRI;
  4522.          serial_out(info, UART_IER, info->IER);
  4523. @@ -344,7 +344,6 @@
  4524.      ignore_char:
  4525.          *status = serial_inp(info, UART_LSR) & info->read_status_mask;
  4526.      } while (*status & UART_LSR_DR);
  4527. -{ unsigned long flags; save_flags (flags); if (!(flags & 0x08000000)) printk ("SERIAL IRQ ON!\n"); }
  4528.      queue_task_irq_off(&tty->flip.tqueue, &tq_timer);
  4529.  #ifdef SERIAL_DEBUG_INTR
  4530.      printk("DR...");
  4531. @@ -831,7 +830,7 @@
  4532.              return -ENOMEM;
  4533.      }
  4534.  
  4535. -    save_flags(flags); cli();
  4536. +    save_flags_cli (flags);
  4537.  
  4538.  #ifdef SERIAL_DEBUG_OPEN
  4539.      printk("starting up ttys%d (irq %d)...", info->line, info->irq);
  4540. @@ -989,7 +988,7 @@
  4541.             info->irq);
  4542.  #endif
  4543.      
  4544. -    save_flags(flags); cli(); /* Disable interrupts */
  4545. +    save_flags_cli (flags); /* Disable interrupts */
  4546.      
  4547.      /*
  4548.       * First unlink the serial port from the IRQ chain...
  4549. @@ -1204,7 +1203,7 @@
  4550.      if (!tty || !info->xmit_buf)
  4551.          return;
  4552.  
  4553. -    save_flags(flags); cli();
  4554. +    save_flags_cli (flags);
  4555.      if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  4556.          restore_flags(flags);
  4557.          return;
  4558. @@ -1228,7 +1227,7 @@
  4559.          !info->xmit_buf)
  4560.          return;
  4561.  
  4562. -    save_flags(flags); cli();
  4563. +    save_flags_cli (flags);
  4564.      info->IER |= UART_IER_THRI;
  4565.      serial_out(info, UART_IER, info->IER);
  4566.      restore_flags(flags);
  4567. @@ -1247,7 +1246,7 @@
  4568.      if (!tty || !info->xmit_buf || !tmp_buf)
  4569.          return 0;
  4570.          
  4571. -    save_flags(flags);
  4572. +    save_flags_cli (flags);
  4573.      while (1) {
  4574.          cli();        
  4575.          c = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
  4576. @@ -1945,7 +1944,7 @@
  4577.      if (!info || serial_paranoia_check(info, tty->device, "rs_close"))
  4578.          return;
  4579.      
  4580. -    save_flags(flags); cli();
  4581. +    save_flags_cli (flags);
  4582.      
  4583.      if (tty_hung_up_p(filp)) {
  4584.          restore_flags(flags);
  4585. @@ -2400,7 +2399,7 @@
  4586.      if (!port)
  4587.          return;
  4588.  
  4589. -    save_flags(flags); cli();
  4590. +    save_flags_cli (flags);
  4591.      
  4592.      /*
  4593.       * Do a simple existence test first; if we fail this, there's
  4594. @@ -2651,8 +2650,7 @@
  4595.      unsigned long flags;
  4596.      struct async_struct *info;
  4597.  
  4598. -    save_flags(flags);
  4599. -    cli();
  4600. +    save_flags_cli (flags);
  4601.      for (i = 0; i < NR_PORTS; i++) {
  4602.          if (rs_table[i].port == req->port)
  4603.              break;
  4604. @@ -2705,8 +2703,7 @@
  4605.      unsigned long flags;
  4606.      struct async_struct *info = &rs_table[line];
  4607.  
  4608. -    save_flags(flags);
  4609. -    cli();
  4610. +    save_flags_cli (flags);
  4611.      if (info->tty)
  4612.          tty_hangup(info->tty);
  4613.      info->type = PORT_UNKNOWN;
  4614. diff -urN linux.store/linux/arch/arm/drivers/char/serial6850.c linux/arch/arm/drivers/char/serial6850.c
  4615. --- linux.store/linux/arch/arm/drivers/char/serial6850.c    Thu Jan  1 01:00:00 1970
  4616. +++ linux/arch/arm/drivers/char/serial6850.c    Mon Mar 11 21:32:33 1996
  4617. @@ -0,0 +1,23 @@
  4618. +/*
  4619. + * Dummy serial functions
  4620. + *
  4621. + * Copyright (C) 1995, 1996 Russell King
  4622. + */
  4623. +
  4624. +#include <linux/errno.h>
  4625. +#include <linux/sched.h>
  4626. +#include <linux/serial.h>
  4627. +
  4628. +int rs_init (void)
  4629. +{
  4630. +    return 0;
  4631. +}
  4632. +
  4633. +int register_serial (struct serial_struct *dev)
  4634. +{
  4635. +    return -1;
  4636. +}
  4637. +
  4638. +void unregister_serial (int line)
  4639. +{
  4640. +}
  4641. diff -urN linux.store/linux/arch/arm/drivers/char/tty_io.c linux/arch/arm/drivers/char/tty_io.c
  4642. --- linux.store/linux/arch/arm/drivers/char/tty_io.c    Sun Mar  3 12:48:37 1996
  4643. +++ linux/arch/arm/drivers/char/tty_io.c    Mon Mar 11 23:57:46 1996
  4644. @@ -1252,8 +1252,7 @@
  4645.              return -ENOMEM;
  4646.          fa->magic = FASYNC_MAGIC;
  4647.          fa->fa_file = filp;
  4648. -        save_flags(flags);
  4649. -        cli();
  4650. +        save_flags_cli (flags);
  4651.          fa->fa_next = *fapp;
  4652.          *fapp = fa;
  4653.          restore_flags(flags);
  4654. @@ -1261,8 +1260,7 @@
  4655.      }
  4656.      if (!fa)
  4657.          return 0;
  4658. -    save_flags(flags);
  4659. -    cli();
  4660. +    save_flags_cli (flags);
  4661.      *fp = fa->fa_next;
  4662.      restore_flags(flags);
  4663.      kfree(fa);
  4664. diff -urN linux.store/linux/arch/arm/drivers/char/vc_screen.c linux/arch/arm/drivers/char/vc_screen.c
  4665. --- linux.store/linux/arch/arm/drivers/char/vc_screen.c    Sat Feb 24 18:12:00 1996
  4666. +++ linux/arch/arm/drivers/char/vc_screen.c    Sun Mar 10 15:26:14 1996
  4667. @@ -163,7 +163,7 @@
  4668.          org = screen_pos(cons, p);
  4669.          while (count-- > 0) {
  4670.              *org = (*org & 0xffffff00) | get_fs_byte(buf++);
  4671. -            ll_char_write (*org);
  4672. +/*            ll_write_char (,*org);*/
  4673.              org++;
  4674.          }
  4675.      } else {
  4676. diff -urN linux.store/linux/arch/arm/drivers/net/ether1.c linux/arch/arm/drivers/net/ether1.c
  4677. --- linux.store/linux/arch/arm/drivers/net/ether1.c    Sun Feb 18 09:28:09 1996
  4678. +++ linux/arch/arm/drivers/net/ether1.c    Mon Mar 11 22:34:57 1996
  4679. @@ -72,22 +72,41 @@
  4680.  static int ether1_manus[] = { 0x0000 };
  4681.  
  4682.  /* ------------------------------------------------------------------------- */
  4683. -#define ether1_inw(dev, addr, type, offset) ether1_inw_p (dev, addr + (int)(&((type *)0)->offset))
  4684. -#define ether1_outw(dev, val, addr, type, offset) ether1_outw_p (dev, val, addr + (int)(&((type *)0)->offset))
  4685. +
  4686. +#define DISABLEIRQS 1
  4687. +#define NORMALIRQS  0
  4688. +
  4689. +#define ether1_inw(dev, addr, type, offset, svflgs) ether1_inw_p (dev, addr + (int)(&((type *)0)->offset), svflgs)
  4690. +#define ether1_outw(dev, val, addr, type, offset, svflgs) ether1_outw_p (dev, val, addr + (int)(&((type *)0)->offset), svflgs)
  4691.  
  4692.  static inline unsigned short
  4693. -ether1_inw_p (struct device *dev, int addr)
  4694. +ether1_inw_p (struct device *dev, int addr, int svflgs)
  4695.  {
  4696. -    outb (addr >> 12, REG_PAGE);
  4697. +    unsigned long flags;
  4698. +    unsigned short ret;
  4699.  
  4700. -    return inw (ETHER1_RAM + ((addr & 4095) >> 1));
  4701. +    if (svflgs) {
  4702. +    save_flags_cli (flags);
  4703. +    }
  4704. +    outb (addr >> 12, REG_PAGE);
  4705. +    ret = inw (ETHER1_RAM + ((addr & 4095) >> 1));
  4706. +    if (svflgs)
  4707. +    restore_flags (flags);
  4708. +    return ret;
  4709.  }
  4710.  
  4711.  static inline void
  4712. -ether1_outw_p (struct device *dev, unsigned short val, int addr)
  4713. +ether1_outw_p (struct device *dev, unsigned short val, int addr, int svflgs)
  4714.  {
  4715. +    unsigned long flags;
  4716. +
  4717. +    if (svflgs) {
  4718. +    save_flags_cli (flags);
  4719. +    }
  4720.      outb (addr >> 12, REG_PAGE);
  4721.      outw (val, ETHER1_RAM + ((addr & 4095) >> 1));
  4722. +    if (svflgs)
  4723. +    restore_flags (flags);
  4724.  }
  4725.  
  4726.  static inline void *
  4727. @@ -423,7 +442,7 @@
  4728.  
  4729.      /* 586 should now unset iscp.busy */
  4730.      i = jiffies + HZ/2;
  4731. -    while (ether1_inw (dev, ISCP_ADDR, iscp_t, iscp_busy) == 1) {
  4732. +    while (ether1_inw (dev, ISCP_ADDR, iscp_t, iscp_busy, DISABLEIRQS) == 1) {
  4733.      if (jiffies > i) {
  4734.          printk ("%s: can't initialise 82586: iscp is busy\n", dev->name);
  4735.          return 1;
  4736. @@ -432,7 +451,8 @@
  4737.  
  4738.      /* check status of commands that we issued */
  4739.      i += HZ/10;
  4740. -    while (((status = ether1_inw (dev, CFG_ADDR, cfg_t, cfg_status)) & STAT_COMPLETE) == 0) {
  4741. +    while (((status = ether1_inw (dev, CFG_ADDR, cfg_t, cfg_status, DISABLEIRQS))
  4742. +        & STAT_COMPLETE) == 0) {
  4743.      if (jiffies > i)
  4744.          break;
  4745.      }
  4746. @@ -444,7 +464,8 @@
  4747.      }
  4748.  
  4749.      i += HZ/10;
  4750. -    while (((status = ether1_inw (dev, SA_ADDR, sa_t, sa_status)) & STAT_COMPLETE) == 0) {
  4751. +    while (((status = ether1_inw (dev, SA_ADDR, sa_t, sa_status, DISABLEIRQS))
  4752. +        & STAT_COMPLETE) == 0) {
  4753.      if (jiffies > i)
  4754.          break;
  4755.      }
  4756. @@ -456,7 +477,8 @@
  4757.      }
  4758.  
  4759.      i += HZ/10;
  4760. -    while (((status = ether1_inw (dev, MC_ADDR, mc_t, mc_status)) & STAT_COMPLETE) == 0) {
  4761. +    while (((status = ether1_inw (dev, MC_ADDR, mc_t, mc_status, DISABLEIRQS))
  4762. +        & STAT_COMPLETE) == 0) {
  4763.      if (jiffies > i)
  4764.          break;
  4765.      }
  4766. @@ -468,7 +490,8 @@
  4767.      }
  4768.  
  4769.      i += HZ;
  4770. -    while (((status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_status)) & STAT_COMPLETE) == 0) {
  4771. +    while (((status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_status, DISABLE_IRQS))
  4772. +        & STAT_COMPLETE) == 0) {
  4773.      if (jiffies > i)
  4774.          break;
  4775.      }
  4776. @@ -478,7 +501,7 @@
  4777.      return 0;
  4778.      }
  4779.  
  4780. -    status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_result);
  4781. +    status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_result, DISABLEIRQS);
  4782.      if (status & TDR_XCVRPROB)
  4783.      printk ("%s: i/f failed tdr: transceiver problem\n", dev->name);
  4784.      else
  4785. @@ -680,6 +703,7 @@
  4786.      else {
  4787.      int len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
  4788.      int tmp, tst, nopaddr, txaddr, tbdaddr, dataddr;
  4789. +    unsigned long flags;
  4790.      tx_t tx;
  4791.      tbd_t tbd;
  4792.      nop_t nop;
  4793. @@ -703,15 +727,17 @@
  4794.      nop.nop_command = CMD_NOP;
  4795.      nop.nop_link = nopaddr;
  4796.  
  4797. +    save_flags_cli (flags);
  4798.      ether1_writebuffer (dev, &tx, txaddr, TX_SIZE);
  4799.      ether1_writebuffer (dev, &tbd, tbdaddr, TBD_SIZE);
  4800.      ether1_writebuffer (dev, skb->data, dataddr, len);
  4801.      ether1_writebuffer (dev, &nop, nopaddr, NOP_SIZE);
  4802.      tmp = priv->tx_link;
  4803.      priv->tx_link = nopaddr;
  4804. +    restore_flags (flags);
  4805.  
  4806.      /* now reset the previous nop pointer */
  4807. -    ether1_outw (dev, txaddr, tmp, nop_t, nop_link);
  4808. +    ether1_outw (dev, txaddr, tmp, nop_t, nop_link, DISABLEIRQS);
  4809.  
  4810.      /* handle transmit */
  4811.      dev->trans_start = jiffies;
  4812. @@ -743,8 +769,10 @@
  4813.      switch (nop.nop_command & CMD_MASK) {
  4814.      case CMD_TDR:
  4815.      /* special case */
  4816. -    if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset) != (unsigned short)I82586_NULL) {
  4817. -        ether1_outw (dev, SCB_CMDCUCSTART | SCB_CMDRXSTART, SCB_ADDR, scb_t, scb_command);
  4818. +    if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS)
  4819. +                != (unsigned short)I82586_NULL) {
  4820. +        ether1_outw (dev, SCB_CMDCUCSTART | SCB_CMDRXSTART, SCB_ADDR, scb_t,
  4821. +        scb_command, NORMALIRQS);
  4822.          outb (CTRL_CA, REG_CONTROL);
  4823.      }
  4824.      priv->tx_tail = NOP_ADDR;
  4825. @@ -838,11 +866,11 @@
  4826.      rbd_t rbd;
  4827.  
  4828.      do {
  4829. -    status = ether1_inw (dev, priv->rx_head, rfd_t, rfd_status);
  4830. +    status = ether1_inw (dev, priv->rx_head, rfd_t, rfd_status, NORMALIRQS);
  4831.      if ((status & RFD_COMPLETE) == 0)
  4832.          break;
  4833.  
  4834. -    rbdaddr = ether1_inw (dev, priv->rx_head, rfd_t, rfd_rbdoffset);
  4835. +    rbdaddr = ether1_inw (dev, priv->rx_head, rfd_t, rfd_rbdoffset, NORMALIRQS);
  4836.      ether1_readbuffer (dev, &rbd, rbdaddr, RBD_SIZE);
  4837.  
  4838.      if ((rbd.rbd_status & (RBD_EOF | RBD_ACNTVALID)) == (RBD_EOF | RBD_ACNTVALID)) {
  4839. @@ -869,18 +897,18 @@
  4840.          priv->stats.rx_dropped ++;
  4841.      }
  4842.  
  4843. -    nexttail = ether1_inw (dev, priv->rx_tail, rfd_t, rfd_link);
  4844. +    nexttail = ether1_inw (dev, priv->rx_tail, rfd_t, rfd_link, NORMALIRQS);
  4845.      /* nexttail should be rx_head */
  4846.      if (nexttail != priv->rx_head)
  4847.          printk ("%s: receiver buffer chaining error (%04X != %04X)\n", dev->name, nexttail,
  4848.              priv->rx_head);
  4849. -    ether1_outw (dev, RFD_CMDEL | RFD_CMDSUSPEND, nexttail, rfd_t, rfd_command);
  4850. -    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_command);
  4851. -    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_status);
  4852. -    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_rbdoffset);
  4853. +    ether1_outw (dev, RFD_CMDEL | RFD_CMDSUSPEND, nexttail, rfd_t, rfd_command, NORMALIRQS);
  4854. +    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_command, NORMALIRQS);
  4855. +    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_status, NORMALIRQS);
  4856. +    ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_rbdoffset, NORMALIRQS);
  4857.      
  4858.      priv->rx_tail = nexttail;
  4859. -    priv->rx_head = ether1_inw (dev, priv->rx_head, rfd_t, rfd_link);
  4860. +    priv->rx_head = ether1_inw (dev, priv->rx_head, rfd_t, rfd_link, NORMALIRQS);
  4861.      } while (1);
  4862.  }
  4863.  
  4864. @@ -898,10 +926,10 @@
  4865.  
  4866.      dev->interrupt = 1;
  4867.  
  4868. -    status = ether1_inw (dev, SCB_ADDR, scb_t, scb_status);
  4869. +    status = ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS);
  4870.      if (status ) {
  4871.      ether1_outw (dev, status & (SCB_STRNR | SCB_STCNA | SCB_STFR | SCB_STCX),
  4872. -            SCB_ADDR, scb_t, scb_command);
  4873. +            SCB_ADDR, scb_t, scb_command, NORMALIRQS);
  4874.      outb (CTRL_CA | CTRL_ACK, REG_CONTROL);
  4875.      if (status & SCB_STCX) {
  4876.          ether1_xmit_done (dev);
  4877. @@ -909,8 +937,9 @@
  4878.      if (status & SCB_STCNA) {
  4879.          if (priv->resetting == 0)
  4880.          printk ("%s: CU went not ready ???\n", dev->name);
  4881. -        if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset) != (unsigned short)I82586_NULL) {
  4882. -        ether1_outw (dev, SCB_CMDCUCSTART, SCB_ADDR, scb_t, scb_command);
  4883. +        if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS)
  4884. +                != (unsigned short)I82586_NULL) {
  4885. +        ether1_outw (dev, SCB_CMDCUCSTART, SCB_ADDR, scb_t, scb_command, NORMALIRQS);
  4886.          outb (CTRL_CA, REG_CONTROL);
  4887.          }
  4888.          if (priv->resetting == 2)
  4889. @@ -921,7 +950,8 @@
  4890.      }
  4891.      if (status & SCB_STRNR) {
  4892.          printk ("%s: RU went not ready\n", dev->name);
  4893. -        printk ("RU ptr = %04X\n", ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset));
  4894. +        printk ("RU ptr = %04X\n", ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset,
  4895. +                    NORMALIRQS));
  4896.      }
  4897.      } else
  4898.          outb (CTRL_ACK, REG_CONTROL);
  4899. diff -urN linux.store/linux/arch/arm/drivers/net/ether3.c linux/arch/arm/drivers/net/ether3.c
  4900. --- linux.store/linux/arch/arm/drivers/net/ether3.c    Tue Mar  5 13:04:29 1996
  4901. +++ linux/arch/arm/drivers/net/ether3.c    Mon Mar 11 22:35:09 1996
  4902. @@ -3,7 +3,7 @@
  4903.   *
  4904.   * SEEQ nq8005 ethernet driver
  4905.   *
  4906. - * By Russell King.
  4907. + * By Russell King, with some suggestions from borris@ant.co.uk
  4908.   *
  4909.   * Changelog:
  4910.   *  29/02/96:    RMK    Won't pass packets that are from our ethernet address
  4911. @@ -182,7 +182,6 @@
  4912.  ether3_ramtest(struct device *dev, unsigned char byte)
  4913.  {
  4914.      unsigned char *buffer = kmalloc(RX_END, GFP_KERNEL);
  4915. -    unsigned long flags;
  4916.      int i,ret=0;
  4917.      int max_errors = 4;
  4918.      int bad=-1;
  4919. @@ -190,9 +189,6 @@
  4920.      if (!buffer)
  4921.      return 1;
  4922.  
  4923. -    save_flags (flags);
  4924. -    cli ();
  4925. -
  4926.      memset (buffer, byte, RX_END);
  4927.      ether3_writebuffer (dev, buffer, 0, TX_END);
  4928.      ether3_writebuffer (dev, buffer+RX_START, RX_START, RX_LEN);
  4929. @@ -220,7 +216,6 @@
  4930.      if (bad != -1)
  4931.      printk (" - 0x10000\n");
  4932.      kfree (buffer);
  4933. -    restore_flags (flags);
  4934.  
  4935.      return ret;
  4936.  }
  4937. @@ -462,8 +457,7 @@
  4938.      dev->tbusy = 1;
  4939.      dev->start = 0;
  4940.  
  4941. -    save_flags (flags);
  4942. -    cli ();
  4943. +    save_flags_cli (flags);
  4944.  
  4945.      outw (CMD_RXOFF|CMD_TXOFF, REG_COMMAND);
  4946.      priv->regs.command = 0;
  4947. @@ -583,8 +577,7 @@
  4948.  
  4949.      thishdr |= htons (nextpacket);
  4950.  
  4951. -    save_flags(flags);
  4952. -    cli();
  4953. +    save_flags_cli (flags);
  4954.      ether3_writebuffer(dev, skb->data, thisdata, (length & 1) ? (length + 1) : length);
  4955.      ether3_writebuffer(dev, &nexthdr, -1, 4);
  4956.      ether3_ledincrementuse (dev);
  4957. @@ -631,17 +624,20 @@
  4958.  
  4959.          done = 0;
  4960.      status = inw(REG_STATUS);
  4961. -    outw ((status & (STAT_INTRX|STAT_INTTX|STAT_INTBUFWIN))
  4962. -        | priv->regs.command, REG_COMMAND);
  4963.  
  4964.      if (status & STAT_INTRX) { /* Got a packet(s). */
  4965. +        outw (CMD_ACKINTRX | priv->regs.command, REG_COMMAND);
  4966.          ether3_rx (dev, priv);
  4967.          done = 1;
  4968.      }
  4969.      if (status & STAT_INTTX) { /* Packets transmitted */
  4970. +        outw (CMD_ACKINTTX | priv->regs.command, REG_COMMAND);
  4971.          ether3_tx (dev, priv);
  4972.          done = 1;
  4973.      }
  4974. +    if (status & STAT_INTBUFWIN) { /* buffer window interrupt */
  4975. +        outw (CMD_ACKINTBUFWIN | priv->regs.command, REG_COMMAND);
  4976. +    }
  4977.      } while (-- boguscount && !done) ;
  4978.  
  4979.      dev->interrupt = 0;
  4980. @@ -685,10 +681,8 @@
  4981.      prev_recv_ptr = current_recv_ptr;
  4982.      ether3_readbuffer (dev, &p, current_recv_ptr, 16);
  4983.  
  4984. -    if ((p.rxhdr & RX_NEXT) == 0 || (p.rxhdr & RXSTAT_DONE) == 0
  4985. -        || (p.rxhdr & (RXHDR_CHAINCONTINUE|RXHDR_RECEIVE)) != RXHDR_CHAINCONTINUE)
  4986. +    if ((p.rxhdr & RX_NEXT) == 0 || (p.rxhdr & RXSTAT_DONE) == 0)
  4987.          break;
  4988. -
  4989.      current_recv_ptr = ntohs (p.rxhdr & RX_NEXT);
  4990.  
  4991.      /*
  4992. @@ -696,7 +690,10 @@
  4993.        */
  4994.      if (memcmp (dev->dev_addr, &p.src_addr, 6) == 0) {
  4995.          outw (current_recv_ptr >> 8, REG_RECVEND);
  4996. -        continue;
  4997. +        if (p.rxhdr & RXHDR_CHAINCONTINUE)
  4998. +        continue;
  4999. +        else
  5000. +        break;
  5001.      }
  5002.  
  5003.      if (p.rxhdr & (RXSTAT_OVERSIZE|RXSTAT_CRCERROR|RXSTAT_DRIBBLEERROR|RXSTAT_SHORTPACKET)) {
  5004. @@ -706,7 +703,10 @@
  5005.          if(p.rxhdr & RXSTAT_DRIBBLEERROR) priv->stats.rx_fifo_errors ++;
  5006.          if(p.rxhdr & RXSTAT_SHORTPACKET) priv->stats.rx_length_errors ++;
  5007.          outw (current_recv_ptr >> 8, REG_RECVEND);
  5008. -        continue;
  5009. +        if (p.rxhdr & RXHDR_CHAINCONTINUE)
  5010. +        continue;
  5011. +        else
  5012. +        break;
  5013.      }
  5014.  
  5015.      if (current_recv_ptr > prev_recv_ptr)
  5016. @@ -742,6 +742,8 @@
  5017.      skb->protocol = eth_type_trans(skb, dev);
  5018.      netif_rx (skb);
  5019.      priv->stats.rx_packets++;
  5020. +    if (!(p.rxhdr & RXHDR_CHAINCONTINUE))
  5021. +        break;
  5022.      }
  5023.      while (-- maxcnt);
  5024.  
  5025. diff -urN linux.store/linux/arch/arm/drivers/scsi/Makefile linux/arch/arm/drivers/scsi/Makefile
  5026. --- linux.store/linux/arch/arm/drivers/scsi/Makefile    Sat Feb 24 13:17:59 1996
  5027. +++ linux/arch/arm/drivers/scsi/Makefile    Wed Mar 13 22:57:35 1996
  5028. @@ -122,10 +122,10 @@
  5029.      $(LD) $(LD_RFLAG) -r -o $@ sd.o sd_ioctl.o
  5030.  
  5031.  oak_mod.o: oak.o
  5032. -    $(LD) $(LD_RFLAG) -r -o oak_mod.o oak.o `gcc --print-libgcc-file-name`
  5033. +    $(LD) $(LD_RFLAG) -r -o oak_mod.o oak.o $(GCCLIB)
  5034.  
  5035.  acornscsi_mod.o: acornscsi.o acornscsi-io.o
  5036. -    $(LD) $(LD_RFLAG) -r -o acornscsi_mod.o acornscsi.o acornscsi-io.o `gcc --print-libgcc-file-name`
  5037. +    $(LD) $(LD_RFLAG) -r -o acornscsi_mod.o acornscsi.o acornscsi-io.o $(GCCLIB)
  5038.  
  5039.  $(SYMTAB_OBJS): $(SYMTAB_OBJS:.o=.c)
  5040.  
  5041. diff -urN linux.store/linux/arch/arm/drivers/scsi/acornscsi.c linux/arch/arm/drivers/scsi/acornscsi.c
  5042. --- linux.store/linux/arch/arm/drivers/scsi/acornscsi.c    Sun Feb 11 09:32:31 1996
  5043. +++ linux/arch/arm/drivers/scsi/acornscsi.c    Mon Mar 11 22:35:55 1996
  5044. @@ -785,8 +785,7 @@
  5045.  
  5046.      dmac_write (instance, MASKREG, MASK_ON);
  5047.  
  5048. -    save_flags (flags);
  5049. -    cli ();
  5050. +    save_flags_cli (flags);
  5051.      ascmd = hostdata->connected;
  5052.      hostdata->connected = NULL;
  5053.  
  5054. diff -urN linux.store/linux/arch/arm/kernel/Makefile linux/arch/arm/kernel/Makefile
  5055. --- linux.store/linux/arch/arm/kernel/Makefile    Sun Feb 11 09:32:37 1996
  5056. +++ linux/arch/arm/kernel/Makefile    Wed Mar 13 14:32:05 1996
  5057. @@ -17,6 +17,10 @@
  5058.          ioport.o arm.o setup.o time.o ecard.o sys-arm.o \
  5059.          dma.o
  5060.  
  5061. +ifeq ($(MACHINE),arc)
  5062. +  O_OBJS += oldlatches.o
  5063. +endif
  5064. +
  5065.  head.o: head.S $(TOPDIR)/include/linux/tasks.h
  5066.      $(CC) -D__ASSEMBLY__ -traditional -c $*.S -o $*.o
  5067.  
  5068. diff -urN linux.store/linux/arch/arm/kernel/dma.c linux/arch/arm/kernel/dma.c
  5069. --- linux.store/linux/arch/arm/kernel/dma.c    Sun Mar  3 13:02:49 1996
  5070. +++ linux/arch/arm/kernel/dma.c    Wed Mar 13 14:53:17 1996
  5071. @@ -15,6 +15,7 @@
  5072.  
  5073.  void enable_dma (unsigned int dmanr)
  5074.  {
  5075. +#ifdef CONFIG_BLK_DEV_FD
  5076.      if (dmanr == 2) {
  5077.          switch (dma_direction[dmanr]) {
  5078.          case 1: /* read */
  5079. @@ -42,8 +43,72 @@
  5080.          default:
  5081.          printk ("enable_dma: dma%d not initialised\n", dmanr);
  5082.          return;
  5083. -    }
  5084. -    }
  5085. +    } /* Direction switch */
  5086. +    }; /* dmanr == 2 */
  5087. +#endif
  5088. +#ifdef CONFIG_BLK_DEV_FD1772
  5089. +    switch (dmanr) {
  5090. +      case 0: /* Data DMA */
  5091. +        switch (dma_direction[dmanr]) {
  5092. +        case 1: /* read */
  5093. +                {
  5094. +            extern unsigned char fdc1772_dma_read, fdc1772_dma_read_end;
  5095. +            extern void fdc1772_setupdma(unsigned int count,unsigned int addr);
  5096. +            unsigned long flags;
  5097. +
  5098. +      /*printk("enable_dma fdc1772 data read\n");*/
  5099. +            save_flags(flags);
  5100. +            cliIF();
  5101. +            
  5102. +            memcpy ((void *)0x1c, (void *)&fdc1772_dma_read,
  5103. +                &fdc1772_dma_read_end - &fdc1772_dma_read);
  5104. +            fdc1772_setupdma(dma_count[dmanr],dma_address[dmanr]); /* Sets data pointer up */
  5105. +            enable_irq (16);
  5106. +            restore_flags(flags);
  5107. +        }
  5108. +        break;
  5109. +
  5110. +        case 0: /* write */
  5111. +            {
  5112. +            extern unsigned char fdc1772_dma_write, fdc1772_dma_write_end;
  5113. +            extern void fdc1772_setupdma(unsigned int count,unsigned int addr);
  5114. +            unsigned long flags;
  5115. +
  5116. +      /*printk("enable_dma fdc1772 data write\n");*/
  5117. +            save_flags(flags);
  5118. +            cliIF();
  5119. +            memcpy ((void *)0x1c, (void *)&fdc1772_dma_write,
  5120. +                &fdc1772_dma_write_end - &fdc1772_dma_write);
  5121. +            fdc1772_setupdma(dma_count[dmanr],dma_address[dmanr]); /* Sets data pointer up */
  5122. +            enable_irq (16);
  5123. +
  5124. +            restore_flags(flags);
  5125. +        }
  5126. +        break;
  5127. +
  5128. +            default:
  5129. +            printk ("enable_dma: dma%d not initialised\n", dmanr);
  5130. +            return;
  5131. +    } /* DMA direction switch */
  5132. +        break;
  5133. +
  5134. +      case 1: /* Command end FIQ - actually just sets a flag */
  5135. +      {
  5136. +    /* Need to build a branch at the FIQ address */
  5137. +    extern void fdc1772_comendhandler(void);
  5138. +    unsigned long flags;
  5139. +
  5140. +  /*printk("enable_dma fdc1772 command end FIQ\n");*/
  5141. +    save_flags(flags);
  5142. +    cliIF();
  5143. +    
  5144. +    *((unsigned int *)0x1c)=0xea000000 | (((unsigned int)fdc1772_comendhandler-(0x1c+8))/4); /* B fdc1772_comendhandler */
  5145. +
  5146. +    restore_flags(flags);
  5147. +      };
  5148. +      break;
  5149. +    } /* dma number switch */
  5150. +#endif
  5151.  }
  5152.  
  5153.  void set_dma_mode (unsigned int dmanr, char mode)
  5154. @@ -79,9 +144,15 @@
  5155.  
  5156.  int get_dma_residue (unsigned int dmanr)
  5157.  {
  5158. +#ifdef CONFIG_BLK_DEV_FD
  5159.      extern int floppy_fiqresidual (void);
  5160.      if (dmanr == 2)
  5161.      return floppy_fiqresidual ();
  5162. +#endif
  5163. +#ifdef CONFIG_BLK_DEV_FD1772
  5164. +    extern unsigned int fdc1772_bytestogo;
  5165. +    if (dmanr == 0) return fdc1772_bytestogo; 
  5166. +#endif
  5167.  
  5168.      return -1;
  5169.  }
  5170. diff -urN linux.store/linux/arch/arm/kernel/ecard.c linux/arch/arm/kernel/ecard.c
  5171. --- linux.store/linux/arch/arm/kernel/ecard.c    Tue Mar  5 13:04:29 1996
  5172. +++ linux/arch/arm/kernel/ecard.c    Wed Mar 13 14:47:54 1996
  5173. @@ -20,12 +20,16 @@
  5174.  #include <asm/ecard.h>
  5175.  #include <asm/irq.h>
  5176.  #include <asm/io.h>
  5177. +#ifdef CONFIG_ARCH_ARC
  5178. +#include <asm/arch/oldlatches.h>
  5179. +#endif
  5180.  
  5181.  /*
  5182.   * from linux/arch/arm/kernel/irq.c
  5183.   */
  5184.  extern void do_fast_IRQ(int irq);
  5185.  extern unsigned char *ioc;
  5186. +int ecard_num_cards;
  5187.  
  5188.  #define MAX_ECARDS 4
  5189.  
  5190. @@ -36,7 +40,7 @@
  5191.  static char initialised = 0;
  5192.  static unsigned long kmem;
  5193.  
  5194. -void *ecard_malloc(int len)
  5195. +static void *ecard_malloc(int len)
  5196.  {
  5197.      int r;
  5198.  
  5199. @@ -53,8 +57,9 @@
  5200.  static void expansioncard_irq_noexpmask(int intr_no, struct pt_regs *regs)
  5201.  {
  5202.      int i;
  5203. +    const int num_cards = ecard_num_cards;
  5204.  
  5205. -    for(i=0; i<MAX_ECARDS; i++) {
  5206. +    for (i = 0; i < num_cards; i++) {
  5207.      if (expcard[i].r_found && expcard[i].r_claimed && expcard[i].irq) {
  5208.          if (expcard[i].r_irqmask) {
  5209.          if(expcard[i].r_irqaddr[0] & expcard[i].r_irqmask)
  5210. @@ -70,11 +75,12 @@
  5211.  static void expansioncard_irq_expmask (int intr_no, struct pt_regs *regs)
  5212.  {
  5213.      int i, ns = 0;
  5214. +    const int num_cards = ecard_num_cards;
  5215.  #if 0
  5216.      int oldexpmask;
  5217.  #endif
  5218.  
  5219. -    for (i = 0; i < MAX_ECARDS; i++) {
  5220. +    for (i = 0; i < num_cards; i++) {
  5221.      if (expmask[0] & (1 << i)) {
  5222.          if (expcard[i].r_found && expcard[i].r_claimed) {
  5223.          if (!expcard[i].r_irqmask || (expcard[i].r_irqaddr[0] & expcard[i].r_irqmask)) {
  5224. @@ -136,51 +142,73 @@
  5225.      }*/
  5226.  }
  5227.  
  5228. -static int ecard_checkirqhw(void)
  5229. +static int ecard_checkirqhw (void)
  5230.  {
  5231. -    int found;
  5232. -    expmask[4] = 0x00;
  5233. -    expmask[0] = 0xff;
  5234. -    found = (expmask[0] == 0xf0);
  5235. -    expmask[4] = 0xff;
  5236. -    return found;
  5237. +    int found;
  5238. +    expmask[4] = 0x00;
  5239. +    expmask[0] = 0xff;
  5240. +    found = (expmask[0] == 0xf0);
  5241. +    expmask[4] = 0xff;
  5242. +    return found;
  5243.  }
  5244.  
  5245. -static void ecard_readbytes(void *addr, struct expansion_card *ec, int off, int len, int useld)
  5246. +static void ecard_readbytes (void *addr, struct expansion_card *ec, int off, int len, int useld)
  5247.  {
  5248. -    extern int read_loader(int off, volatile unsigned char *pa, unsigned char *loader);
  5249. +    extern int ecard_loader_read(int off, volatile unsigned char *pa, unsigned char *loader);
  5250.    
  5251. -    unsigned char *a = (unsigned char *)addr;
  5252. +    unsigned char *a = (unsigned char *)addr;
  5253.  
  5254. -    if(!useld || !ec->r_loader) {
  5255. -        while(len--)
  5256. -            *a++ = ec->r_podaddr[(off++)*4];
  5257. -    } else {
  5258. -        while(len--) {
  5259. -            *(unsigned long *)0x108 = 0; /* hack for some loaders!!! */
  5260. -            *a++ = read_loader(off++, ec->r_podaddr, ec->r_loader);
  5261. -        }
  5262. +    if (!useld || !ec->r_loader) {
  5263. +    while(len--)
  5264. +        *a++ = ec->r_podaddr[(off++)*4];
  5265. +    } else {
  5266. +    while(len--) {
  5267. +        *(unsigned long *)0x108 = 0; /* hack for some loaders!!! */
  5268. +        *a++ = ecard_loader_read(off++, ec->r_podaddr, ec->r_loader);
  5269.      }
  5270. +    }
  5271.  }
  5272.  
  5273. -struct expansion_card *ecard_find(int cld, int num, int prod[], int manu[])
  5274. +/*
  5275. + * This is called to reset the loaders for each expansion card on reboot.
  5276. + *
  5277. + * This is required to make sure that the card is in the correct state
  5278. + * that RiscOS expects it to be.
  5279. + */
  5280. +void ecard_reset (int card)
  5281.  {
  5282. -    int i, j;
  5283. +    extern int ecard_loader_reset (volatile unsigned char *pa, unsigned char *loader);
  5284.  
  5285. -    for (i = 0 ; i<MAX_ECARDS; i++) {
  5286. -        if(expcard[i].r_found == 0 || expcard[i].r_claimed)
  5287. -            continue;
  5288. -        if((e_ecld(&expcard[i].ecld) & 0x78) != (cld & 0x78))
  5289. -            continue;
  5290. -        if((e_ecld(&expcard[i].ecld) & 0x78) != 0)
  5291. -            return &expcard[i];
  5292. -        for (j = 0; j<num; j++) {
  5293. -            if(e_prod(&expcard[i].ecld) == prod[j] &&
  5294. -                e_manu(&expcard[i].ecld) == manu[j])
  5295. -                return &expcard[i];
  5296. -        }
  5297. +    if (card >= ecard_num_cards)
  5298. +    return;
  5299. +    
  5300. +    if (card < 0) {
  5301. +    for (card = 0; card < ecard_num_cards; card++)
  5302. +        if (expcard[card].r_loader)
  5303. +        ecard_loader_reset (expcard[card].r_podaddr, expcard[card].r_loader);
  5304. +    } else
  5305. +    if (expcard[card].r_loader)
  5306. +        ecard_loader_reset (expcard[card].r_podaddr, expcard[card].r_loader);
  5307. +}
  5308. +
  5309. +struct expansion_card *ecard_find (int cld, int num, int prod[], int manu[])
  5310. +{
  5311. +    int i, j;
  5312. +
  5313. +    for (i = 0 ; i < ecard_num_cards; i++) {
  5314. +    if(expcard[i].r_found == 0 || expcard[i].r_claimed)
  5315. +        continue;
  5316. +    if((e_ecld(&expcard[i].ecld) & 0x78) != (cld & 0x78))
  5317. +        continue;
  5318. +    if((e_ecld(&expcard[i].ecld) & 0x78) != 0)
  5319. +        return &expcard[i];
  5320. +    for (j = 0; j<num; j++) {
  5321. +        if (e_prod(&expcard[i].ecld) == prod[j] &&
  5322. +        e_manu(&expcard[i].ecld) == manu[j])
  5323. +            return &expcard[i];
  5324.      }
  5325. -    return NULL;
  5326. +    }
  5327. +    return NULL;
  5328.  }
  5329.  
  5330.  int ecard_readchunk(struct chunk_dir *cd, struct expansion_card *ec, int id, int num)
  5331. @@ -230,28 +258,37 @@
  5332.  unsigned long ecard_init(unsigned long my_kmem)
  5333.  {
  5334.      int i;
  5335. +
  5336.      kmem = (my_kmem | 3) + 1;
  5337. +
  5338.      initialised = 0;
  5339. +    ecard_num_cards = 4;
  5340.  
  5341. -    for (i=0; i<MAX_ECARDS; i++) {
  5342. +    if (ecard_num_cards > MAX_ECARDS)
  5343. +    ecard_num_cards = MAX_ECARDS;
  5344. +
  5345. +    for (i = 0; i < ecard_num_cards; i++) {
  5346.      expcard[i].r_claimed = 0;
  5347.      expcard[i].r_found = 0;
  5348.      }
  5349.  
  5350. +    if (ecard_num_cards == 0)
  5351. +    return kmem;
  5352. +
  5353.      if (ecard_checkirqhw()) {
  5354.      have_expmask = 0xff;
  5355.      printk("Expansion card interrupt management hardware found\n");
  5356.      }
  5357.  
  5358. -    if (request_irq(IRQ_EXPANSIONCARD, have_expmask ? expansioncard_irq_expmask :
  5359. +    if (request_irq (IRQ_EXPANSIONCARD, have_expmask ? expansioncard_irq_expmask :
  5360.          expansioncard_irq_noexpmask, 0, "expansion cards") != 0) {
  5361. -    printk("Could not allocate interrupt for expansion cards\n");
  5362. +    printk ("Could not allocate interrupt for expansion cards\n");
  5363.      return kmem;
  5364.      }
  5365.      
  5366.      printk("Searching for expansion cards:");
  5367.  
  5368. -    for (i=0; i<MAX_ECARDS; i++) {
  5369. +    for (i = 0; i < ecard_num_cards; i++) {
  5370.      struct expansion_card *ec;
  5371.          
  5372.      ec = &expcard[i];
  5373. @@ -262,7 +299,7 @@
  5374.      ec->irq = 0;
  5375.      ec->fiq = 0;
  5376.          
  5377. -    ecard_readbytes(&ec->ecld, ec, 0, 16, 0);
  5378. +    ecard_readbytes (&ec->ecld, ec, 0, 16, 0);
  5379.          
  5380.      if (ec->ecld.r_ecld & 2) {
  5381.          have_expmask &= ~(1<<i);
  5382. @@ -306,5 +343,11 @@
  5383.  
  5384.  unsigned long bios32_init(unsigned long start_mem, unsigned long end_mem)
  5385.  {
  5386. -    return ecard_init(start_mem);
  5387. +    unsigned long mem;
  5388. +
  5389. +    mem = ecard_init(start_mem);
  5390. +
  5391. +#ifdef CONFIG_ARCH_ARC
  5392. +    oldlatch_init ();
  5393. +#endif
  5394.  }
  5395. diff -urN linux.store/linux/arch/arm/kernel/head.S linux/arch/arm/kernel/head.S
  5396. --- linux.store/linux/arch/arm/kernel/head.S    Sun Mar  3 13:03:43 1996
  5397. +++ linux/arch/arm/kernel/head.S    Thu Mar 14 23:26:08 1996
  5398. @@ -67,39 +67,32 @@
  5399.  @        4156025X = ARM 250
  5400.  @        4156020X = ARM 2
  5401.  @
  5402. -        adr    r0, undef_instr - 12
  5403. -        mov    r2, #4
  5404. -        mov    r3, #0xea000000
  5405. -        orr    r0, r3, r0, lsr #2
  5406. -        str    r0, [r2]
  5407. -
  5408. -        mrc    15, 0, r0, c0, c0
  5409. -
  5410. -continue:
  5411. +        adr    r3, undef_instr - 12
  5412. +        mov    r2, #0
  5413. +        mov    r0, #0xea000000
  5414. +        orr    r3, r0, r3, lsr #2
  5415. +        str    r3, [r2, #4]
  5416. +
  5417. +        ldr    r3, arm2_id
  5418. +        swp    r0, r0, [r2]        @ check for swp - if it can't do it, then it
  5419. +        ldr    r3, arm250_id        @ must be ARM2
  5420. +        mrc    15, 0, r0, c0, c0    @ check for CP#15 - if it can't do it, then ARM250
  5421. +        mov    r3, r0
  5422. +continue:    ldr    r0, [pc, #LC4 - . - 8]
  5423. +        str    r3, [r0]
  5424.  @
  5425.  @ Make undefined instr vector point to itself (endless loop)
  5426.  @
  5427. +        mov    r3, #0xeb000000
  5428.          sub    r3, r3, #2
  5429. -        orr    r3, r3, #0xeb000000
  5430. -        str    r3, [r2]
  5431. -        ldr    r3, [pc, #LC4 - . - 8]
  5432. -        str    r0, [r3]
  5433. +        mov    r2, #0
  5434. +        str    r3, [r2, #4]
  5435.          mov    fp, #0
  5436.          b    _start_kernel
  5437.  @
  5438. -@ IF we come in here from the mrc instruction, then we have an ARM2/250
  5439. +@ IF we come in here then one of the swp / mrc instructions must have aborted - jum
  5440.  @
  5441. -undef_instr:    adr    r0, undef_instr2 - 12
  5442. -        orr    r0, r3, r0, lsr #2
  5443. -        str    r0, [r2], #4
  5444. -        swpb    r0, r0, [r2]
  5445. -        ldr     r0, arm250_id
  5446. -        b    continue
  5447. -
  5448. -arm250_id:    .long    0x41560250
  5449. -
  5450. -undef_instr2:    ldr    r0, arm2_id
  5451. -        b    continue
  5452. +undef_instr:    b    continue
  5453.  
  5454.  arm2_id:    .long    0x41560200
  5455. -
  5456. +arm250_id:    .long    0x41560250
  5457. diff -urN linux.store/linux/arch/arm/kernel/irq.c linux/arch/arm/kernel/irq.c
  5458. --- linux.store/linux/arch/arm/kernel/irq.c    Sun Mar  3 13:04:56 1996
  5459. +++ linux/arch/arm/kernel/irq.c    Wed Mar 13 15:12:17 1996
  5460. @@ -51,8 +51,12 @@
  5461.      extern void ecard_disableirq (unsigned int);
  5462.      unsigned long flags;
  5463.  
  5464. +#ifdef cliIF
  5465.      save_flags(flags);
  5466. -    cli();
  5467. +    cliIF();
  5468. +#else
  5469. +    save_flags_cli (flags);
  5470. +#endif
  5471.  
  5472.      enabled_irqs &= ~(1 << irq_nr);
  5473.  
  5474. @@ -75,8 +79,12 @@
  5475.      extern void ecard_enableirq (unsigned int);
  5476.      unsigned long flags;
  5477.  
  5478. -    save_flags(flags);
  5479. -    cli();
  5480. +#ifdef cliIF
  5481. +    save_flags (flags);
  5482. +    cliIF();
  5483. +#else
  5484. +    save_flags_cli (flags);
  5485. +#endif
  5486.  
  5487.      enabled_irqs |= 1 << irq_nr;
  5488.  
  5489. diff -urN linux.store/linux/arch/arm/kernel/oldlatches.c linux/arch/arm/kernel/oldlatches.c
  5490. --- linux.store/linux/arch/arm/kernel/oldlatches.c    Thu Jan  1 01:00:00 1970
  5491. +++ linux/arch/arm/kernel/oldlatches.c    Mon Mar 11 23:27:12 1996
  5492. @@ -0,0 +1,47 @@
  5493. +/* Support for the latches on the old Archimedes which control the floppy,
  5494. +   hard disc and printer
  5495. +
  5496. +   (c) David Alan Gilbert 1995/1996
  5497. +
  5498. +*/
  5499. +#include <linux/config.h>
  5500. +#include <linux/kernel.h>
  5501. +
  5502. +#include <asm/machdep.h>
  5503. +#include <asm/io.h>
  5504. +
  5505. +/* They are static so that everyone who accesses them has to go through here */
  5506. +static unsigned char LatchACopy;
  5507. +static unsigned char LatchBCopy;
  5508. +
  5509. +#define LATCHAADDR 0x3250040
  5510. +#define LATCHBADDR 0x3250018
  5511. +
  5512. +/* newval=(oldval & ~mask)|newdata */
  5513. +void oldlatch_aupdate(unsigned char mask,unsigned char newdata)
  5514. +{
  5515. +  LatchACopy=(LatchACopy & ~mask)|newdata;
  5516. +  outb(LatchACopy,(LATCHAADDR >> 2));
  5517. +#ifdef DEBUG
  5518. +  printk("oldlatch_A:0x%2x\n",LatchACopy);
  5519. +#endif
  5520. +
  5521. +};
  5522. +
  5523. +/* newval=(oldval & ~mask)|newdata */
  5524. +void oldlatch_bupdate(unsigned char mask,unsigned char newdata)
  5525. +{
  5526. +  LatchBCopy=(LatchBCopy & ~mask)|newdata;
  5527. +  outb(LatchBCopy,(LATCHBADDR >> 2));
  5528. +#ifdef DEBUG
  5529. +  printk("oldlatch_B:0x%2x\n",LatchBCopy);
  5530. +#endif
  5531. +};
  5532. +
  5533. +void oldlatch_init(void)
  5534. +{
  5535. +  printk("oldlatch: init\n");
  5536. +  oldlatch_aupdate(0xff,0xff);
  5537. +  oldlatch_bupdate(0xff,0x8); /* Thats no FDC reset...*/
  5538. +  return ;
  5539. +}
  5540. diff -urN linux.store/linux/arch/arm/kernel/process.c linux/arch/arm/kernel/process.c
  5541. --- linux.store/linux/arch/arm/kernel/process.c    Tue Mar  5 13:04:29 1996
  5542. +++ linux/arch/arm/kernel/process.c    Fri Mar  8 22:36:31 1996
  5543. @@ -60,12 +60,17 @@
  5544.  
  5545.  void hard_reset_now(void)
  5546.  {
  5547. +    extern void ecard_reset (int card);
  5548. +    extern unsigned long arm_id;
  5549. +    /*
  5550. +     * reset all expansion cards
  5551. +     */
  5552. +    ecard_reset (-1);
  5553.      /*
  5554.       * If we are using the ARM3, turn off the cache!
  5555.       * otherwise we get problems with 256 colour modes
  5556.       * and floppy drive accesses in RiscOS.
  5557.       */
  5558. -    extern unsigned long arm_id;
  5559.      if ((arm_id & 0xfffffff0) == 0x41560300)
  5560.      __asm__ __volatile__ ("mcr 15, 0, %0, c2, c0": : "r" (2));
  5561.  
  5562. diff -urN linux.store/linux/arch/arm/kernel/setup.c linux/arch/arm/kernel/setup.c
  5563. --- linux.store/linux/arch/arm/kernel/setup.c    Thu Mar 14 23:33:06 1996
  5564. +++ linux/arch/arm/kernel/setup.c    Thu Mar 14 23:09:24 1996
  5565. @@ -30,6 +30,7 @@
  5566.  #define F_MEMC   (1<<0)
  5567.  #define F_MMU    (1<<1)
  5568.  #define F_32BIT  (1<<2)
  5569. +#define F_CACHE  (1<<3)
  5570.  #define F_IOEB   (1<<31)
  5571.  
  5572.  struct drive_info_struct { char dummy[32]; } drive_info;
  5573. @@ -74,7 +75,7 @@
  5574.  } armidlist[] = {
  5575.      { 0x41560200, 0xfffffff0, F_MEMC    , 0x03000000    , "ARM",    "arm2"        },
  5576.      { 0x41560250, 0xfffffff0, F_MEMC    , 0x03000000    , "ARM",    "arm250"    },
  5577. -    { 0x41560300, 0xfffffff0, F_MEMC    , 0x03000000    , "ARM",    "arm3"        },
  5578. +    { 0x41560300, 0xfffffff0, F_MEMC|F_CACHE, 0x03000000    , "ARM",    "arm3"        },
  5579.      { 0x41560610, 0xfffffff0, F_MMU|F_32BIT    , 0        , "ARM",    "arm610"    },
  5580.      { 0x44450000, 0xffff0000, F_MMU        , 0        , "DEC",    "SA-1"        },
  5581.      { 0x00000000, 0x00000000, 0        , 0        , "***",    "*unknown*"    }
  5582. @@ -96,7 +97,9 @@
  5583.  extern int bytes_per_char_h;
  5584.  extern int bytes_per_char_v;
  5585.  extern char arc_hd_files[8][128];
  5586. +#ifdef CONFIG_BLK_DEV_HD
  5587.  extern int no_hds;
  5588. +#endif
  5589.  extern int ramdisk_size;
  5590.  extern int root_mountflags;
  5591.  extern int _etext, _edata, _end;
  5592. @@ -140,7 +143,7 @@
  5593.  
  5594.      check_ioeb_present();
  5595.  
  5596. -    if ((arm_id & 0x0000fff0) == 0x300) {
  5597. +    if (armidlist[armidindex].features & F_CACHE) {
  5598.          __asm__ __volatile__("
  5599.          mcr    15, 0, %0, c3, c0
  5600.          mcr    15, 0, %1, c4, c0
  5601. @@ -150,7 +153,7 @@
  5602.          " : : "r" (0x000e7fff), "r" (0x000e7fff), "r" (0xf0000000), "r" (3));
  5603.      } else {
  5604.          /* ok, so this is a bit dirty... Self modifing code! */
  5605. -        extern unsigned long *arm3_flushcache;
  5606. +        extern unsigned long arm3_flushcache[2];
  5607.          arm3_flushcache[0] = arm3_flushcache[1];
  5608.      }
  5609.  
  5610. @@ -165,8 +168,9 @@
  5611.      ORIG_VIDEO_COLS = params->video_num_cols;
  5612.      ORIG_VIDEO_LINES = params->video_num_rows;
  5613.      memc_ctrl_reg = params->memc_control_reg;
  5614. +#ifdef CONFIG_BLK_DEV_HD
  5615.      no_hds = (params->adfsdrives >> 6) & 3;
  5616. -
  5617. +#endif
  5618.      aux_device_present = 0;
  5619.      memory_end = 0x02000000 + params->page_size * params->nr_pages;
  5620.      ramdisk_size = params->ramdisk_size;
  5621. diff -urN linux.store/linux/arch/arm/kernel/sys-arm.c linux/arch/arm/kernel/sys-arm.c
  5622. --- linux.store/linux/arch/arm/kernel/sys-arm.c    Tue Mar  5 13:04:29 1996
  5623. +++ linux/arch/arm/kernel/sys-arm.c    Wed Mar 13 22:19:33 1996
  5624. @@ -10,6 +10,7 @@
  5625.   */
  5626.  
  5627.  #include <linux/config.h>
  5628. +#include <linux/module.h>
  5629.  #include <linux/errno.h>
  5630.  #include <linux/sched.h>
  5631.  #include <linux/mm.h>
  5632. @@ -182,7 +183,7 @@
  5633.  asmlinkage int
  5634.  sys_arm_init_module (char *module_name, char *code, unsigned codesize, unsigned long *__p)
  5635.  {
  5636. -    extern int sys_init_module (char *, char *, unsigned, struct mod_routes *,
  5637. +    extern int sys_init_module (char *, char *, unsigned, struct mod_routines *,
  5638.              struct symbol_table *);
  5639.      return sys_init_module (module_name, code, codesize, (struct mod_routines *)__p[0],
  5640.              (struct symbol_table *)__p[1]);
  5641. diff -urN linux.store/linux/arch/arm/kernel/time.c linux/arch/arm/kernel/time.c
  5642. --- linux.store/linux/arch/arm/kernel/time.c    Sun Mar  3 13:07:50 1996
  5643. +++ linux/arch/arm/kernel/time.c    Wed Mar 13 12:27:14 1996
  5644. @@ -31,47 +31,46 @@
  5645.  
  5646.  unsigned long do_dummy_gettimeoffset(void)
  5647.  {
  5648. -    return 0;
  5649. +    return 0;
  5650.  }
  5651.  
  5652.  static unsigned long (*do_gettimeoffset)(void) = do_dummy_gettimeoffset;
  5653.  
  5654.  void do_gettimeofday(struct timeval *tv)
  5655.  {
  5656. -    unsigned long flags;
  5657. +    unsigned long flags;
  5658.  
  5659. -    save_flags (flags);
  5660. -    cli();
  5661. -    *tv = xtime;
  5662. -    tv->tv_usec += do_gettimeoffset();
  5663. -    if (tv->tv_usec >= 1000000) {
  5664. -        tv->tv_usec -= 1000000;
  5665. -        tv->tv_sec++;
  5666. -    }
  5667. -    restore_flags(flags);
  5668. +    save_flags_cli (flags);
  5669. +    *tv = xtime;
  5670. +    tv->tv_usec += do_gettimeoffset();
  5671. +    if (tv->tv_usec >= 1000000) {
  5672. +    tv->tv_usec -= 1000000;
  5673. +    tv->tv_sec++;
  5674. +    }
  5675. +    restore_flags(flags);
  5676.  }
  5677.  
  5678.  void do_settimeofday(struct timeval *tv)
  5679.  {
  5680. -    cli();
  5681. -    /* This is revolting. We need to set the xtime.tv_usec
  5682. -     * correctly. However, the value in this location is
  5683. -     * is value at the last tick.
  5684. -     * Discover what correction gettimeofday
  5685. -     * would have done, and then undo it!
  5686. -     */
  5687. -    tv->tv_usec -= do_gettimeoffset();
  5688. -
  5689. -    if (tv->tv_usec < 0) {
  5690. -        tv->tv_usec += 1000000;
  5691. -        tv->tv_sec--;
  5692. -    }
  5693. -
  5694. -    xtime = *tv;
  5695. -    time_state = TIME_BAD;
  5696. -    time_maxerror = 0x70000000;
  5697. -    time_esterror = 0x70000000;
  5698. -    sti();
  5699. +    cli ();
  5700. +    /* This is revolting. We need to set the xtime.tv_usec
  5701. +     * correctly. However, the value in this location is
  5702. +     * is value at the last tick.
  5703. +     * Discover what correction gettimeofday
  5704. +     * would have done, and then undo it!
  5705. +     */
  5706. +    tv->tv_usec -= do_gettimeoffset();
  5707. +
  5708. +    if (tv->tv_usec < 0) {
  5709. +    tv->tv_usec += 1000000;
  5710. +    tv->tv_sec--;
  5711. +    }
  5712. +
  5713. +    xtime = *tv;
  5714. +    time_state = TIME_BAD;
  5715. +    time_maxerror = 0x70000000;
  5716. +    time_esterror = 0x70000000;
  5717. +    sti ();
  5718.  }
  5719.  
  5720.  /*
  5721. @@ -83,8 +82,8 @@
  5722.   */
  5723.  int set_rtc_mmss(unsigned long nowtime)
  5724.  {
  5725. -  int retval = 0;
  5726. -  return retval;
  5727. +    int retval = 0;
  5728. +    return retval;
  5729.  }
  5730.  
  5731.  /* last time the cmos clock got updated */
  5732. @@ -96,19 +95,20 @@
  5733.   */
  5734.  static inline void timer_interrupt(int irq, struct pt_regs *regs)
  5735.  {
  5736. -    do_timer(regs);
  5737. +    do_timer(regs);
  5738.  
  5739. -    /* If we have an externally synchronized linux clock, then update
  5740. -     * CMOS clock accordingly every ~11 minutes.  Set_rtc_mmss() has to be
  5741. -     * called as close as possible to 500 ms before the new second starts.
  5742. -     */
  5743. -    if (time_state != TIME_BAD && xtime.tv_sec > last_rtc_update + 660 &&
  5744. +    /* If we have an externally synchronized linux clock, then update
  5745. +     * CMOS clock accordingly every ~11 minutes.  Set_rtc_mmss() has to be
  5746. +     * called as close as possible to 500 ms before the new second starts.
  5747. +     */
  5748. +    if (time_state != TIME_BAD && xtime.tv_sec > last_rtc_update + 660 &&
  5749.          xtime.tv_usec > 50000 - (tick >> 1) &&
  5750. -        xtime.tv_usec < 50000 + (tick >> 1))
  5751. -      if (set_rtc_mmss(xtime.tv_sec) == 0)
  5752. +        xtime.tv_usec < 50000 + (tick >> 1)) {
  5753. +    if (set_rtc_mmss(xtime.tv_sec) == 0)
  5754.          last_rtc_update = xtime.tv_sec;
  5755. -      else
  5756. +    else
  5757.          last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
  5758. +    }
  5759.  }
  5760.  
  5761.  /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
  5762. @@ -130,11 +130,11 @@
  5763.      unsigned int day, unsigned int hour,
  5764.      unsigned int min, unsigned int sec)
  5765.  {
  5766. -    if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
  5767. -        mon += 12;    /* Puts Feb last since it has leap day */
  5768. -        year -= 1;
  5769. -    }
  5770. -    return (((
  5771. +    if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
  5772. +    mon += 12;    /* Puts Feb last since it has leap day */
  5773. +    year -= 1;
  5774. +    }
  5775. +    return (((
  5776.          (unsigned long)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
  5777.            year*365 - 719499
  5778.          )*24 + hour /* now have hours */
  5779. @@ -144,30 +144,30 @@
  5780.  
  5781.  void time_init(void)
  5782.  {
  5783. -    unsigned int year, mon, day, hour, min, sec;
  5784. -    char buf[8];
  5785. -    extern int iic_control(unsigned char, int, char *, int);
  5786. -
  5787. -    iic_control(0xa0, 2, buf, 5);
  5788. -    sec = buf[0];
  5789. -    min = buf[1];
  5790. -    hour= buf[2];
  5791. -    day = buf[3] & 0x3f;
  5792. -    mon = buf[4] & 0x1f;
  5793. -    iic_control(0xa0, 0xc0, buf, 1);
  5794. -    year= buf[0];
  5795. -    BCD_TO_BIN(sec);
  5796. -    BCD_TO_BIN(min);
  5797. -    BCD_TO_BIN(hour);
  5798. -    BCD_TO_BIN(day);
  5799. -    BCD_TO_BIN(mon);
  5800. -
  5801. -    if ((year += 1900) < 1970)
  5802. -        year += 100;
  5803. -    xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  5804. -    xtime.tv_usec = 0;
  5805. +    unsigned int year, mon, day, hour, min, sec;
  5806. +    char buf[8];
  5807. +    extern int iic_control(unsigned char, int, char *, int);
  5808. +
  5809. +    iic_control(0xa0, 2, buf, 5);
  5810. +    sec = buf[0];
  5811. +    min = buf[1];
  5812. +    hour= buf[2];
  5813. +    day = buf[3] & 0x3f;
  5814. +    mon = buf[4] & 0x1f;
  5815. +    iic_control(0xa0, 0xc0, buf, 1);
  5816. +    year= buf[0];
  5817. +    BCD_TO_BIN(sec);
  5818. +    BCD_TO_BIN(min);
  5819. +    BCD_TO_BIN(hour);
  5820. +    BCD_TO_BIN(day);
  5821. +    BCD_TO_BIN(mon);
  5822. +
  5823. +    if ((year += 1900) < 1970)
  5824. +    year += 100;
  5825. +    xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
  5826. +    xtime.tv_usec = 0;
  5827.  
  5828. -    if (request_irq(TIMER_IRQ, timer_interrupt, 0, "timer") != 0)
  5829. -        panic("Could not allocate timer IRQ!");
  5830. +    if (request_irq(IRQ_TIMER0, timer_interrupt, 0, "timer") != 0)
  5831. +    panic("Could not allocate timer IRQ!");
  5832.  }
  5833.  
  5834. diff -urN linux.store/linux/arch/arm/lib/Makefile linux/arch/arm/lib/Makefile
  5835. --- linux.store/linux/arch/arm/lib/Makefile    Sun Feb 11 09:32:40 1996
  5836. +++ linux/arch/arm/lib/Makefile    Tue Mar 12 13:36:52 1996
  5837. @@ -1,8 +1,22 @@
  5838. +#
  5839. +# linux/arch/arm/lib/Makefile
  5840. +#
  5841. +# Copyright (C) 1995, 1996 Russell King
  5842. +#
  5843. +
  5844.  O_TARGET := lib.o
  5845.  O_OBJS   := backtrace.o bitops.o delay.o irqs.o \
  5846.      ll_char_wr.o io.o segment.o system.o traps.o ioc.o \
  5847.      calls.o prints.o memfastset.o fp_support.o string.o \
  5848.      floppydma.o
  5849. +
  5850. +ifdef CONFIG_BLK_DEV_FD1772
  5851. +O_OBJS += fd1772.o
  5852. +endif
  5853. +
  5854. +ifdef CONFIG_BLK_DEV_XD
  5855. +O_OBJS += mfm.o
  5856. +endif
  5857.  
  5858.  ifdef CONFIG_INET
  5859.  O_OBJS += iputils.o
  5860. diff -urN linux.store/linux/arch/arm/lib/constants.h.sample linux/arch/arm/lib/constants.h.sample
  5861. --- linux.store/linux/arch/arm/lib/constants.h.sample    Thu Jan  1 01:00:00 1970
  5862. +++ linux/arch/arm/lib/constants.h.sample    Tue Mar  5 14:57:16 1996
  5863. @@ -0,0 +1,20 @@
  5864. +/*
  5865. + *  contants.h generated by getconstants
  5866. + * DO NOT EDIT!
  5867. + */
  5868. +#define _current    _current_set
  5869. +#define PAGE_PRESENT    1
  5870. +#define PAGE_RW    2
  5871. +#define PAGE_USER    4
  5872. +#define PAGE_ACCESSED    32
  5873. +#define PAGE_DIRTY    64
  5874. +#define TSK_MM    744
  5875. +#define MM_PGDIR    4
  5876. +#define TSS_UREGS    512
  5877. +#define TSS_SREGS    532
  5878. +#define TSS_FPESAVE    576
  5879. +#define SYS_execve    9437195
  5880. +#define SYS_sigreturn    9437303
  5881. +#define KSWI_BASE    0x900000
  5882. +#define KSWI_SYS_BASE    0x9F0000
  5883. +#define SYS_ERROR0    0x9F0000
  5884. diff -urN linux.store/linux/arch/arm/lib/fd1772.S linux/arch/arm/lib/fd1772.S
  5885. --- linux.store/linux/arch/arm/lib/fd1772.S    Thu Jan  1 01:00:00 1970
  5886. +++ linux/arch/arm/lib/fd1772.S    Mon Mar 11 23:02:11 1996
  5887. @@ -0,0 +1,98 @@
  5888. +@ Code for DMA with the 1772 fdc
  5889. +.text
  5890. +
  5891. +
  5892. +_fdc1772_fiqdata:
  5893. +@ Number of bytes left to DMA
  5894. +  .global _fdc1772_bytestogo
  5895. +_fdc1772_bytestogo:
  5896. +  .word 0
  5897. +@ Place to put/get data from in DMA
  5898. +  .global _fdc1772_dataaddr
  5899. +_fdc1772_dataaddr:
  5900. +  .word 0
  5901. +  
  5902. +  .global _fdc1772_fdc_int_done
  5903. +_fdc1772_fdc_int_done:
  5904. +  .word 0
  5905. +  .global _fdc1772_comendstatus
  5906. +_fdc1772_comendstatus:
  5907. +  .word 0
  5908. +
  5909. +@ We hang this off DMA channel 1
  5910. +    .global _fdc1772_comendhandler
  5911. +_fdc1772_comendhandler:
  5912. +  mov      r8,#0x3200000
  5913. +  ldrb     r9,[r8,#0x34]    @ IOC FIQ status
  5914. +  tst      r9,#2
  5915. +  subeqs   pc,r14,#4
  5916. +  mov      r9,#0x3200000
  5917. +  orr      r9,r9,#0x10000   @ FDC base
  5918. +  adr      r8,_fdc1772_fdc_int_done
  5919. +  ldrb     r10,[r9,#0]  @ FDC status
  5920. +  mov      r9,#1        @ Got a FIQ flag
  5921. +  stmia    r8,{r9,r10}
  5922. +  subs     pc,r14,#4
  5923. +
  5924. +
  5925. +    .global _fdc1772_dma_read
  5926. +_fdc1772_dma_read:
  5927. +  mov      r8,#0x3200000
  5928. +  ldrb     r9,[r8,#0x34]    @ IOC FIQ status
  5929. +  tst      r9,#1
  5930. +  beq      _fdc1772_dma_read_notours
  5931. +  orr      r8,r8,#0x10000   @ FDC base
  5932. +  ldrb     r10,[r8,#0xc]   @ Read from FDC data reg (also clears interrupt)
  5933. +  ldmia    r11,{r8,r9}
  5934. +  subs     r8,r8,#1        @ One less byte to go
  5935. +  @ If there was somewhere for this data to go then store it and update pointers
  5936. +  strplb   r10,[r9],#1     @ Store the data and increment the pointer
  5937. +  stmplia  r11,{r8,r9}     @ Update count/pointers
  5938. +  @ Handle any other interrupts if there are any
  5939. +_fdc1772_dma_read_notours:
  5940. +  @ Cant branch because this code has been copied down to the FIQ vector
  5941. +  ldr pc,[pc,#-4]
  5942. +  .word _fdc1772_comendhandler
  5943. +  .global _fdc1772_dma_read_end
  5944. +_fdc1772_dma_read_end:
  5945. +
  5946. +    .global _fdc1772_dma_write
  5947. +_fdc1772_dma_write:
  5948. +  mov      r8,#0x3200000
  5949. +  ldrb     r9,[r8,#0x34]    @ IOC FIQ status
  5950. +  tst      r9,#1
  5951. +  beq      _fdc1772_dma_write_notours
  5952. +  orr      r8,r8,#0x10000   @ FDC base
  5953. +  ldmia    r11,{r9,r10}
  5954. +  subs     r9,r9,#1        @ One less byte to go
  5955. +  @ If there really is some data then get it, store it and update count
  5956. +  ldrplb   r12,[r10],#1
  5957. +  strplb   r12,[r8,#0xc]   @ write it to FDC data reg
  5958. +  stmplia  r11,{r9,r10}    @ Update count and pointer - should clear interrupt
  5959. +  @ Handle any other interrupts
  5960. +_fdc1772_dma_write_notours:
  5961. +  @ Cant branch because this code has been copied down to the FIQ vector
  5962. +  ldr pc,[pc,#-4]
  5963. +  .word _fdc1772_comendhandler
  5964. +
  5965. +  .global _fdc1772_dma_write_end
  5966. +_fdc1772_dma_write_end:
  5967. +  
  5968. +
  5969. +@ Setup the FIQ R11 to point to the data and store the count, address
  5970. +@ for this dma
  5971. +@ R0=count
  5972. +@ R1=address
  5973. +  .global _fdc1772_setupdma
  5974. +_fdc1772_setupdma:
  5975. +    @ The big job is flipping in and out of FIQ mode
  5976. +    adr    r2,_fdc1772_fiqdata    @ This is what we really came here for
  5977. +  stmia  r2,{r0,r1}
  5978. +    mov    r3, pc
  5979. +    teqp    pc,#0x0c000001    @ Disable FIQs, IRQs and switch to FIQ mode
  5980. +    mov    r0,r0          @ NOP
  5981. +    mov r11,r2
  5982. +    teqp    r3,#0        @ Normal mode
  5983. +    mov    r0,r0        @ NOP
  5984. +  mov pc,r14
  5985. +
  5986. diff -urN linux.store/linux/arch/arm/lib/floppydma.S linux/arch/arm/lib/floppydma.S
  5987. --- linux.store/linux/arch/arm/lib/floppydma.S    Sun Mar  3 13:11:49 1996
  5988. +++ linux/arch/arm/lib/floppydma.S    Tue Mar 12 13:40:31 1996
  5989. @@ -35,6 +35,7 @@
  5990.  @ r0 = length
  5991.  @ r1 = address
  5992.  @ r2 = floppy port
  5993. +@ Puts these into R9_fiq, R10_fiq, R11_fiq
  5994.          .global    _floppy_fiqsetup
  5995.  _floppy_fiqsetup:
  5996.          mov    ip, sp
  5997. diff -urN linux.store/linux/arch/arm/lib/io.S linux/arch/arm/lib/io.S
  5998. --- linux.store/linux/arch/arm/lib/io.S    Sun Mar  3 13:13:17 1996
  5999. +++ linux/arch/arm/lib/io.S    Fri Mar  8 22:27:50 1996
  6000. @@ -6,6 +6,7 @@
  6001.  
  6002.  #include <asm/assembler.h>
  6003.          .text
  6004. +        .align
  6005.  
  6006.  #define OUT(reg)                    \
  6007.          mov    r8, reg, lsl \#16        ;\
  6008. @@ -24,8 +25,6 @@
  6009.  @ purpose: read a byte from a hardware register.
  6010.  @ Proto  : unsigned char inb(int address);
  6011.  
  6012. -        .align
  6013. -
  6014.          .global    ___inb
  6015.          .global    ___inb_p
  6016.          .global    ___inbc
  6017. @@ -44,8 +43,6 @@
  6018.  @ purpose: read a short word from a hardware register.
  6019.  @ Proto  : unsigned char inw(int address);
  6020.  
  6021. -        .align
  6022. -
  6023.          .global    ___inw
  6024.  ___inw:        cmp    r0, #0x00c00000
  6025.          movge    r2, #0
  6026. @@ -59,8 +56,6 @@
  6027.  @ Purpose: write a byte to a hardware register.
  6028.  @ Proto  : outb(unsigned char c,int address);
  6029.  
  6030. -        .align
  6031. -
  6032.          .global    ___outb
  6033.          .global    ___outb_p
  6034.          .global    ___outbc
  6035. @@ -79,8 +74,6 @@
  6036.  @ Purpose: write a short to a hardware register.
  6037.  @ Proto  : outw(unsigned short c,int address);
  6038.  
  6039. -        .align
  6040. -
  6041.          .global    ___outw
  6042.  ___outw:    cmp    r1, #0x00c00000
  6043.          movge    r2, #0
  6044. @@ -95,8 +88,6 @@
  6045.  @ Proto  : inswb(int from_port, void *to, int len_in_bytes);
  6046.  @ Notes  : increment to
  6047.  
  6048. -        .align
  6049. -
  6050.          .global    _insw
  6051.          .global    _inswb
  6052.  _insw:        mov    r2, r2, lsl#1
  6053. @@ -175,8 +166,6 @@
  6054.  @ Proto  : outswb(int to_reg, void *from, int len_in_bytes);
  6055.  @ Notes  : increments from
  6056.  
  6057. -        .align
  6058. -
  6059.          .global    _outsw
  6060.          .global    _outswb
  6061.  _outsw:        mov    r2, r2, LSL#1
  6062. @@ -225,8 +214,6 @@
  6063.  @ Proto  : void vidc_write(int register, int value);
  6064.  @ Returns: nothing
  6065.  
  6066. -        .align
  6067. -
  6068.          .global    _vidc_write
  6069.  _vidc_write:    bic    r1, r1, #0xFF000000
  6070.          orr    r0, r1, r0, lsl #24
  6071. @@ -238,8 +225,6 @@
  6072.  @ Proto  : void memc_write(int register, int value);
  6073.  @ Returns: nothing
  6074.  
  6075. -        .align
  6076. -
  6077.          .global    _memc_write
  6078.  _memc_write:    cmp    r0, #7
  6079.          RETINSTR(movgt,pc,lr)
  6080. @@ -252,26 +237,26 @@
  6081.          RETINSTR(mov,pc,lr)
  6082.  
  6083.  @ Purpose: call an expansion card loader to read bytes.
  6084. -@ Proto  : int read_loader(int offset, int card_base, int *loader);
  6085. +@ Proto  : char read_loader(int offset, char *card_base, char *loader);
  6086.  @ Returns: byte read
  6087.  
  6088. -        .align
  6089. -
  6090. -        .global    _read_loader
  6091. -_read_loader:    stmfd    sp!, {r4 - r12, lr}
  6092. +        .global    _ecard_loader_read
  6093. +_ecard_loader_read:
  6094. +        stmfd    sp!, {r4 - r12, lr}
  6095.          mov    r11, r1
  6096.          mov    r1, r0
  6097.          mov    lr, pc
  6098.          mov    pc, r2
  6099.          LOADREGS(fd, sp!, {r4 - r12, pc})
  6100.  
  6101. -        .align
  6102. -msgg:
  6103. -        .ascii    "%08X  "
  6104. -        .align
  6105. +@ Purpose: call an expansion card loader to reset the card
  6106. +@ Proto  : void read_loader(int card_base, char *loader);
  6107. +@ Returns: byte read
  6108.  
  6109. -show:        stmfd    sp!, {r0-r12, lr}
  6110. -        mov    r1, r8
  6111. -        adr    r0, msgg
  6112. -        bl    _printk
  6113. -        LOADREGS(fd, sp!, {r0-r12, pc})
  6114. +        .global    _ecard_loader_reset
  6115. +_ecard_loader_reset:
  6116. +        stmfd    sp!, {r4 - r12, lr}
  6117. +        mov    r11, r0
  6118. +        mov    lr, pc
  6119. +        add    pc, r1, #8
  6120. +        LOADREGS(fd, sp!, {r4 - r12, pc})
  6121. diff -urN linux.store/linux/arch/arm/lib/ll_char_wr.S linux/arch/arm/lib/ll_char_wr.S
  6122. --- linux.store/linux/arch/arm/lib/ll_char_wr.S    Sun Mar  3 13:15:26 1996
  6123. +++ linux/arch/arm/lib/ll_char_wr.S    Sun Mar 10 16:31:30 1996
  6124. @@ -7,7 +7,7 @@
  6125.  #include <asm/assembler.h>
  6126.          .text
  6127.  
  6128. -        .global    _ll_char_write
  6129. +        .global    _ll_write_char
  6130.  
  6131.  #define BOLD            0x01
  6132.  #define ITALIC          0x02
  6133. @@ -15,41 +15,44 @@
  6134.  #define FLASH           0x08
  6135.  #define INVERSE         0x10
  6136.  
  6137. -@ r4 = flags
  6138. -@ r3 = backc
  6139. -@ r2 = forec
  6140. -@ r1 = ch
  6141. -@ r0 = ps
  6142. -
  6143.  LC0:
  6144.          .word    _bytes_per_char_h
  6145.          .word    _video_num_columns
  6146.          .word    _cmap_80
  6147.  
  6148. -_ll_char_write:
  6149. -        subs    r1, r1, #32
  6150. -        movlt    r1, #0
  6151. -        cmp    r1, #126-32
  6152. -        RETINSTR(movgt,pc,lr)
  6153. +_ll_write_char:
  6154.          mov    ip, sp
  6155.          stmfd    sp!, {r4 - r9, fp, ip, lr, pc}
  6156.          sub    fp, ip, #4
  6157. -@ do inverse stuff
  6158. -        ldr    r4, [fp, #4]        @ get flags
  6159. -        eor    r4, r4, #UNDERLINE
  6160. -        tst    r4, #INVERSE
  6161. -        movne    r5, r3
  6162. -        movne    r3, r2
  6163. -        movne    r2, r5
  6164. -        tst    r4, #BOLD
  6165. +        eor    r4, r1, #UNDERLINE << 24
  6166. +/*
  6167. + * calculate colours
  6168. + */
  6169. +        tst    r1, #INVERSE << 24
  6170. +        moveq    r2, r1, lsr #8
  6171. +        moveq    r3, r1, lsr #16
  6172. +        movne    r2, r1, lsr #16
  6173. +        movne    r3, r1, lsr #8
  6174. +        tst    r1, #BOLD << 24
  6175.          orrne    r2, r2, #8
  6176. -@ compute the offset required for each row
  6177. -        ldr    r5, [pc, #LC0 - . - 8]
  6178. -        ldrb    r5, [r5]
  6179. -        ldr    r6, [pc, #LC0 - . - 4]
  6180. -        ldrb    r6, [r6]
  6181. +        and    r3, r3, #255
  6182. +        and    r2, r2, #255
  6183. +/*
  6184. + * calculate offset into character table
  6185. + */
  6186. +        and    r1, r1, #255
  6187. +        subs    r1, r1, #32
  6188. +        movlt    r1, #0
  6189. +        cmp    r1, #126 - 32
  6190. +        movgt    r1, #0
  6191. +/*
  6192. + * calculate offset required for each row
  6193. + */
  6194. +        adr    r5, LC0
  6195. +        ldmia    r5, {r5, r6, r7}
  6196. +        ldr    r5, [r5]
  6197. +        ldr    r6, [r6]
  6198.          mul    r6, r5, r6
  6199. -        ldr    r7, [pc, #LC0 - .]
  6200.          mov    r1, r1, lsl #3
  6201.          teq    r5, #8
  6202.          beq    row8bpplp
  6203. @@ -57,7 +60,7 @@
  6204.          ldrb    r9, [r7, r1]
  6205.          and    r8, r1, #7
  6206.          teq    r8, #7
  6207. -        tsteq    r4, #UNDERLINE
  6208. +        tsteq    r4, #UNDERLINE << 24
  6209.          mvneq    r9, r9
  6210.          sub    r8, r5, #1
  6211.          mov    ip, #0
  6212. @@ -85,7 +88,7 @@
  6213.          tst    r9, #1<<0
  6214.          orreq    ip, ip, r3, lsl#28
  6215.          orrne    ip, ip, r2, lsl#28
  6216. -        str    ip, [r0],r6
  6217. +        str    ip, [r0], r6
  6218.          add    r1, r1,#1
  6219.          tst    r1, #7
  6220.          bne    row4bpplp
  6221. @@ -94,7 +97,7 @@
  6222.  row8bpplp:    ldrb    r9, [r7, r1]
  6223.          and    r8, r1, #7
  6224.          teq    r8, #7
  6225. -        tsteq    r4, #UNDERLINE
  6226. +        tsteq    r4, #UNDERLINE << 24
  6227.          mvneq    r9, r9
  6228.          tst    r9, #1<<7
  6229.          moveq    r5, r3
  6230. diff -urN linux.store/linux/arch/arm/lib/mfm.S linux/arch/arm/lib/mfm.S
  6231. --- linux.store/linux/arch/arm/lib/mfm.S    Thu Jan  1 01:00:00 1970
  6232. +++ linux/arch/arm/lib/mfm.S    Mon Mar 11 23:02:11 1996
  6233. @@ -0,0 +1,118 @@
  6234. +@ Read/Write DMA code for the ST506/MFM hard drive controllers on the A400
  6235. +@   motherboard on ST506 podules.
  6236. +@ (c) David Alan Gilbert (gilbertd@cs.man.ac.uk) 1996
  6237. +
  6238. +#include <asm/assembler.h>
  6239. + 
  6240. +_hdc63463_irqdata:
  6241. +@ Controller base address
  6242. +  .global _hdc63463_baseaddress
  6243. +_hdc63463_baseaddress:
  6244. +  .word 0
  6245. +
  6246. +  .global _hdc63463_irqpolladdress
  6247. +_hdc63463_irqpolladdress:
  6248. +  .word 0
  6249. + 
  6250. +  .global _hdc63463_irqpollmask
  6251. +_hdc63463_irqpollmask:
  6252. +  .word 0
  6253. +
  6254. +@ where to read/write data  from the kernel data space
  6255. +  .global _hdc63463_dataptr
  6256. +_hdc63463_dataptr:
  6257. +  .word 0
  6258. +
  6259. +@ Number of bytes left to transfer
  6260. +  .global _hdc63463_dataleft
  6261. +_hdc63463_dataleft:
  6262. +  .word 0
  6263. +
  6264. +@ -------------------------------------------------------------------------
  6265. +@ hdc63463_writedma: DMA from host to controller
  6266. +@  internal reg usage: r0=hdc base address, r1=irq poll address, r2=poll mask
  6267. +@                      r3=data ptr, r4=data left, r5,r6=temporary
  6268. +  .global _hdc63463_writedma
  6269. +_hdc63463_writedma:
  6270. +  stmfd sp!,{r4-r9}
  6271. +  adr r5,_hdc63463_irqdata
  6272. +  ldmia r5,{r0,r1,r2,r3,r4}
  6273. +
  6274. +writedma_loop:
  6275. +  @ test number of remaining bytes to transfer
  6276. +  cmp r4,#0
  6277. +  beq writedma_end
  6278. +  bmi writedma_end
  6279. +
  6280. +  @ Check the hdc is interrupting
  6281. +  ldrb r5,[r1,#0]
  6282. +  tst r5,r2
  6283. +  beq writedma_end
  6284. +
  6285. +  @ Check the hdc is still busy and command has not ended and no errors
  6286. +  ldr r5,[r0,#32]     @ Status reg - 16 bit - its the top few bits which are status
  6287. +  tst r5,#0x3c00        @ Test for things which should be off
  6288. +  bne writedma_end
  6289. +  and r5,r5,#0x8000        @ This is test for things which should be on: Busy
  6290. +  cmp r5,#0x8000
  6291. +  bne writedma_end 
  6292. +
  6293. +  @ OK - pretty sure we should be doing this
  6294. +  @ Get two bytes - note it can be half word aligned; its easiest to read 2 bytes
  6295. +  ldrb r6,[r3],#1
  6296. +  ldrb r5,[r3],#1
  6297. +  orr  r6,r6,r5,lsl#8  @ Put them together, note big endian for HDC
  6298. +  orr  r6,r6,r6,lsl#16    @ Both halves of word for podule write
  6299. +  str  r6,[r0,#32+8]      @ Put the data out
  6300. +  subs r4,r4,#2        @ Decrement bytes to go
  6301. +  b writedma_loop
  6302. +
  6303. +writedma_end:
  6304. +  adr r5,_hdc63463_irqdata+12
  6305. +  stmia r5,{r3,r4}
  6306. +  ldmfd sp!,{r4-r9}
  6307. +  RETINSTR(mov,pc,lr)
  6308. +
  6309. +@ -------------------------------------------------------------------------
  6310. +@ hdc63463_readdma: DMA from controller to host
  6311. +@  internal reg usage: r0=hdc base address, r1=irq poll address, r2=poll mask
  6312. +@                      r3=data ptr, r4=data left, r5,r6=temporary
  6313. +  .global _hdc63463_readdma
  6314. +_hdc63463_readdma:
  6315. +  stmfd sp!,{r4-r9}
  6316. +  adr r5,_hdc63463_irqdata
  6317. +  ldmia r5,{r0,r1,r2,r3,r4}
  6318. +
  6319. +readdma_loop:
  6320. +  @ test number of remaining bytes to transfer
  6321. +  cmp r4,#0
  6322. +  beq readdma_end
  6323. +  bmi readdma_end
  6324. +
  6325. +  @ Check the hdc is interrupting
  6326. +  ldrb r5,[r1,#0]
  6327. +  tst r5,r2
  6328. +  beq readdma_end
  6329. +
  6330. +  @ Check the hdc is still busy and command has not ended and no errors
  6331. +  ldr r5,[r0,#32]     @ Status reg - 16 bit - its the top few bits which are status
  6332. +  tst r5,#0x3c00      @ Test for things which should be off
  6333. +  bne readdma_end
  6334. +  and r5,r5,#0x8000        @ This is test for things which should be on: Busy
  6335. +  cmp r5,#0x8000
  6336. +  bne readdma_end 
  6337. +
  6338. +  @ OK - pretty sure we should be doing this
  6339. +  @ Get two bytes - note it can be half word aligned; its easiest to read 2 bytes
  6340. +  ldr  r6,[r0,#8]     @ Read data from hdc - its in the bottom half
  6341. +  mov  r5,r6,lsr#8     @ Move second byte to bottom
  6342. +  strb r6,[r3],#1      @ Note endian swap in here
  6343. +  strb r5,[r3],#1
  6344. +  subs r4,r4,#2        @ Decrement bytes to go
  6345. +  b readdma_loop
  6346. +
  6347. +readdma_end:
  6348. +  adr r5,_hdc63463_irqdata+12
  6349. +  stmia r5,{r3,r4}
  6350. +  ldmfd sp!,{r4-r9}
  6351. +  RETINSTR(mov,pc,lr)
  6352. diff -urN linux.store/linux/arch/arm/mm/fault.c linux/arch/arm/mm/fault.c
  6353. --- linux.store/linux/arch/arm/mm/fault.c    Sun Mar  3 13:08:26 1996
  6354. +++ linux/arch/arm/mm/fault.c    Sun Mar 10 14:34:32 1996
  6355. @@ -176,81 +176,79 @@
  6356.   */
  6357.  asmlinkage int do_dataabort (unsigned long min_addr, unsigned long max_addr, int mode, unsigned long *regs)
  6358.  {
  6359. -    unsigned long error_code;
  6360. -    int done = 0;
  6361. -    pte_t *pte;
  6362. +    unsigned long error_code;
  6363. +    int done = 0;
  6364. +    pte_t *pte;
  6365.  
  6366. -    IDEBUG(debug (min_addr, max_addr, mode, regs));
  6367. +    IDEBUG(debug (min_addr, max_addr, mode, regs));
  6368.      
  6369. -    if ((min_addr >= LOGICAL_END || max_addr >= LOGICAL_END) && (mode & 3) == 0)
  6370. -    {
  6371. -        send_sig (SIGSEGV, current, 1);
  6372. -        return 1;
  6373. -    }
  6374. +    if ((min_addr >= LOGICAL_END || max_addr >= LOGICAL_END) && (mode & 3) == 0) {
  6375. +    send_sig (SIGSEGV, current, 1);
  6376. +    return 1;
  6377. +    }
  6378.      
  6379. -    error_code = ((mode & 0x20) ? _PAGE_RW : 0) | ((mode & 3) ? 0 : _PAGE_USER);
  6380. +    error_code = ((mode & 0x20) ? _PAGE_RW : 0) | ((mode & 3) ? 0 : _PAGE_USER);
  6381.  
  6382. -    pte = pte_offset (pmd_offset (pgd_offset (current->mm, min_addr), min_addr), min_addr);
  6383. +    pte = pte_offset (pmd_offset (pgd_offset (current->mm, min_addr), min_addr), min_addr);
  6384.  
  6385. -    if (pte_present(*pte)) {
  6386. -        if ((error_code & _PAGE_USER) && !pte_read(*pte)) {
  6387. -            printk("Process (%s, %d) tried to access reserved mem %08lx mode %d (pc=%08lx, lr=%08lx)\n",
  6388. -                current->comm, current->pid, min_addr, mode, regs[15], regs[14]);
  6389. -            send_sig(SIGSEGV, current, 1);
  6390. -            return 1;
  6391. -        }
  6392. -
  6393. -        if ((mode & 0x700)==0x100 && pte_young(*pte)) {
  6394. -            printk("Page %08lx (%08lx) in but got abort (pc=%08lx) - undefined instr\n",
  6395. -                min_addr, pte_val(*pte), regs[15]);
  6396. -            return 0;
  6397. -        }
  6398. -
  6399. -        if (!pte_young (*pte)) {
  6400. -            *pte = pte_mkyoung (*pte);
  6401. -            done = 1;
  6402. -        }
  6403. -
  6404. -        if ((error_code & _PAGE_RW) && pte_write(*pte) && !pte_dirty (*pte)) {
  6405. -            *pte = pte_mkdirty (*pte);
  6406. -            done = 1;
  6407. -        }
  6408. -
  6409. -        if (done) {
  6410. -            invalidate ();
  6411. -            return 1;
  6412. -        }
  6413. +    if (pte_present(*pte)) {
  6414. +    if ((error_code & _PAGE_USER) && !pte_read(*pte)) {
  6415. +        printk("Process (%s, %d) tried to access reserved mem %08lx mode %d (pc=%08lx, lr=%08lx)\n",
  6416. +            current->comm, current->pid, min_addr, mode, regs[15], regs[14]);
  6417. +        send_sig(SIGSEGV, current, 1);
  6418. +        return 1;
  6419. +    }
  6420.  
  6421. -        error_code |= _PAGE_PRESENT;
  6422. +    if ((mode & 0x700)==0x100 && pte_young(*pte)) {
  6423. +        printk("Page %08lx (%08lx) in but got abort (pc=%08lx) - undefined instr\n",
  6424. +            min_addr, pte_val(*pte), regs[15]);
  6425. +        return 0;
  6426.      }
  6427.  
  6428. -    do_page_fault1(min_addr, error_code, (struct pt_regs *)regs);
  6429. +    if (!pte_young (*pte)) {
  6430. +        *pte = pte_mkyoung (*pte);
  6431. +       done = 1;
  6432. +    }
  6433.  
  6434. -    if ((min_addr ^ max_addr) >> PAGE_SHIFT) {
  6435. -        pte = pte_offset (pmd_offset (pgd_offset (current->mm, max_addr), max_addr), max_addr);
  6436. -        if (pte_present (*pte)) {
  6437. -            if (!pte_young (*pte)) {
  6438. -                *pte = pte_mkyoung (*pte);
  6439. -                done = 1;
  6440. -            }
  6441. -
  6442. -            if ((error_code & _PAGE_RW) && pte_write(*pte) && !pte_dirty (*pte)) {
  6443. -                *pte = pte_mkdirty (*pte);
  6444. -                done = 1;
  6445. -            }
  6446. -
  6447. -            if (done) {
  6448. -                invalidate ();
  6449. -                return 1;
  6450. -            }
  6451. -
  6452. -            error_code |= _PAGE_PRESENT;
  6453. -        }
  6454. -        else
  6455. -            error_code &= ~_PAGE_PRESENT;
  6456. -        do_page_fault1(max_addr, error_code, (struct pt_regs *)regs);
  6457. +    if ((error_code & _PAGE_RW) && pte_write(*pte) && !pte_dirty (*pte)) {
  6458. +        *pte = pte_mkdirty (*pte);
  6459. +        done = 1;
  6460.      }
  6461.  
  6462. -    invalidate();
  6463. -    return 1;
  6464. +    if (done) {
  6465. +        invalidate ();
  6466. +        return 1;
  6467. +    }
  6468. +
  6469. +    error_code |= _PAGE_PRESENT;
  6470. +    }
  6471. +
  6472. +    do_page_fault1(min_addr, error_code, (struct pt_regs *)regs);
  6473. +
  6474. +    if ((min_addr ^ max_addr) >> PAGE_SHIFT) {
  6475. +    pte = pte_offset (pmd_offset (pgd_offset (current->mm, max_addr), max_addr), max_addr);
  6476. +    if (pte_present (*pte)) {
  6477. +        if (!pte_young (*pte)) {
  6478. +        *pte = pte_mkyoung (*pte);
  6479. +        done = 1;
  6480. +        }
  6481. +
  6482. +        if ((error_code & _PAGE_RW) && pte_write(*pte) && !pte_dirty (*pte)) {
  6483. +        *pte = pte_mkdirty (*pte);
  6484. +        done = 1;
  6485. +        }
  6486. +
  6487. +        if (done) {
  6488. +        invalidate ();
  6489. +        return 1;
  6490. +        }
  6491. +
  6492. +        error_code |= _PAGE_PRESENT;
  6493. +    } else
  6494. +        error_code &= ~_PAGE_PRESENT;
  6495. +        do_page_fault1(max_addr, error_code, (struct pt_regs *)regs);
  6496. +    }
  6497. +
  6498. +    invalidate();
  6499. +    return 1;
  6500.  }
  6501. diff -urN linux.store/linux/arch/arm/mm/init.c linux/arch/arm/mm/init.c
  6502. --- linux.store/linux/arch/arm/mm/init.c    Sun Mar  3 13:08:36 1996
  6503. +++ linux/arch/arm/mm/init.c    Sun Mar 10 14:32:18 1996
  6504. @@ -27,8 +27,8 @@
  6505.  
  6506.  unsigned long low_memory;
  6507.  int page_nr    = 256;
  6508. -pgd_t swapper_pg_dir[1024];
  6509.  int page_shift = 15;
  6510. +pgd_t swapper_pg_dir[1024];
  6511.  
  6512.  extern void memfastset (void *, unsigned long n, size_t l);
  6513.  
  6514. @@ -45,58 +45,45 @@
  6515.   * ZERO_PAGE is a special page that is used for zero-initialized
  6516.   * data and COW.
  6517.   */
  6518. -#if 0
  6519. -pte_t * __bad_pagetable(void)
  6520. -{
  6521. -    extern char empty_bad_page_table[PAGE_SIZE];
  6522. -
  6523. -    __asm__ __volatile__("cld ; rep ; stosl":
  6524. -        :"a" (pte_val(BAD_PAGE)),
  6525. -         "D" ((long) empty_bad_page_table),
  6526. -         "c" (PAGE_SIZE/4)
  6527. -        :"di","cx");
  6528. -    return (pte_t *) empty_bad_page_table;
  6529. -}
  6530. -#endif
  6531.  char *empty_bad_page;
  6532.  pte_t __bad_page(void)
  6533.  {
  6534. -        memfastset(empty_bad_page, 0, PAGE_SIZE);
  6535. -    return pte_mkdirty(mk_pte((unsigned long) empty_bad_page, PAGE_SHARED));
  6536. +    memfastset(empty_bad_page, 0, PAGE_SIZE);
  6537. +    return pte_mkdirty(mk_pte((unsigned long) empty_bad_page, PAGE_SHARED));
  6538.  }
  6539.  
  6540.  char *empty_zero_page;
  6541.  unsigned long __zero_page(void)
  6542.  {
  6543. -        memfastset(empty_zero_page, 0, PAGE_SIZE);
  6544. -    return (unsigned long) empty_zero_page;
  6545. +    memfastset(empty_zero_page, 0, PAGE_SIZE);
  6546. +    return (unsigned long) empty_zero_page;
  6547.  }
  6548.  
  6549.  void show_mem(void)
  6550.  {
  6551. -    int i,free = 0,total = 0,reserved = 0;
  6552. -    int shared = 0;
  6553. +    int i,free = 0,total = 0,reserved = 0;
  6554. +    int shared = 0;
  6555.  
  6556. -    printk("Mem-info:\n");
  6557. -    show_free_areas();
  6558. -    printk("Free swap:       %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
  6559. -    i = (high_memory - PAGE_OFFSET) >> PAGE_SHIFT;
  6560. -    while (i-- > 0) {
  6561. -        total++;
  6562. -        if (mem_map[i].reserved)
  6563. -            reserved++;
  6564. -        else if (!mem_map[i].count)
  6565. -            free++;
  6566. -        else
  6567. -            shared += mem_map[i].count-1;
  6568. -    }
  6569. -    printk("%d pages of RAM\n",total);
  6570. -    printk("%d free pages\n",free);
  6571. -    printk("%d reserved pages\n",reserved);
  6572. -    printk("%d pages shared\n",shared);
  6573. -    show_buffers();
  6574. +    printk ("Mem-info:\n");
  6575. +    show_free_areas();
  6576. +    printk ("Free swap:       %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
  6577. +    i = (high_memory - PAGE_OFFSET) >> PAGE_SHIFT;
  6578. +    while (i-- > 0) {
  6579. +    total++;
  6580. +    if (mem_map[i].reserved)
  6581. +        reserved++;
  6582. +    else if (!mem_map[i].count)
  6583. +        free++;
  6584. +    else
  6585. +        shared += mem_map[i].count-1;
  6586. +    }
  6587. +    printk("%d pages of RAM\n",total);
  6588. +    printk("%d free pages\n",free);
  6589. +    printk("%d reserved pages\n",reserved);
  6590. +    printk("%d pages shared\n",shared);
  6591. +    show_buffers();
  6592.  #ifdef CONFIG_NET
  6593. -    show_net_buffers();
  6594. +    show_net_buffers();
  6595.  #endif
  6596.  }
  6597.  
  6598. @@ -105,48 +92,38 @@
  6599.  unsigned long map_screen_mem(int log_start,int update)
  6600.  {
  6601.      /* This routine needs more work to make it dynamically release/allocate mem! */
  6602. -    unsigned long address;
  6603. -    int i;
  6604. -    static int updated=0;
  6605. -#if 0
  6606. -    unsigned long screen_size = 256*1024;
  6607. -#else
  6608. -    unsigned long screen_size = 480*1024;
  6609. -#endif
  6610. -    pgd_t *pg_dir;
  6611. -    pmd_t *pm_dir;
  6612. -    pte_t *pt_entry;
  6613. -
  6614. -    if(updated)
  6615. -        return 0;
  6616. -
  6617. -    address=LOGICAL_END;
  6618. -
  6619. -    for(i = LOGICAL_END - screen_size; i<LOGICAL_END; i+=PAGE_SIZE)
  6620. -    {
  6621. -        pg_dir = swapper_pg_dir + (i >> PGDIR_SHIFT);
  6622. -        pm_dir = pmd_offset(pg_dir, i);
  6623. -        pt_entry = pte_offset(pm_dir, i);
  6624. -        if(i>=log_start)
  6625. -        {
  6626. -            *pt_entry = mk_pte(address, __pgprot(_PAGE_PRESENT|_PAGE_USER|_PAGE_RW|_PAGE_ACCESSED));
  6627. -            address+=PAGE_SIZE;
  6628. -        }
  6629. -        else
  6630. -            *pt_entry = mk_pte(0, __pgprot(0));
  6631. -    }
  6632. -    if(update)
  6633. -    {
  6634. -
  6635. -        for(; address<(LOGICAL_END + screen_size); address += PAGE_SIZE)
  6636. -        {
  6637. -            mem_map[MAP_NR(address)].count = 1;
  6638. -            free_page(address);
  6639. -        }
  6640. -        updated=1;
  6641. -        invalidate();
  6642. +    static int updated=0;
  6643. +    unsigned long screen_size = 480*1024;
  6644. +    unsigned long address;
  6645. +    int i;
  6646. +    pgd_t *pg_dir;
  6647. +    pmd_t *pm_dir;
  6648. +    pte_t *pt_entry;
  6649. +
  6650. +    if(updated)
  6651. +    return 0;
  6652. +
  6653. +    address = LOGICAL_END;
  6654. +
  6655. +    for (i = LOGICAL_END - screen_size; i < LOGICAL_END; i += PAGE_SIZE) {
  6656. +    pg_dir = swapper_pg_dir + (i >> PGDIR_SHIFT);
  6657. +    pm_dir = pmd_offset(pg_dir, i);
  6658. +    pt_entry = pte_offset(pm_dir, i);
  6659. +    if (i >= log_start) {
  6660. +        *pt_entry = mk_pte(address, __pgprot(_PAGE_PRESENT|_PAGE_USER|_PAGE_RW|_PAGE_ACCESSED));
  6661. +        address += PAGE_SIZE;
  6662. +    } else
  6663. +        *pt_entry = mk_pte(0, __pgprot(0));
  6664. +    }
  6665. +    if (update) {
  6666. +    for (; address<(LOGICAL_END + screen_size); address += PAGE_SIZE) {
  6667. +        mem_map[MAP_NR(address)].count = 1;
  6668. +        free_page(address);
  6669.      }
  6670. -    return address;
  6671. +    updated=1;
  6672. +    invalidate();
  6673. +    }
  6674. +    return address;
  6675.  }
  6676.  
  6677.  /*
  6678. @@ -158,129 +135,122 @@
  6679.   */
  6680.  unsigned long paging_init(unsigned long start_mem, unsigned long end_mem)
  6681.  {
  6682. -    extern int page_nr;
  6683. -    int address;
  6684. -    int i;
  6685. -    pgd_t *pg_dir;
  6686. -    pmd_t *pm_dir;
  6687. -    pte_t *pt_entry;
  6688. -
  6689. -    page_nr = MAP_NR(end_mem);
  6690. -/* We appear to need this */
  6691. -    current = &init_task;
  6692. +    extern int page_nr;
  6693. +    int address;
  6694. +    int i;
  6695. +    pgd_t *pg_dir;
  6696. +    pmd_t *pm_dir;
  6697. +    pte_t *pt_entry;
  6698. +
  6699. +    page_nr = MAP_NR(end_mem);
  6700. +    /*
  6701. +     * We appear to need this
  6702. +     */
  6703. +    current = &init_task;
  6704.      
  6705. -    pg_dir = swapper_pg_dir;
  6706. -    pm_dir = pmd_offset(pg_dir, 0);
  6707. -    pt_entry = pte_offset(pm_dir, 0);
  6708. -
  6709. -    /* Insert mappings for the screen memory */
  6710. -    for(i=0; i<LOGICAL_END; i+=PAGE_SIZE)
  6711. -    {
  6712. -        pt_entry[i>>PAGE_SHIFT] = mk_pte(0, __pgprot(0));
  6713. -    }
  6714. -#if 0
  6715. -    address = map_screen_mem(0x02000000 - 256*1024, 0);
  6716. -#else
  6717. -    address = map_screen_mem(LOGICAL_END - 480*1024, 0);
  6718. -#endif
  6719. -
  6720. -    /* Allocate zero page */
  6721. -    for(i=0; i<32768>>PAGE_SHIFT; i++)
  6722. -    {
  6723. -        pt_entry[i] = mk_pte(address, PAGE_READONLY);
  6724. -        address += PAGE_SIZE;
  6725. -    }
  6726. -
  6727. -    /* Allocate kernel code pages */
  6728. -    for(i=0x01800000>>PAGE_SHIFT; address < start_mem; i++)
  6729. -    {
  6730. -        pt_entry[i] = mk_pte(address, PAGE_SHARED);
  6731. -        address += PAGE_SIZE;
  6732. -    }
  6733. -
  6734. -    empty_bad_page = (unsigned char *)address;
  6735. +    pg_dir = swapper_pg_dir;
  6736. +    pm_dir = pmd_offset(pg_dir, 0);
  6737. +    pt_entry = pte_offset(pm_dir, 0);
  6738. +
  6739. +    /* Insert mappings for the screen memory */
  6740. +    for(i=0; i<LOGICAL_END; i+=PAGE_SIZE)
  6741. +    pt_entry[i>>PAGE_SHIFT] = mk_pte(0, __pgprot(0));
  6742. +
  6743. +    address = map_screen_mem(LOGICAL_END - 480*1024, 0);
  6744. +
  6745. +    /* Allocate zero page */
  6746. +    for (i = 0; i < 32768 >> PAGE_SHIFT; i++) {
  6747. +    pt_entry[i] = mk_pte(address, PAGE_READONLY);
  6748.      address += PAGE_SIZE;
  6749. -    empty_zero_page = (unsigned char *)address;
  6750. +    }
  6751. +
  6752. +    /* Allocate kernel code pages */
  6753. +    for (i = 0x01800000 >> PAGE_SHIFT; address < start_mem; i++) {
  6754. +    pt_entry[i] = mk_pte(address, PAGE_SHARED);
  6755.      address += PAGE_SIZE;
  6756. +    }
  6757.  
  6758. -    invalidate();
  6759. -    return free_area_init(address, end_mem);
  6760. +    empty_bad_page = (unsigned char *)address;
  6761. +    address += PAGE_SIZE;
  6762. +    empty_zero_page = (unsigned char *)address;
  6763. +    address += PAGE_SIZE;
  6764. +
  6765. +    invalidate();
  6766. +    return free_area_init(address, end_mem);
  6767.  }
  6768.  
  6769.  void mem_init(unsigned long start_mem, unsigned long end_mem)
  6770.  {
  6771. -    int codepages = 0;
  6772. -    int reservedpages = 0;
  6773. -    int datapages = 0;
  6774. -    unsigned long tmp;
  6775. -    extern int etext;
  6776. -    int i;
  6777. -    extern void sound_init(void);
  6778. -
  6779. -    end_mem &= PAGE_MASK;
  6780. -    high_memory = end_mem;
  6781. -
  6782. -    /* mark usable pages in the mem_map[] */
  6783. -    start_mem = PAGE_ALIGN(start_mem);
  6784. -
  6785. -    for(i=0; i<MAP_NR(start_mem); i++)
  6786. -    {
  6787. -        mem_map[i].reserved = 1;
  6788. -        mem_map[i].count = 0;
  6789. -    }
  6790. -
  6791. -    while(i < MAP_NR(end_mem))
  6792. -    {
  6793. -        mem_map[i].reserved = 0;
  6794. -        mem_map[i++].count = 0;
  6795. -    }
  6796. +    int codepages = 0;
  6797. +    int reservedpages = 0;
  6798. +    int datapages = 0;
  6799. +    unsigned long tmp;
  6800. +    extern int etext;
  6801. +    int i;
  6802. +    extern void sound_init(void);
  6803. +
  6804. +    end_mem &= PAGE_MASK;
  6805. +    high_memory = end_mem;
  6806. +
  6807. +    /* mark usable pages in the mem_map[] */
  6808. +    start_mem = PAGE_ALIGN(start_mem);
  6809. +
  6810. +    for (i = 0; i < MAP_NR(start_mem); i++) {
  6811. +    mem_map[i].reserved = 1;
  6812. +    mem_map[i].count = 0;
  6813. +    }
  6814. +
  6815. +    while (i < MAP_NR(end_mem)) {
  6816. +    mem_map[i].reserved = 0;
  6817. +    mem_map[i++].count = 0;
  6818. +    }
  6819.  
  6820.  #ifdef CONFIG_SCSI
  6821. -    scsi_mem_init(high_memory);
  6822. +    scsi_mem_init(high_memory);
  6823.  #endif
  6824. -    for (tmp = LOGICAL_END ; tmp < high_memory ; tmp += PAGE_SIZE) {
  6825. -        if (mem_map[MAP_NR(tmp)].reserved) {
  6826. -            if (tmp < LOGICAL_END + (256*1024+32*1024))
  6827. -                reservedpages++;
  6828. -            else if (tmp < ((unsigned long) &etext - 0x01800000 + 0x02048000))
  6829. -                codepages++;
  6830. -            else
  6831. -                datapages++;
  6832. -            continue;
  6833. -        }
  6834. -        mem_map[MAP_NR(tmp)].count = 1;
  6835. -        free_page(tmp);
  6836. -    }
  6837. -    tmp = nr_free_pages << PAGE_SHIFT;
  6838. -    printk("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data)\n",
  6839. -        tmp >> 10,
  6840. -        (high_memory - LOGICAL_END) >> 10,
  6841. -        codepages << (PAGE_SHIFT-10),
  6842. -        reservedpages << (PAGE_SHIFT-10),
  6843. -        datapages << (PAGE_SHIFT-10));
  6844. +    for (tmp = LOGICAL_END ; tmp < high_memory ; tmp += PAGE_SIZE) {
  6845. +    if (mem_map[MAP_NR(tmp)].reserved) {
  6846. +        if (tmp < LOGICAL_END + (256*1024+32*1024))
  6847. +        reservedpages++;
  6848. +        else if (tmp < ((unsigned long) &etext - 0x01800000 + 0x02048000))
  6849. +        codepages++;
  6850. +        else
  6851. +        datapages++;
  6852. +        continue;
  6853. +    }
  6854. +    mem_map[MAP_NR(tmp)].count = 1;
  6855. +    free_page(tmp);
  6856. +    }
  6857. +    tmp = nr_free_pages << PAGE_SHIFT;
  6858. +    printk ("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data)\n",
  6859. +    tmp >> 10,
  6860. +    (high_memory - LOGICAL_END) >> 10,
  6861. +    codepages << (PAGE_SHIFT-10),
  6862. +    reservedpages << (PAGE_SHIFT-10),
  6863. +    datapages << (PAGE_SHIFT-10));
  6864.  #ifdef CONFIG_SOUND
  6865. -    sound_init();
  6866. +    sound_init();
  6867.  #endif
  6868.  }
  6869.  
  6870.  void si_meminfo(struct sysinfo *val)
  6871.  {
  6872. -    int i;
  6873. +    int i;
  6874.  
  6875. -    i = MAP_NR(high_memory);
  6876. -    val->totalram = 0;
  6877. -    val->sharedram = 0;
  6878. -    val->freeram = nr_free_pages << PAGE_SHIFT;
  6879. -    val->bufferram = buffermem;
  6880. -    while (i-- > 0)  {
  6881. -        if (mem_map[i].reserved)
  6882. -            continue;
  6883. -        val->totalram++;
  6884. -        if (!mem_map[i].count)
  6885. -            continue;
  6886. -        val->sharedram += mem_map[i].count-1;
  6887. -    }
  6888. -    val->totalram <<= PAGE_SHIFT;
  6889. -    val->sharedram <<= PAGE_SHIFT;
  6890. -    return;
  6891. +    i = MAP_NR(high_memory);
  6892. +    val->totalram = 0;
  6893. +    val->sharedram = 0;
  6894. +    val->freeram = nr_free_pages << PAGE_SHIFT;
  6895. +    val->bufferram = buffermem;
  6896. +    while (i-- > 0)  {
  6897. +    if (mem_map[i].reserved)
  6898. +        continue;
  6899. +    val->totalram++;
  6900. +    if (!mem_map[i].count)
  6901. +        continue;
  6902. +    val->sharedram += mem_map[i].count-1;
  6903. +    }
  6904. +    val->totalram <<= PAGE_SHIFT;
  6905. +    val->sharedram <<= PAGE_SHIFT;
  6906. +    return;
  6907.  }
  6908. diff -urN linux.store/linux/include/asm-arm/a.out.h linux/include/asm-arm/a.out.h
  6909. --- linux.store/linux/include/asm-arm/a.out.h    Sun Feb 11 09:32:54 1996
  6910. +++ linux/include/asm-arm/a.out.h    Sun Feb 11 09:32:54 1996
  6911. @@ -13,18 +13,11 @@
  6912.    unsigned a_drsize;        /* length of relocation info for data, in bytes */
  6913.  };
  6914.  
  6915. -#define N_TXTADDR(a)    0x8000
  6916. -
  6917.  #define N_TRSIZE(a)    ((a).a_trsize)
  6918.  #define N_DRSIZE(a)    ((a).a_drsize)
  6919.  #define N_SYMSIZE(a)    ((a).a_syms)
  6920.  
  6921.  #define M_ARM 103
  6922.  
  6923. -#ifdef __KERNEL__
  6924. -
  6925. -#define STACK_TOP    24*1024*1024
  6926. -
  6927. -#endif
  6928. -
  6929. +#include <asm/arch/a.out.h>
  6930.  #endif /* __A_OUT_GNU_H__ */
  6931. diff -urN linux.store/linux/include/asm-arm/arch-a5k/a.out.h linux/include/asm-arm/arch-a5k/a.out.h
  6932. --- linux.store/linux/include/asm-arm/arch-a5k/a.out.h    Thu Jan  1 01:00:00 1970
  6933. +++ linux/include/asm-arm/arch-a5k/a.out.h    Sun Feb 11 09:32:54 1996
  6934. @@ -0,0 +1,17 @@
  6935. +/*
  6936. + * linux/include/asm-arm/arch-a5k/a.out.h
  6937. + *
  6938. + * Copyright (C) 1996 Russell King
  6939. + */
  6940. +
  6941. +#ifndef __ASM_ARCH_A_OUT_H
  6942. +#define __ASM_ARCH_A_OUT_H
  6943. +
  6944. +#define N_TXTADDR(a)    0x8000
  6945. +
  6946. +#ifdef __KERNEL__
  6947. +#define STACK_TOP    24*1024*1024
  6948. +#endif
  6949. +
  6950. +#endif
  6951. +
  6952. diff -urN linux.store/linux/include/asm-arm/arch-a5k/dma.h linux/include/asm-arm/arch-a5k/dma.h
  6953. --- linux.store/linux/include/asm-arm/arch-a5k/dma.h    Thu Jan  1 01:00:00 1970
  6954. +++ linux/include/asm-arm/arch-a5k/dma.h    Wed Mar 13 15:21:00 1996
  6955. @@ -0,0 +1,64 @@
  6956. +#ifndef __ASM_ARCH_DMA_H
  6957. +#define __ASM_ARCH_DMA_H
  6958. +
  6959. +/* enable/disable a specific DMA channel */
  6960. +extern void enable_dma(unsigned int dmanr);
  6961. +
  6962. +static __inline__ void disable_dma(unsigned int dmanr)
  6963. +{
  6964. +    switch(dmanr) {
  6965. +    case 2:  disable_irq(16); break;
  6966. +    default: printk("disable_dma: dma %d not supported\n", dmanr); break;
  6967. +    }
  6968. +}
  6969. +
  6970. +/* Clear the 'DMA Pointer Flip Flop'.
  6971. + * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  6972. + * Use this once to initialize the FF to a known state.
  6973. + * After that, keep track of it. :-)
  6974. + * --- In order to do that, the DMA routines below should ---
  6975. + * --- only be used while interrupts are disabled! ---
  6976. + */
  6977. +static __inline__ void clear_dma_ff(unsigned int dmanr)
  6978. +{
  6979. +    switch(dmanr) {
  6980. +    case 2:  break;
  6981. +    default: printk("clear_dma_ff: dma %d not supported\n", dmanr); break;
  6982. +    }
  6983. +}
  6984. +
  6985. +/* set mode (above) for a specific DMA channel */
  6986. +extern void set_dma_mode(unsigned int dmanr, char mode);
  6987. +
  6988. +/* Set only the page register bits of the transfer address.
  6989. + * This is used for successive transfers when we know the contents of
  6990. + * the lower 16 bits of the DMA current address register, but a 64k boundary
  6991. + * may have been crossed.
  6992. + */
  6993. +static __inline__ void set_dma_page(unsigned int dmanr, char pagenr)
  6994. +{
  6995. +    printk("set_dma_page: dma %d not supported\n", dmanr);
  6996. +}
  6997. +
  6998. +
  6999. +/* Set transfer address & page bits for specific DMA channel.
  7000. + * Assumes dma flipflop is clear.
  7001. + */
  7002. +extern void set_dma_addr(unsigned int dmanr, unsigned int addr);
  7003. +
  7004. +/* Set transfer size for a specific DMA channel.
  7005. + */
  7006. +extern void set_dma_count(unsigned int dmanr, unsigned int count);
  7007. +
  7008. +/* Get DMA residue count. After a DMA transfer, this
  7009. + * should return zero. Reading this while a DMA transfer is
  7010. + * still in progress will return unpredictable results.
  7011. + * If called before the channel has been used, it may return 1.
  7012. + * Otherwise, it returns the number of _bytes_ left to transfer.
  7013. + *
  7014. + * Assumes DMA flip-flop is clear.
  7015. + */
  7016. +extern int get_dma_residue(unsigned int dmanr);
  7017. +
  7018. +#endif /* _ASM_ARCH_DMA_H */
  7019. +
  7020. diff -urN linux.store/linux/include/asm-arm/arch-a5k/irqs.h linux/include/asm-arm/arch-a5k/irqs.h
  7021. --- linux.store/linux/include/asm-arm/arch-a5k/irqs.h    Thu Jan  1 01:00:00 1970
  7022. +++ linux/include/asm-arm/arch-a5k/irqs.h    Sun Feb 11 09:32:54 1996
  7023. @@ -0,0 +1,28 @@
  7024. +/*
  7025. + * linux/include/asm-arm/arch-a5k/irqs.h
  7026. + *
  7027. + * Copyright (C) 1996 Russell King
  7028. + */
  7029. +
  7030. +#define IRQ_PRINTER        0
  7031. +#define IRQ_BATLOW        1
  7032. +#define IRQ_FLOPPYINDEX        2
  7033. +#define IRQ_VSYNCPULSE        3
  7034. +#define IRQ_POWERON        4
  7035. +#define IRQ_TIMER0        5
  7036. +#define IRQ_TIMER1        6
  7037. +#define IRQ_IMMEDIATE        7
  7038. +#define IRQ_EXPCARDFIQ        8
  7039. +#define IRQ_SOUNDCHANGE        9
  7040. +#define IRQ_SERIALPORT        10
  7041. +#define IRQ_HARDDISK        11
  7042. +#define IRQ_FLOPPYDISK        12
  7043. +#define IRQ_EXPANSIONCARD    13
  7044. +#define IRQ_KEYBOARDTX        14
  7045. +#define IRQ_KEYBOARDRX        15
  7046. +
  7047. +#define FIQ_FLOPPYDATA        0
  7048. +#define FIQ_ECONET        2
  7049. +#define FIQ_SERIALPORT        4
  7050. +#define FIQ_EXPANSIONCARD    6
  7051. +#define FIQ_FORCE        7
  7052. diff -urN linux.store/linux/include/asm-arm/arch-a5k/oldlatches.h linux/include/asm-arm/arch-a5k/oldlatches.h
  7053. --- linux.store/linux/include/asm-arm/arch-a5k/oldlatches.h    Thu Jan  1 01:00:00 1970
  7054. +++ linux/include/asm-arm/arch-a5k/oldlatches.h    Sun Feb 11 09:32:54 1996
  7055. @@ -0,0 +1,9 @@
  7056. +/*
  7057. + * Dummy oldlatches.h
  7058. + *
  7059. + * Copyright (C) 1996 Russell King
  7060. + */
  7061. +
  7062. +#ifdef __need_oldlatches
  7063. +#error "Old latches not present in this (a5k) machine"
  7064. +#endif
  7065. diff -urN linux.store/linux/include/asm-arm/arch-arc/a.out.h linux/include/asm-arm/arch-arc/a.out.h
  7066. --- linux.store/linux/include/asm-arm/arch-arc/a.out.h    Thu Jan  1 01:00:00 1970
  7067. +++ linux/include/asm-arm/arch-arc/a.out.h    Sun Feb 11 09:32:57 1996
  7068. @@ -0,0 +1,17 @@
  7069. +/*
  7070. + * linux/include/asm-arm/arch-arc/a.out.h
  7071. + *
  7072. + * Copyright (C) 1996 Russell King
  7073. + */
  7074. +
  7075. +#ifndef __ASM_ARCH_A_OUT_H
  7076. +#define __ASM_ARCH_A_OUT_H
  7077. +
  7078. +#define N_TXTADDR(a)    0x8000
  7079. +
  7080. +#ifdef __KERNEL__
  7081. +#define STACK_TOP    24*1024*1024
  7082. +#endif
  7083. +
  7084. +#endif
  7085. +
  7086. diff -urN linux.store/linux/include/asm-arm/arch-arc/dma.h linux/include/asm-arm/arch-arc/dma.h
  7087. --- linux.store/linux/include/asm-arm/arch-arc/dma.h    Thu Jan  1 01:00:00 1970
  7088. +++ linux/include/asm-arm/arch-arc/dma.h    Wed Mar 13 15:20:23 1996
  7089. @@ -0,0 +1,81 @@
  7090. +#ifndef __ASM_ARCH_DMA_H
  7091. +#define __ASM_ARCH_DMA_H
  7092. +
  7093. +/* enable/disable a specific DMA channel */
  7094. +extern void enable_dma(unsigned int dmanr);
  7095. +
  7096. +static __inline__ void disable_dma(unsigned int dmanr)
  7097. +{
  7098. +    switch(dmanr) {
  7099. +#ifdef CONFIG_BLK_DEV_FD
  7100. +    /* This is a HACK - at the moment ARM Linux doesn't support two FIQs
  7101. +     being serviced together, until it does this hack must stay - DAG */
  7102. +    case 0: { /* Data DMA */
  7103. +    /* We have to replace it by FIQ code for command end */
  7104. +    unsigned long flags;
  7105. +    extern void fdc1772_comendhandler(void);
  7106. +    /*printk("disable_dma for FD1772\n");*/
  7107. +    disable_irq(16);
  7108. +
  7109. +    save_flags(flags);
  7110. +    cliIF();
  7111. +    *((unsigned int *)0x1c)=0xea000000 | (((unsigned int)fdc1772_comendhandler-(0x1c+8))/4); /* B fdc1772_comendhandler */ 
  7112. +    restore_flags(flags);
  7113. +  }
  7114. +  break;
  7115. +
  7116. +#endif
  7117. +    default: printk("disable_dma: dma %d not supported\n", dmanr); break;
  7118. +    }
  7119. +}
  7120. +
  7121. +/* Clear the 'DMA Pointer Flip Flop'.
  7122. + * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  7123. + * Use this once to initialize the FF to a known state.
  7124. + * After that, keep track of it. :-)
  7125. + * --- In order to do that, the DMA routines below should ---
  7126. + * --- only be used while interrupts are disabled! ---
  7127. + */
  7128. +static __inline__ void clear_dma_ff(unsigned int dmanr)
  7129. +{
  7130. +    switch(dmanr) {
  7131. +    case 2:  break;
  7132. +    default: printk("clear_dma_ff: dma %d not supported\n", dmanr); break;
  7133. +    }
  7134. +}
  7135. +
  7136. +/* set mode (above) for a specific DMA channel */
  7137. +extern void set_dma_mode(unsigned int dmanr, char mode);
  7138. +
  7139. +/* Set only the page register bits of the transfer address.
  7140. + * This is used for successive transfers when we know the contents of
  7141. + * the lower 16 bits of the DMA current address register, but a 64k boundary
  7142. + * may have been crossed.
  7143. + */
  7144. +static __inline__ void set_dma_page(unsigned int dmanr, char pagenr)
  7145. +{
  7146. +    printk("set_dma_page: dma %d not supported\n", dmanr);
  7147. +}
  7148. +
  7149. +
  7150. +/* Set transfer address & page bits for specific DMA channel.
  7151. + * Assumes dma flipflop is clear.
  7152. + */
  7153. +extern void set_dma_addr(unsigned int dmanr, unsigned int addr);
  7154. +
  7155. +/* Set transfer size for a specific DMA channel.
  7156. + */
  7157. +extern void set_dma_count(unsigned int dmanr, unsigned int count);
  7158. +
  7159. +/* Get DMA residue count. After a DMA transfer, this
  7160. + * should return zero. Reading this while a DMA transfer is
  7161. + * still in progress will return unpredictable results.
  7162. + * If called before the channel has been used, it may return 1.
  7163. + * Otherwise, it returns the number of _bytes_ left to transfer.
  7164. + *
  7165. + * Assumes DMA flip-flop is clear.
  7166. + */
  7167. +extern int get_dma_residue(unsigned int dmanr);
  7168. +
  7169. +#endif /* _ASM_ARCH_DMA_H */
  7170. +
  7171. diff -urN linux.store/linux/include/asm-arm/arch-arc/irqs.h linux/include/asm-arm/arch-arc/irqs.h
  7172. --- linux.store/linux/include/asm-arm/arch-arc/irqs.h    Thu Jan  1 01:00:00 1970
  7173. +++ linux/include/asm-arm/arch-arc/irqs.h    Sun Feb 11 09:32:57 1996
  7174. @@ -0,0 +1,30 @@
  7175. +/*
  7176. + * linux/include/asm-arm/arch-arc/irqs.h
  7177. + *
  7178. + * Copyright (C) 1996 Russell King, Dave Gilbert (gilbertd@cs.man.ac.uk)
  7179. + */
  7180. +
  7181. +#define IRQ_PRINTERBUSY        0
  7182. +#define IRQ_SERIALRING        1
  7183. +#define IRQ_PRINTERACK        2
  7184. +#define IRQ_VSYNCPULSE        3
  7185. +#define IRQ_POWERON        4
  7186. +#define IRQ_TIMER0        5
  7187. +#define IRQ_TIMER1        6
  7188. +#define IRQ_IMMEDIATE        7
  7189. +#define IRQ_EXPCARDFIQ        8
  7190. +#define IRQ_SOUNDCHANGE        9
  7191. +#define IRQ_SERIALPORT        10
  7192. +#define IRQ_HARDDISK        11
  7193. +#define IRQ_FLOPPYCHANGED    12
  7194. +#define IRQ_EXPANSIONCARD    13
  7195. +#define IRQ_KEYBOARDTX        14
  7196. +#define IRQ_KEYBOARDRX        15
  7197. +
  7198. +#define FIQ_FLOPPYDATA        0
  7199. +#define FIQ_FLOPPYIRQ        1
  7200. +#define FIQ_ECONET        2
  7201. +#define FIQ_EXPANSIONCARD    6
  7202. +#define FIQ_FORCE        7
  7203. +
  7204. +#define FIQ_FD1772        FIQ_FLOPPYIRQ
  7205. diff -urN linux.store/linux/include/asm-arm/arch-arc/oldlatches.h linux/include/asm-arm/arch-arc/oldlatches.h
  7206. --- linux.store/linux/include/asm-arm/arch-arc/oldlatches.h    Thu Jan  1 01:00:00 1970
  7207. +++ linux/include/asm-arm/arch-arc/oldlatches.h    Sun Feb 11 09:32:57 1996
  7208. @@ -0,0 +1,24 @@
  7209. +#ifndef _ASM_ARM_ARCHARC_OLDLATCH_H
  7210. +#define _ASN_ARM_ARCHARC_OLDLATCH_H
  7211. +
  7212. +#define LATCHA_FDSEL0    (1<<0)
  7213. +#define LATCHA_FDSEL1    (1<<1)
  7214. +#define LATCHA_FDSEL2    (1<<2)
  7215. +#define LATCHA_FDSEL3    (1<<3)
  7216. +#define LATCHA_FDSELALL  (0xf)
  7217. +#define LATCHA_SIDESEL   (1<<4)
  7218. +#define LATCHA_MOTOR     (1<<5)
  7219. +#define LATCHA_INUSE     (1<<6)
  7220. +#define LATCHA_CHANGERST (1<<7)
  7221. +
  7222. +#define LATCHB_FDCDENSITY  (1<<1)
  7223. +#define LATCHB_FDCRESET    (1<<3)
  7224. +#define LATCHB_PRINTSTROBE (1<<4)
  7225. +
  7226. +/* newval=(oldval & mask)|newdata */
  7227. +void oldlatch_bupdate(unsigned char mask,unsigned char newdata);
  7228. +
  7229. +/* newval=(oldval & mask)|newdata */
  7230. +void oldlatch_aupdate(unsigned char mask,unsigned char newdata);
  7231. +
  7232. +#endif
  7233. diff -urN linux.store/linux/include/asm-arm/arch-arc/system.h linux/include/asm-arm/arch-arc/system.h
  7234. --- linux.store/linux/include/asm-arm/arch-arc/system.h    Thu Jan  1 01:00:00 1970
  7235. +++ linux/include/asm-arm/arch-arc/system.h    Wed Mar 13 15:10:27 1996
  7236. @@ -0,0 +1,9 @@
  7237. +#define cliIF()                \
  7238. +    do {                \
  7239. +      unsigned long temp;        \
  7240. +      __asm__ __volatile__(        \
  7241. +"    mov    %0, pc\n"        \
  7242. +"    orr %0, %0, #0x0c000000\n"    \
  7243. +"    teqp    %0, #0\n"        \
  7244. +      : "=r" (temp));
  7245. +
  7246. diff -urN linux.store/linux/include/asm-arm/arch-rpc/oldlatches.h linux/include/asm-arm/arch-rpc/oldlatches.h
  7247. --- linux.store/linux/include/asm-arm/arch-rpc/oldlatches.h    Thu Jan  1 01:00:00 1970
  7248. +++ linux/include/asm-arm/arch-rpc/oldlatches.h    Tue Mar 12 15:36:14 1996
  7249. @@ -0,0 +1,9 @@
  7250. +/*
  7251. + * Dummy oldlatches.h
  7252. + *
  7253. + * Copyright (C) 1996 Russell King
  7254. + */
  7255. +
  7256. +#ifdef __need_oldlatches
  7257. +#error "Old latches not present in this (rpc) machine"
  7258. +#endif
  7259. diff -urN linux.store/linux/include/asm-arm/assembler.h linux/include/asm-arm/assembler.h
  7260. --- linux.store/linux/include/asm-arm/assembler.h    Sun Feb 11 09:32:54 1996
  7261. +++ linux/include/asm-arm/assembler.h    Sun Feb 11 09:32:54 1996
  7262. @@ -2,50 +2,12 @@
  7263.   * linux/asm/assembler.h
  7264.   *
  7265.   * This file contains arm architecture specific defines
  7266. - * for the different processors
  7267. + * for the different processors.
  7268. + *
  7269. + * Do not include any C declarations in this file - it is included by
  7270. + * assembler source.
  7271.   */
  7272.  
  7273. -#if !defined (__arm2__) && !defined (__arm3__) && !defined (__arm6__)
  7274. -#error "Only ARN2, ARM3 and ARM6 architectures are supported"
  7275. -#endif
  7276. -
  7277. -#undef __FOUND
  7278. -#undef __ERROR
  7279. -
  7280. -#ifdef __arm2__
  7281. -#ifdef __FOUND
  7282. -#undef __ERROR
  7283. -#define __ERROR
  7284. -#else
  7285. -#define __FOUND
  7286. -#endif
  7287. -#endif
  7288. -
  7289. -#ifdef __arm3__
  7290. -#ifdef __FOUND
  7291. -#undef __ERROR
  7292. -#define __ERROR
  7293. -#else
  7294. -#define __FOUND
  7295. -#endif
  7296. -#endif
  7297. -
  7298. -#ifdef __arm6__
  7299. -#ifdef __FOUND
  7300. -#undef __ERROR
  7301. -#define __ERROR
  7302. -#else
  7303. -#define __FOUND
  7304. -#endif
  7305. -#endif
  7306. -
  7307. -#ifdef __ERROR
  7308. -#error "Only one of __arm3__ and __arm6__ may be defined"
  7309. -#endif
  7310. -
  7311. -#undef __FOUND
  7312. -#undef __ERROR
  7313. -
  7314.  /*
  7315.   * LOADREGS: multiple register load (ldm) with pc in register list
  7316.   *        (takes account of ARM6 not using ^)
  7317. @@ -69,73 +31,4 @@
  7318.   * SVCMODE: switch to SVC mode
  7319.   */
  7320.  
  7321. -#if defined (__arm2__)
  7322. -#define LOADREGS(cond, base, reglist...)\
  7323. -    ldm##cond    base,reglist^
  7324. -
  7325. -#define RETINSTR(instr, regs...)\
  7326. -    instr##s    regs
  7327. -
  7328. -#define MODENOP\
  7329. -    mov    r0, r0
  7330. -
  7331. -#define SAVEIRQS
  7332. -#define RESTOREIRQS
  7333. -
  7334. -#define DISABLEIRQS\
  7335. -    teqp    pc, #0x08000003
  7336. -
  7337. -#define ENABLEIRQS\
  7338. -    teqp    pc, #0x00000003
  7339. -
  7340. -#define USERMODE\
  7341. -    teqp    pc, #0x00000000;\
  7342. -    mov    r0, r0
  7343. -
  7344. -#define SVCMODE\
  7345. -    teqp    pc, #0x00000003;\
  7346. -    mov    r0, r0
  7347. -#endif
  7348. -
  7349. -#if defined (__arm3__)
  7350. -#define LOADREGS(cond, base, reglist...)\
  7351. -    ldm##cond    base,reglist^
  7352. -
  7353. -#define RETINSTR(instr, regs...)\
  7354. -    instr##s    regs
  7355. -
  7356. -#define MODENOP
  7357. -
  7358. -#define SAVEIRQS
  7359. -#define RESTOREIRQS
  7360. -
  7361. -#define DISABLEIRQS\
  7362. -    teqp    pc, #0x08000003
  7363. -
  7364. -#define ENABLEIRQS\
  7365. -    teqp    pc, #0x00000003
  7366. -
  7367. -#define USERMODE\
  7368. -    teqp    pc, #0x00000000
  7369. -
  7370. -#define SVCMODE\
  7371. -    teqp    pc, #0x00000003
  7372. -#endif
  7373. -
  7374. -#if defined (__arm6__)
  7375. -#define LOADREGS(cond, base, reglist...)\
  7376. -    ldm##cond    base,reglist
  7377. -
  7378. -#define RETINSTR(instr, regs...)\
  7379. -    instr    regs
  7380. -
  7381. -#define MODENOP
  7382. -
  7383. -#define SAVEIRQS
  7384. -#define RESTOREIRQS
  7385. -
  7386. -#define DISABLEIRQS
  7387. -#define ENABLEIRQS
  7388. -#define USERMODE
  7389. -#define SVCMODE
  7390. -#endif
  7391. +#include <asm/proc/assembler.h>
  7392. diff -urN linux.store/linux/include/asm-arm/bugs.h linux/include/asm-arm/bugs.h
  7393. --- linux.store/linux/include/asm-arm/bugs.h    Sun Feb 11 09:32:54 1996
  7394. +++ linux/include/asm-arm/bugs.h    Sun Feb 11 09:32:54 1996
  7395. @@ -4,14 +4,4 @@
  7396.   *  Copyright (C) 1995  Russell King
  7397.   */
  7398.  
  7399. -/*
  7400. - * This is included by init/main.c to check for architecture-dependent bugs.
  7401. - *
  7402. - * Needs:
  7403. - *      void check_bugs(void);
  7404. - */
  7405. -         
  7406. -static inline void check_bugs(void)
  7407. -{
  7408. -}
  7409. -
  7410. +#include <asm/proc/bugs.h>
  7411. diff -urN linux.store/linux/include/asm-arm/dma.h linux/include/asm-arm/dma.h
  7412. --- linux.store/linux/include/asm-arm/dma.h    Sun Feb 11 09:32:54 1996
  7413. +++ linux/include/asm-arm/dma.h    Wed Mar 13 15:18:17 1996
  7414. @@ -10,64 +10,7 @@
  7415.  #define DMA_MODE_READ        0x44
  7416.  #define DMA_MODE_WRITE        0x48
  7417.  
  7418. -/* enable/disable a specific DMA channel */
  7419. -extern void enable_dma(unsigned int dmanr);
  7420. -
  7421. -static __inline__ void disable_dma(unsigned int dmanr)
  7422. -{
  7423. -    switch(dmanr) {
  7424. -    case 2:  disable_irq(16); break;
  7425. -    default: printk("disable_dma: dma %d not supported\n", dmanr); break;
  7426. -    }
  7427. -}
  7428. -
  7429. -/* Clear the 'DMA Pointer Flip Flop'.
  7430. - * Write 0 for LSB/MSB, 1 for MSB/LSB access.
  7431. - * Use this once to initialize the FF to a known state.
  7432. - * After that, keep track of it. :-)
  7433. - * --- In order to do that, the DMA routines below should ---
  7434. - * --- only be used while interrupts are disabled! ---
  7435. - */
  7436. -static __inline__ void clear_dma_ff(unsigned int dmanr)
  7437. -{
  7438. -    switch(dmanr) {
  7439. -    case 2:  break;
  7440. -    default: printk("clear_dma_ff: dma %d not supported\n", dmanr); break;
  7441. -    }
  7442. -}
  7443. -
  7444. -/* set mode (above) for a specific DMA channel */
  7445. -extern void set_dma_mode(unsigned int dmanr, char mode);
  7446. -
  7447. -/* Set only the page register bits of the transfer address.
  7448. - * This is used for successive transfers when we know the contents of
  7449. - * the lower 16 bits of the DMA current address register, but a 64k boundary
  7450. - * may have been crossed.
  7451. - */
  7452. -static __inline__ void set_dma_page(unsigned int dmanr, char pagenr)
  7453. -{
  7454. -    printk("set_dma_page: dma %d not supported\n", dmanr);
  7455. -}
  7456. -
  7457. -
  7458. -/* Set transfer address & page bits for specific DMA channel.
  7459. - * Assumes dma flipflop is clear.
  7460. - */
  7461. -extern void set_dma_addr(unsigned int dmanr, unsigned int addr);
  7462. -
  7463. -/* Set transfer size for a specific DMA channel.
  7464. - */
  7465. -extern void set_dma_count(unsigned int dmanr, unsigned int count);
  7466. -
  7467. -/* Get DMA residue count. After a DMA transfer, this
  7468. - * should return zero. Reading this while a DMA transfer is
  7469. - * still in progress will return unpredictable results.
  7470. - * If called before the channel has been used, it may return 1.
  7471. - * Otherwise, it returns the number of _bytes_ left to transfer.
  7472. - *
  7473. - * Assumes DMA flip-flop is clear.
  7474. - */
  7475. -extern int get_dma_residue(unsigned int dmanr);
  7476. +#include <asm/arch/dma.h>
  7477.  
  7478.  /* These are in kernel/dma.c: */
  7479.  extern int request_dma(unsigned int dmanr, const char * device_id);   /* reserve a DMA channel */
  7480. diff -urN linux.store/linux/include/asm-arm/irq-no.h linux/include/asm-arm/irq-no.h
  7481. --- linux.store/linux/include/asm-arm/irq-no.h    Sun Feb 11 09:32:55 1996
  7482. +++ linux/include/asm-arm/irq-no.h    Wed Mar 13 15:28:12 1996
  7483. @@ -1,25 +1,11 @@
  7484. -#define IRQ_PRINTERBUSY        0
  7485. -#define IRQ_SERIALRING        1
  7486. -#define IRQ_PRINTERACK        2
  7487. -#define IRQ_VSYNCPULSE        3
  7488. -#define IRQ_POWERON        4
  7489. -#define IRQ_TIMER0        5
  7490. -#define IRQ_TIMER1        6
  7491. -#define IRQ_7            7
  7492. -#define IRQ_8            8
  7493. -#define IRQ_SOUNDCHANGE        9
  7494. -#define IRQ_SERIALPORT        10
  7495. -#define IRQ_HARDDISK        11
  7496. -#define IRQ_FLOPPYDISK        12
  7497. -#define IRQ_EXPANSIONCARD    13
  7498. -#define IRQ_KEYBOARDTX        14
  7499. -#define IRQ_KEYBOARDRX        15
  7500. +/*
  7501. + * linux/include/asm-arm/irq-no.h
  7502. + *
  7503. + * Machine independent interrupt numbers
  7504. + */
  7505.  
  7506. -#define FIQ_FLOPPYDATA        0
  7507. -#define FIQ_ECONET        2
  7508. -#define FIQ_EXPANSIONCARD    6
  7509. -
  7510. -#define TIMER_IRQ        IRQ_TIMER0
  7511. -
  7512. -#define NUM_IRQS        32
  7513. +#include <asm/arch/irqs.h>
  7514.  
  7515. +#ifndef NR_IRQS
  7516. +#define NR_IRQS        32
  7517. +#endif
  7518. diff -urN linux.store/linux/include/asm-arm/irq.h linux/include/asm-arm/irq.h
  7519. --- linux.store/linux/include/asm-arm/irq.h    Sun Feb 11 09:32:55 1996
  7520. +++ linux/include/asm-arm/irq.h    Sun Feb 11 09:32:54 1996
  7521. @@ -3,8 +3,7 @@
  7522.  
  7523.  #include <linux/linkage.h>
  7524.  #include <asm/segment.h>
  7525. -
  7526. -#define NR_IRQS 32
  7527. +#include <asm/irq-no.h>
  7528.  
  7529.  extern void disable_irq(unsigned int);
  7530.  extern void enable_irq(unsigned int);
  7531. diff -urN linux.store/linux/include/asm-arm/page.h linux/include/asm-arm/page.h
  7532. --- linux.store/linux/include/asm-arm/page.h    Sun Feb 11 09:32:55 1996
  7533. +++ linux/include/asm-arm/page.h    Sun Feb 11 09:32:55 1996
  7534. @@ -1,109 +1 @@
  7535. -#ifndef __ASM_ARM_PAGE_H
  7536. -#define __ASM_ARM_PAGE_H
  7537. -
  7538. -#include <linux/config.h>
  7539. -
  7540. -/* PAGE_SHIFT determines the page size */
  7541. -/* Check for 32K and 16K page sizes */
  7542. -#ifdef CONFIG_PAGE_32K
  7543. -#define PAGE_SHIFT    15
  7544. -#else
  7545. -#ifdef CONFIG_PAGE_16K
  7546. -#define PAGE_SHIFT    14
  7547. -#else
  7548. -#define PAGE_SHIFT    page_shift
  7549. -extern char page_shift;
  7550. -#endif
  7551. -#endif
  7552. -
  7553. -#define LOGICAL_END    0x02000000
  7554. -
  7555. -#define PAGE_SIZE       (1UL << PAGE_SHIFT)
  7556. -#define PAGE_MASK       (~(PAGE_SIZE-1))
  7557. -
  7558. -#ifdef __KERNEL__
  7559. -
  7560. -#define CONFIG_STRICT_MM_TYPECHECKS
  7561. -
  7562. -#ifdef CONFIG_STRICT_MM_TYPECHECKS
  7563. -/*
  7564. - * These are used to make use of C type-checking..
  7565. - */
  7566. -typedef struct { unsigned long pte; } pte_t;
  7567. -typedef struct { unsigned long pmd; } pmd_t;
  7568. -typedef struct { unsigned long pgd; } pgd_t;
  7569. -typedef struct { unsigned long pgprot; } pgprot_t;
  7570. -
  7571. -#define pte_val(x)      ((x).pte)
  7572. -#define pmd_val(x)      ((x).pmd)
  7573. -#define pgd_val(x)      ((x).pgd)
  7574. -#define pgprot_val(x)   ((x).pgprot)
  7575. -
  7576. -#define __pte(x)        ((pte_t) { (x) } )
  7577. -#define __pmd(x)        ((pmd_t) { (x) } )
  7578. -#define __pgd(x)        ((pgd_t) { (x) } )
  7579. -#define __pgprot(x)     ((pgprot_t) { (x) } )
  7580. -
  7581. -#else
  7582. -/*
  7583. - * .. while these make it easier on the compiler
  7584. - */
  7585. -typedef unsigned long pte_t;
  7586. -typedef unsigned long pmd_t;
  7587. -typedef unsigned long pgd_t;
  7588. -typedef unsigned long pgprot_t;
  7589. -
  7590. -#define pte_val(x)      (x)
  7591. -#define pmd_val(x)      (x)
  7592. -#define pgd_val(x)      (x)
  7593. -#define pgprot_val(x)   (x)
  7594. -
  7595. -#define __pte(x)        (x)
  7596. -#define __pmd(x)        (x)
  7597. -#define __pgd(x)        (x)
  7598. -#define __pgprot(x)     (x)
  7599. -
  7600. -#endif
  7601. -
  7602. -extern void remap_task (pgd_t *);
  7603. -
  7604. -/*
  7605. - * TLB invalidation:
  7606. - *
  7607. - *  - invalidate() invalidates the current task TLBs
  7608. - *  - invalidate_all() invalidates all processes TLBs
  7609. - *  - invalidate_task(task) invalidates the specified tasks TLB's
  7610. - *  - invalidate_page(task, vmaddr) invalidates one page
  7611. - */
  7612. -#define invalidate() \
  7613. -    remap_task(current->mm->pgd)
  7614. -#define invalidate_all() invalidate()
  7615. -#define invalidate_task(task) \
  7616. -do { if ((task)->mm == current->mm) invalidate(); } while (0)
  7617. -#define invalidate_page(task,addr) \
  7618. -do { if ((task)->mm == current->mm) invalidate(); } while (0)
  7619. -
  7620. -/* Certain architectures need to do special things when pte's
  7621. - * within a page table are directly modified.  Thus, the following
  7622. - * hook is made available.
  7623. - */
  7624. -#define set_pte(pteptr, pteval) ((*(pteptr)) = (pteval))
  7625. -
  7626. -/* to align the pointer to the (next) page boundary */
  7627. -#define PAGE_ALIGN(addr)    (((addr)+PAGE_SIZE-1)&PAGE_MASK)
  7628. -
  7629. -/* This handles the memory map.. */
  7630. -#define PAGE_OFFSET        0x02000000
  7631. -#define MAP_NR(addr)        (((unsigned long)(addr) - PAGE_OFFSET) >> PAGE_SHIFT)
  7632. -
  7633. -typedef struct {
  7634. -    unsigned count:24,
  7635. -         age:6,
  7636. -         dirty:1,
  7637. -         reserved:1;
  7638. -} mem_map_t;
  7639. -
  7640. -#endif /* __KERNEL__ */
  7641. -
  7642. -#endif /* _ARM_PAGE_H */
  7643. -
  7644. +#include <asm/proc/page.h>
  7645. diff -urN linux.store/linux/include/asm-arm/param.h linux/include/asm-arm/param.h
  7646. --- linux.store/linux/include/asm-arm/param.h    Sun Feb 11 09:32:55 1996
  7647. +++ linux/include/asm-arm/param.h    Sun Feb 11 09:32:55 1996
  7648. @@ -1,21 +1 @@
  7649. -#ifndef __ASM_ARM_PARAM_H
  7650. -#define __ASM_ARM_PARAM_H
  7651. -
  7652. -#ifndef HZ
  7653. -#define HZ 100
  7654. -#endif
  7655. -
  7656. -#define EXEC_PAGESIZE   32768
  7657. -
  7658. -#ifndef NGROUPS
  7659. -#define NGROUPS         32
  7660. -#endif
  7661. -
  7662. -#ifndef NOGROUP
  7663. -#define NOGROUP         (-1)
  7664. -#endif
  7665. -
  7666. -#define MAXHOSTNAMELEN  64      /* max length of hostname */
  7667. -
  7668. -#endif
  7669. -
  7670. +#include <asm/proc/param.h>
  7671. diff -urN linux.store/linux/include/asm-arm/pgtable.h linux/include/asm-arm/pgtable.h
  7672. --- linux.store/linux/include/asm-arm/pgtable.h    Sun Feb 11 09:32:55 1996
  7673. +++ linux/include/asm-arm/pgtable.h    Sun Feb 11 09:32:55 1996
  7674. @@ -1,285 +1 @@
  7675. -#ifndef __ASM_ARM_PGTABLE_H
  7676. -#define __ASM_ARM_PGTABLE_H
  7677. -
  7678. -/* PMD_SHIFT determines the size of the area a second-level page table can map */
  7679. -#define PMD_SHIFT       PAGE_SHIFT
  7680. -#define PMD_SIZE        (1UL << PMD_SHIFT)
  7681. -#define PMD_MASK        (~(PMD_SIZE-1))
  7682. -
  7683. -/* PGDIR_SHIFT determines what a third-level page table entry can map */
  7684. -#define PGDIR_SHIFT     PAGE_SHIFT
  7685. -#define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
  7686. -#define PGDIR_MASK      (~(PGDIR_SIZE-1))
  7687. -
  7688. -/*
  7689. - * entries per page directory level: the i386 is two-level, so
  7690. - * we don't really have any PMD directory physically.
  7691. - */
  7692. -#define PTRS_PER_PTE    1
  7693. -#define PTRS_PER_PMD    1
  7694. -#define PTRS_PER_PGD    1024
  7695. -
  7696. -/* Just any arbitrary offset to the start of the vmalloc VM area: the
  7697. - * current 8MB value just means that there will be a 8MB "hole" after the
  7698. - * physical memory until the kernel virtual memory starts.  That means that
  7699. - * any out-of-bounds memory accesses will hopefully be caught.
  7700. - * The vmalloc() routines leaves a hole of 4kB between each vmalloced
  7701. - * area for the same reason. ;)
  7702. - */
  7703. -#define VMALLOC_START    0x01A00000
  7704. -#define VMALLOC_VMADDR(x) ((unsigned long)(x))
  7705. -
  7706. -#define _PAGE_PRESENT   0x001
  7707. -#define _PAGE_RW        0x002
  7708. -#define _PAGE_USER      0x004
  7709. -#define _PAGE_PCD       0x010
  7710. -#define _PAGE_ACCESSED  0x020
  7711. -#define _PAGE_DIRTY     0x040
  7712. -#define _PAGE_COW       0x200   /* implemented in software (one of the AVL bits) */
  7713. -
  7714. -#define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
  7715. -#define _PAGE_CHG_MASK  (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
  7716. -
  7717. -#define PAGE_NONE       __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED)
  7718. -#define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
  7719. -#define PAGE_COPY       __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_COW)
  7720. -#define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
  7721. -#define PAGE_KERNEL     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
  7722. -
  7723. -/*
  7724. - * The i386 can't do page protection for execute, and considers that the same are read.
  7725. - * Also, write permissions imply read permissions. This is the closest we can get..
  7726. - */
  7727. -#define __P000  PAGE_NONE
  7728. -#define __P001  PAGE_READONLY
  7729. -#define __P010  PAGE_COPY
  7730. -#define __P011  PAGE_COPY
  7731. -#define __P100  PAGE_READONLY
  7732. -#define __P101  PAGE_READONLY
  7733. -#define __P110  PAGE_COPY
  7734. -#define __P111  PAGE_COPY
  7735. -
  7736. -#define __S000  PAGE_NONE
  7737. -#define __S001  PAGE_READONLY
  7738. -#define __S010  PAGE_SHARED
  7739. -#define __S011  PAGE_SHARED
  7740. -#define __S100  PAGE_READONLY
  7741. -#define __S101  PAGE_READONLY
  7742. -#define __S110  PAGE_SHARED
  7743. -#define __S111  PAGE_SHARED
  7744. -
  7745. -/*
  7746. - * Define this if things work differently on a i386 and a i486:
  7747. - * it will (on a i486) warn about kernel memory accesses that are
  7748. - * done without a 'verify_area(VERIFY_WRITE,..)'
  7749. - */
  7750. -#undef CONFIG_TEST_VERIFY_AREA
  7751. -
  7752. -#ifndef not_yet_checked
  7753. -/* page table for 0-4MB for everybody */
  7754. -extern unsigned long pg0[1024];
  7755. -#endif
  7756. -
  7757. -/*
  7758. - * BAD_PAGE is used for a bogus page.
  7759. - *
  7760. - * ZERO_PAGE is a global shared page that is always zero: used
  7761. - * for zero-mapped memory areas etc..
  7762. - */
  7763. -extern pte_t __bad_page(void);
  7764. -extern unsigned long __zero_page(void);
  7765. -
  7766. -#define BAD_PAGE __bad_page()
  7767. -#define ZERO_PAGE __zero_page()
  7768. -
  7769. -/* number of bits that fit into a memory pointer */
  7770. -#define BITS_PER_PTR                    (8*sizeof(unsigned long))
  7771. -
  7772. -/* to align the pointer to a pointer address */
  7773. -#define PTR_MASK                        (~(sizeof(void*)-1))
  7774. -
  7775. -/* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
  7776. -/* 64-bit machines, beware!  SRB. */
  7777. -#define SIZEOF_PTR_LOG2                 2
  7778. -
  7779. -/* to set the page-dir */
  7780. -#define SET_PAGE_DIR(tsk,pgdir) \
  7781. -do { \
  7782. -    if ((tsk) == current) \
  7783. -        remap_task((pgdir)); \
  7784. -} while (0)
  7785. -
  7786. -extern unsigned long physical_start;
  7787. -extern unsigned long physical_end;
  7788. -
  7789. -extern inline int pte_none(pte_t pte)           { return !pte_val(pte); }
  7790. -extern inline int pte_present(pte_t pte)        { return pte_val(pte) & _PAGE_PRESENT; }
  7791. -extern inline int pte_inuse(pte_t *ptep)        { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
  7792. -extern inline void pte_clear(pte_t *ptep)       { pte_val(*ptep) = 0; }
  7793. -extern inline void pte_reuse(pte_t * ptep)
  7794. -{
  7795. -    if (!mem_map[MAP_NR(ptep)].reserved)
  7796. -        mem_map[MAP_NR(ptep)].count++;
  7797. -}
  7798. -
  7799. -extern inline int pmd_none(pmd_t pmd)           { return 0; }
  7800. -extern inline int pmd_bad(pmd_t pmd)            { return 0; }
  7801. -extern inline int pmd_present(pmd_t pmd)        { return 1; }
  7802. -extern inline int pmd_inuse(pmd_t *pmdp)        { return 0; }
  7803. -extern inline void pmd_clear(pmd_t * pmdp)      { }
  7804. -extern inline void pmd_reuse(pmd_t * pmdp)      { }
  7805. -
  7806. -
  7807. -/*
  7808. - * The "pgd_xxx()" functions here are trivial for a folded two-level
  7809. - * setup: the pgd is never bad, and a pmd always exists (as it's folded
  7810. - * into the pgd entry)
  7811. - */
  7812. -extern inline int pgd_none(pgd_t pgd)           { return 0; }
  7813. -extern inline int pgd_bad(pgd_t pgd)            { return 0; }
  7814. -extern inline int pgd_present(pgd_t pgd)        { return 1; }
  7815. -extern inline int pgd_inuse(pgd_t * pgdp)       { return 0; }
  7816. -extern inline void pgd_clear(pgd_t * pgdp)      { }
  7817. -
  7818. -/*
  7819. - * The following only work if pte_present() is true.
  7820. - * Undefined behaviour if not..
  7821. - */
  7822. -extern inline int pte_read(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
  7823. -extern inline int pte_write(pte_t pte)          { return pte_val(pte) & _PAGE_RW; }
  7824. -extern inline int pte_exec(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
  7825. -extern inline int pte_dirty(pte_t pte)          { return pte_val(pte) & _PAGE_DIRTY; }
  7826. -extern inline int pte_young(pte_t pte)          { return pte_val(pte) & _PAGE_ACCESSED; }
  7827. -extern inline int pte_cow(pte_t pte)            { return pte_val(pte) & _PAGE_COW; }
  7828. -
  7829. -extern inline pte_t pte_wrprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_RW; return pte; }
  7830. -extern inline pte_t pte_rdprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_USER; return pte; }
  7831. -extern inline pte_t pte_exprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_USER; return pte; }
  7832. -extern inline pte_t pte_mkclean(pte_t pte)      { pte_val(pte) &= ~_PAGE_DIRTY; return pte; }
  7833. -extern inline pte_t pte_mkold(pte_t pte)        { pte_val(pte) &= ~_PAGE_ACCESSED; return pte; }
  7834. -extern inline pte_t pte_uncow(pte_t pte)        { pte_val(pte) &= ~_PAGE_COW; return pte; }
  7835. -extern inline pte_t pte_mkwrite(pte_t pte)      { pte_val(pte) |= _PAGE_RW; return pte; }
  7836. -extern inline pte_t pte_mkread(pte_t pte)       { pte_val(pte) |= _PAGE_USER; return pte; }
  7837. -extern inline pte_t pte_mkexec(pte_t pte)       { pte_val(pte) |= _PAGE_USER; return pte; }
  7838. -extern inline pte_t pte_mkdirty(pte_t pte)      { pte_val(pte) |= _PAGE_DIRTY; return pte; }
  7839. -extern inline pte_t pte_mkyoung(pte_t pte)      { pte_val(pte) |= _PAGE_ACCESSED; return pte; }
  7840. -extern inline pte_t pte_mkcow(pte_t pte)        { pte_val(pte) |= _PAGE_COW; return pte; }
  7841. -
  7842. -/*
  7843. - * Conversion functions: convert a page and protection to a page entry,
  7844. - * and a page entry and page directory to the page they refer to.
  7845. - */
  7846. -extern inline pte_t mk_pte(unsigned long page, pgprot_t pgprot)
  7847. -{ pte_t pte; pte_val(pte) = page | pgprot_val(pgprot); return pte; }
  7848. -
  7849. -extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  7850. -{ pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot); return pte; }
  7851. -
  7852. -extern inline unsigned long pte_page(pte_t pte)
  7853. -{ return pte_val(pte) & PAGE_MASK; }
  7854. -
  7855. -extern inline unsigned long pmd_page(pmd_t pmd)
  7856. -{ return pmd_val(pmd) & PAGE_MASK; }
  7857. -
  7858. -/* to find an entry in a page-table-directory */
  7859. -extern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
  7860. -{
  7861. -        return mm->pgd + (address >> PGDIR_SHIFT);
  7862. -}
  7863. -
  7864. -/* Find an entry in the second-level page table.. */
  7865. -extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
  7866. -{
  7867. -        return (pmd_t *) dir;
  7868. -}
  7869. -
  7870. -/* Find an entry in the third-level page table.. */
  7871. -extern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
  7872. -{
  7873. -        return (pte_t *) dir;
  7874. -}
  7875. -
  7876. -/*
  7877. - * Allocate and free page tables. The xxx_kernel() versions are
  7878. - * used to allocate a kernel page table - this turns on ASN bits
  7879. - * if any, and marks the page tables reserved.
  7880. - */
  7881. -extern inline void pte_free_kernel(pte_t * pte)
  7882. -{
  7883. -    pte_val(*pte) = 0;
  7884. -}
  7885. -
  7886. -extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
  7887. -{
  7888. -    return (pte_t *) pmd;
  7889. -}
  7890. -
  7891. -/*
  7892. - * allocating and freeing a pmd is trivial: the 1-entry pmd is
  7893. - * inside the pgd, so has no extra memory associated with it.
  7894. - */
  7895. -extern inline void pmd_free_kernel(pmd_t * pmd)
  7896. -{
  7897. -}
  7898. -
  7899. -extern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
  7900. -{
  7901. -        return (pmd_t *) pgd;
  7902. -}
  7903. -
  7904. -extern inline void pte_free(pte_t * pte)
  7905. -{
  7906. -}
  7907. -
  7908. -extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
  7909. -{
  7910. -    return (pte_t *) pmd;
  7911. -}
  7912. -
  7913. -/*
  7914. - * allocating and freeing a pmd is trivial: the 1-entry pmd is
  7915. - * inside the pgd, so has no extra memory associated with it.
  7916. - */
  7917. -extern inline void pmd_free(pmd_t * pmd)
  7918. -{
  7919. -}
  7920. -
  7921. -extern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
  7922. -{
  7923. -        return (pmd_t *) pgd;
  7924. -}
  7925. -
  7926. -extern inline void pgd_free(pgd_t * pgd)
  7927. -{
  7928. -    extern void kfree(void *);
  7929. -    kfree((void *)pgd);
  7930. -}
  7931. -
  7932. -extern inline pgd_t * pgd_alloc(void)
  7933. -{
  7934. -    pgd_t *pgd;
  7935. -    extern void *kmalloc(unsigned int, int);
  7936. -    
  7937. -        pgd = (pgd_t *) kmalloc(32*1024*1024*4/PAGE_SIZE, GFP_KERNEL);
  7938. -        memset(pgd, 0, 32*1024*1024*4/PAGE_SIZE);
  7939. -
  7940. -        return pgd;
  7941. -}
  7942. -
  7943. -extern pgd_t swapper_pg_dir[1024];
  7944. -
  7945. -/*
  7946. - * The i386 doesn't have any external MMU info: the kernel page
  7947. - * tables contain all the necessary information.
  7948. - */
  7949. -extern inline void update_mmu_cache(struct vm_area_struct * vma,
  7950. -        unsigned long address, pte_t pte)
  7951. -{
  7952. -}
  7953. -
  7954. -#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
  7955. -#define SWP_OFFSET(entry) ((entry) >> 8)
  7956. -#define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) <<  8))
  7957. -
  7958. -#endif /* _ARM_PAGE_H */
  7959. -
  7960. +#include <asm/proc/pgtable.h>
  7961. diff -urN linux.store/linux/include/asm-arm/proc-arm2/assembler.h linux/include/asm-arm/proc-arm2/assembler.h
  7962. --- linux.store/linux/include/asm-arm/proc-arm2/assembler.h    Thu Jan  1 01:00:00 1970
  7963. +++ linux/include/asm-arm/proc-arm2/assembler.h    Sun Feb 11 09:32:56 1996
  7964. @@ -0,0 +1,34 @@
  7965. +/*
  7966. + * linux/asm/proc-arm2/assembler.h
  7967. + *
  7968. + * Copyright (C) 1996 Russell King
  7969. + *
  7970. + * This file contains arm architecture specific defines
  7971. + * for the different processors
  7972. + */
  7973. +
  7974. +#define LOADREGS(cond, base, reglist...)\
  7975. +    ldm##cond    base,reglist^
  7976. +
  7977. +#define RETINSTR(instr, regs...)\
  7978. +    instr##s    regs
  7979. +
  7980. +#define MODENOP\
  7981. +    mov    r0, r0
  7982. +
  7983. +#define SAVEIRQS
  7984. +#define RESTOREIRQS
  7985. +
  7986. +#define DISABLEIRQS\
  7987. +    teqp    pc, #0x08000003
  7988. +
  7989. +#define ENABLEIRQS\
  7990. +    teqp    pc, #0x00000003
  7991. +
  7992. +#define USERMODE\
  7993. +    teqp    pc, #0x00000000;\
  7994. +    mov    r0, r0
  7995. +
  7996. +#define SVCMODE\
  7997. +    teqp    pc, #0x00000003;\
  7998. +    mov    r0, r0
  7999. diff -urN linux.store/linux/include/asm-arm/proc-arm2/bugs.h linux/include/asm-arm/proc-arm2/bugs.h
  8000. --- linux.store/linux/include/asm-arm/proc-arm2/bugs.h    Thu Jan  1 01:00:00 1970
  8001. +++ linux/include/asm-arm/proc-arm2/bugs.h    Sun Feb 11 09:32:54 1996
  8002. @@ -0,0 +1,17 @@
  8003. +/*
  8004. + *  include/asm-arm/bugs.h
  8005. + *
  8006. + *  Copyright (C) 1995  Russell King
  8007. + */
  8008. +
  8009. +/*
  8010. + * This is included by init/main.c to check for architecture-dependent bugs.
  8011. + *
  8012. + * Needs:
  8013. + *      void check_bugs(void);
  8014. + */
  8015. +         
  8016. +static inline void check_bugs(void)
  8017. +{
  8018. +}
  8019. +
  8020. diff -urN linux.store/linux/include/asm-arm/proc-arm2/page.h linux/include/asm-arm/proc-arm2/page.h
  8021. --- linux.store/linux/include/asm-arm/proc-arm2/page.h    Thu Jan  1 01:00:00 1970
  8022. +++ linux/include/asm-arm/proc-arm2/page.h    Wed Mar 13 22:26:38 1996
  8023. @@ -0,0 +1,105 @@
  8024. +/*
  8025. + * linux/include/asm-arm/proc-arm2/page.h
  8026. + *
  8027. + * Copyright (C) 1996 Russell King
  8028. + */
  8029. +
  8030. +#ifndef __ASM_PROC_PAGE_H
  8031. +#define __ASM_PROC_PAGE_H
  8032. +
  8033. +#include <linux/config.h>
  8034. +
  8035. +/* PAGE_SHIFT determines the page size */
  8036. +#define PAGE_SHIFT    15
  8037. +
  8038. +#define LOGICAL_END    0x02000000
  8039. +
  8040. +#define PAGE_SIZE       (1UL << PAGE_SHIFT)
  8041. +#define PAGE_MASK       (~(PAGE_SIZE-1))
  8042. +
  8043. +#ifdef __KERNEL__
  8044. +
  8045. +#define CONFIG_STRICT_MM_TYPECHECKS
  8046. +
  8047. +#ifdef CONFIG_STRICT_MM_TYPECHECKS
  8048. +/*
  8049. + * These are used to make use of C type-checking..
  8050. + */
  8051. +typedef struct { unsigned long pte; } pte_t;
  8052. +typedef struct { unsigned long pmd; } pmd_t;
  8053. +typedef struct { unsigned long pgd; } pgd_t;
  8054. +typedef struct { unsigned long pgprot; } pgprot_t;
  8055. +
  8056. +#define pte_val(x)      ((x).pte)
  8057. +#define pmd_val(x)      ((x).pmd)
  8058. +#define pgd_val(x)      ((x).pgd)
  8059. +#define pgprot_val(x)   ((x).pgprot)
  8060. +
  8061. +#define __pte(x)        ((pte_t) { (x) } )
  8062. +#define __pmd(x)        ((pmd_t) { (x) } )
  8063. +#define __pgd(x)        ((pgd_t) { (x) } )
  8064. +#define __pgprot(x)     ((pgprot_t) { (x) } )
  8065. +
  8066. +#else
  8067. +/*
  8068. + * .. while these make it easier on the compiler
  8069. + */
  8070. +typedef unsigned long pte_t;
  8071. +typedef unsigned long pmd_t;
  8072. +typedef unsigned long pgd_t;
  8073. +typedef unsigned long pgprot_t;
  8074. +
  8075. +#define pte_val(x)      (x)
  8076. +#define pmd_val(x)      (x)
  8077. +#define pgd_val(x)      (x)
  8078. +#define pgprot_val(x)   (x)
  8079. +
  8080. +#define __pte(x)        (x)
  8081. +#define __pmd(x)        (x)
  8082. +#define __pgd(x)        (x)
  8083. +#define __pgprot(x)     (x)
  8084. +
  8085. +#endif
  8086. +
  8087. +extern void remap_task (pgd_t *);
  8088. +
  8089. +/*
  8090. + * TLB invalidation:
  8091. + *
  8092. + *  - invalidate() invalidates the current task TLBs
  8093. + *  - invalidate_all() invalidates all processes TLBs
  8094. + *  - invalidate_task(task) invalidates the specified tasks TLB's
  8095. + *  - invalidate_page(task, vmaddr) invalidates one page
  8096. + */
  8097. +#define invalidate() \
  8098. +    remap_task(current->mm->pgd)
  8099. +#define invalidate_all() invalidate()
  8100. +#define invalidate_task(task) \
  8101. +do { if ((task)->mm == current->mm) invalidate(); } while (0)
  8102. +#define invalidate_page(task,addr) \
  8103. +do { if ((task)->mm == current->mm) invalidate(); } while (0)
  8104. +
  8105. +/* Certain architectures need to do special things when pte's
  8106. + * within a page table are directly modified.  Thus, the following
  8107. + * hook is made available.
  8108. + */
  8109. +#define set_pte(pteptr, pteval) ((*(pteptr)) = (pteval))
  8110. +
  8111. +/* to align the pointer to the (next) page boundary */
  8112. +#define PAGE_ALIGN(addr)    (((addr)+PAGE_SIZE-1)&PAGE_MASK)
  8113. +
  8114. +/* This handles the memory map.. */
  8115. +#define PAGE_OFFSET        0x02000000
  8116. +#define MAP_NR(addr)        (((unsigned long)(addr) - PAGE_OFFSET) >> PAGE_SHIFT)
  8117. +
  8118. +typedef struct {
  8119. +    unsigned count:24,
  8120. +         age:6,
  8121. +         dirty:1,
  8122. +         reserved:1;
  8123. +} mem_map_t;
  8124. +
  8125. +#endif /* __KERNEL__ */
  8126. +
  8127. +#endif /* __ASM_PROC_PAGE_H */
  8128. +
  8129. diff -urN linux.store/linux/include/asm-arm/proc-arm2/param.h linux/include/asm-arm/proc-arm2/param.h
  8130. --- linux.store/linux/include/asm-arm/proc-arm2/param.h    Thu Jan  1 01:00:00 1970
  8131. +++ linux/include/asm-arm/proc-arm2/param.h    Sun Feb 11 09:32:56 1996
  8132. @@ -0,0 +1,26 @@
  8133. +/*
  8134. + * linux/include/asm-arm/proc-arm2/param.h
  8135. + *
  8136. + * Copyright (C) 1996 Russell King
  8137. + */
  8138. +
  8139. +#ifndef __ASM_PROC_PARAM_H
  8140. +#define __ASM_PROC_PARAM_H
  8141. +
  8142. +#ifndef HZ
  8143. +#define HZ 100
  8144. +#endif
  8145. +
  8146. +#define EXEC_PAGESIZE   32768
  8147. +
  8148. +#ifndef NGROUPS
  8149. +#define NGROUPS         32
  8150. +#endif
  8151. +
  8152. +#ifndef NOGROUP
  8153. +#define NOGROUP         (-1)
  8154. +#endif
  8155. +
  8156. +#define MAXHOSTNAMELEN  64      /* max length of hostname */
  8157. +
  8158. +#endif
  8159. diff -urN linux.store/linux/include/asm-arm/proc-arm2/pgtable.h linux/include/asm-arm/proc-arm2/pgtable.h
  8160. --- linux.store/linux/include/asm-arm/proc-arm2/pgtable.h    Thu Jan  1 01:00:00 1970
  8161. +++ linux/include/asm-arm/proc-arm2/pgtable.h    Sun Feb 11 09:32:56 1996
  8162. @@ -0,0 +1,291 @@
  8163. +/*
  8164. + * linux/include/asm-arm/proc-arm2/pgtable.h
  8165. + *
  8166. + * Copyright (C) 1996 Russell King
  8167. + */
  8168. +
  8169. +#ifndef __ASM_PROC_PGTABLE_H
  8170. +#define __ASM_PROC_PGTABLE_H
  8171. +
  8172. +/* PMD_SHIFT determines the size of the area a second-level page table can map */
  8173. +#define PMD_SHIFT       PAGE_SHIFT
  8174. +#define PMD_SIZE        (1UL << PMD_SHIFT)
  8175. +#define PMD_MASK        (~(PMD_SIZE-1))
  8176. +
  8177. +/* PGDIR_SHIFT determines what a third-level page table entry can map */
  8178. +#define PGDIR_SHIFT     PAGE_SHIFT
  8179. +#define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
  8180. +#define PGDIR_MASK      (~(PGDIR_SIZE-1))
  8181. +
  8182. +/*
  8183. + * entries per page directory level: the i386 is two-level, so
  8184. + * we don't really have any PMD directory physically.
  8185. + */
  8186. +#define PTRS_PER_PTE    1
  8187. +#define PTRS_PER_PMD    1
  8188. +#define PTRS_PER_PGD    1024
  8189. +
  8190. +/* Just any arbitrary offset to the start of the vmalloc VM area: the
  8191. + * current 8MB value just means that there will be a 8MB "hole" after the
  8192. + * physical memory until the kernel virtual memory starts.  That means that
  8193. + * any out-of-bounds memory accesses will hopefully be caught.
  8194. + * The vmalloc() routines leaves a hole of 4kB between each vmalloced
  8195. + * area for the same reason. ;)
  8196. + */
  8197. +#define VMALLOC_START    0x01A00000
  8198. +#define VMALLOC_VMADDR(x) ((unsigned long)(x))
  8199. +
  8200. +#define _PAGE_PRESENT   0x001
  8201. +#define _PAGE_RW        0x002
  8202. +#define _PAGE_USER      0x004
  8203. +#define _PAGE_PCD       0x010
  8204. +#define _PAGE_ACCESSED  0x020
  8205. +#define _PAGE_DIRTY     0x040
  8206. +#define _PAGE_COW       0x200   /* implemented in software (one of the AVL bits) */
  8207. +
  8208. +#define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
  8209. +#define _PAGE_CHG_MASK  (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
  8210. +
  8211. +#define PAGE_NONE       __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED)
  8212. +#define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
  8213. +#define PAGE_COPY       __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_COW)
  8214. +#define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
  8215. +#define PAGE_KERNEL     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
  8216. +
  8217. +/*
  8218. + * The i386 can't do page protection for execute, and considers that the same are read.
  8219. + * Also, write permissions imply read permissions. This is the closest we can get..
  8220. + */
  8221. +#define __P000  PAGE_NONE
  8222. +#define __P001  PAGE_READONLY
  8223. +#define __P010  PAGE_COPY
  8224. +#define __P011  PAGE_COPY
  8225. +#define __P100  PAGE_READONLY
  8226. +#define __P101  PAGE_READONLY
  8227. +#define __P110  PAGE_COPY
  8228. +#define __P111  PAGE_COPY
  8229. +
  8230. +#define __S000  PAGE_NONE
  8231. +#define __S001  PAGE_READONLY
  8232. +#define __S010  PAGE_SHARED
  8233. +#define __S011  PAGE_SHARED
  8234. +#define __S100  PAGE_READONLY
  8235. +#define __S101  PAGE_READONLY
  8236. +#define __S110  PAGE_SHARED
  8237. +#define __S111  PAGE_SHARED
  8238. +
  8239. +/*
  8240. + * Define this if things work differently on a i386 and a i486:
  8241. + * it will (on a i486) warn about kernel memory accesses that are
  8242. + * done without a 'verify_area(VERIFY_WRITE,..)'
  8243. + */
  8244. +#undef CONFIG_TEST_VERIFY_AREA
  8245. +
  8246. +#ifndef not_yet_checked
  8247. +/* page table for 0-4MB for everybody */
  8248. +extern unsigned long pg0[1024];
  8249. +#endif
  8250. +
  8251. +/*
  8252. + * BAD_PAGE is used for a bogus page.
  8253. + *
  8254. + * ZERO_PAGE is a global shared page that is always zero: used
  8255. + * for zero-mapped memory areas etc..
  8256. + */
  8257. +extern pte_t __bad_page(void);
  8258. +extern unsigned long __zero_page(void);
  8259. +
  8260. +#define BAD_PAGE __bad_page()
  8261. +#define ZERO_PAGE __zero_page()
  8262. +
  8263. +/* number of bits that fit into a memory pointer */
  8264. +#define BITS_PER_PTR                    (8*sizeof(unsigned long))
  8265. +
  8266. +/* to align the pointer to a pointer address */
  8267. +#define PTR_MASK                        (~(sizeof(void*)-1))
  8268. +
  8269. +/* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
  8270. +/* 64-bit machines, beware!  SRB. */
  8271. +#define SIZEOF_PTR_LOG2                 2
  8272. +
  8273. +/* to set the page-dir */
  8274. +#define SET_PAGE_DIR(tsk,pgdir) \
  8275. +do { \
  8276. +    if ((tsk) == current) \
  8277. +        remap_task((pgdir)); \
  8278. +} while (0)
  8279. +
  8280. +extern unsigned long physical_start;
  8281. +extern unsigned long physical_end;
  8282. +
  8283. +extern inline int pte_none(pte_t pte)           { return !pte_val(pte); }
  8284. +extern inline int pte_present(pte_t pte)        { return pte_val(pte) & _PAGE_PRESENT; }
  8285. +extern inline int pte_inuse(pte_t *ptep)        { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
  8286. +extern inline void pte_clear(pte_t *ptep)       { pte_val(*ptep) = 0; }
  8287. +extern inline void pte_reuse(pte_t * ptep)
  8288. +{
  8289. +    if (!mem_map[MAP_NR(ptep)].reserved)
  8290. +        mem_map[MAP_NR(ptep)].count++;
  8291. +}
  8292. +
  8293. +extern inline int pmd_none(pmd_t pmd)           { return 0; }
  8294. +extern inline int pmd_bad(pmd_t pmd)            { return 0; }
  8295. +extern inline int pmd_present(pmd_t pmd)        { return 1; }
  8296. +extern inline int pmd_inuse(pmd_t *pmdp)        { return 0; }
  8297. +extern inline void pmd_clear(pmd_t * pmdp)      { }
  8298. +extern inline void pmd_reuse(pmd_t * pmdp)      { }
  8299. +
  8300. +
  8301. +/*
  8302. + * The "pgd_xxx()" functions here are trivial for a folded two-level
  8303. + * setup: the pgd is never bad, and a pmd always exists (as it's folded
  8304. + * into the pgd entry)
  8305. + */
  8306. +extern inline int pgd_none(pgd_t pgd)           { return 0; }
  8307. +extern inline int pgd_bad(pgd_t pgd)            { return 0; }
  8308. +extern inline int pgd_present(pgd_t pgd)        { return 1; }
  8309. +extern inline int pgd_inuse(pgd_t * pgdp)       { return 0; }
  8310. +extern inline void pgd_clear(pgd_t * pgdp)      { }
  8311. +
  8312. +/*
  8313. + * The following only work if pte_present() is true.
  8314. + * Undefined behaviour if not..
  8315. + */
  8316. +extern inline int pte_read(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
  8317. +extern inline int pte_write(pte_t pte)          { return pte_val(pte) & _PAGE_RW; }
  8318. +extern inline int pte_exec(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
  8319. +extern inline int pte_dirty(pte_t pte)          { return pte_val(pte) & _PAGE_DIRTY; }
  8320. +extern inline int pte_young(pte_t pte)          { return pte_val(pte) & _PAGE_ACCESSED; }
  8321. +extern inline int pte_cow(pte_t pte)            { return pte_val(pte) & _PAGE_COW; }
  8322. +
  8323. +extern inline pte_t pte_wrprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_RW; return pte; }
  8324. +extern inline pte_t pte_rdprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_USER; return pte; }
  8325. +extern inline pte_t pte_exprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_USER; return pte; }
  8326. +extern inline pte_t pte_mkclean(pte_t pte)      { pte_val(pte) &= ~_PAGE_DIRTY; return pte; }
  8327. +extern inline pte_t pte_mkold(pte_t pte)        { pte_val(pte) &= ~_PAGE_ACCESSED; return pte; }
  8328. +extern inline pte_t pte_uncow(pte_t pte)        { pte_val(pte) &= ~_PAGE_COW; return pte; }
  8329. +extern inline pte_t pte_mkwrite(pte_t pte)      { pte_val(pte) |= _PAGE_RW; return pte; }
  8330. +extern inline pte_t pte_mkread(pte_t pte)       { pte_val(pte) |= _PAGE_USER; return pte; }
  8331. +extern inline pte_t pte_mkexec(pte_t pte)       { pte_val(pte) |= _PAGE_USER; return pte; }
  8332. +extern inline pte_t pte_mkdirty(pte_t pte)      { pte_val(pte) |= _PAGE_DIRTY; return pte; }
  8333. +extern inline pte_t pte_mkyoung(pte_t pte)      { pte_val(pte) |= _PAGE_ACCESSED; return pte; }
  8334. +extern inline pte_t pte_mkcow(pte_t pte)        { pte_val(pte) |= _PAGE_COW; return pte; }
  8335. +
  8336. +/*
  8337. + * Conversion functions: convert a page and protection to a page entry,
  8338. + * and a page entry and page directory to the page they refer to.
  8339. + */
  8340. +extern inline pte_t mk_pte(unsigned long page, pgprot_t pgprot)
  8341. +{ pte_t pte; pte_val(pte) = page | pgprot_val(pgprot); return pte; }
  8342. +
  8343. +extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  8344. +{ pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot); return pte; }
  8345. +
  8346. +extern inline unsigned long pte_page(pte_t pte)
  8347. +{ return pte_val(pte) & PAGE_MASK; }
  8348. +
  8349. +extern inline unsigned long pmd_page(pmd_t pmd)
  8350. +{ return pmd_val(pmd) & PAGE_MASK; }
  8351. +
  8352. +/* to find an entry in a page-table-directory */
  8353. +extern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
  8354. +{
  8355. +        return mm->pgd + (address >> PGDIR_SHIFT);
  8356. +}
  8357. +
  8358. +/* Find an entry in the second-level page table.. */
  8359. +extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
  8360. +{
  8361. +        return (pmd_t *) dir;
  8362. +}
  8363. +
  8364. +/* Find an entry in the third-level page table.. */
  8365. +extern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
  8366. +{
  8367. +        return (pte_t *) dir;
  8368. +}
  8369. +
  8370. +/*
  8371. + * Allocate and free page tables. The xxx_kernel() versions are
  8372. + * used to allocate a kernel page table - this turns on ASN bits
  8373. + * if any, and marks the page tables reserved.
  8374. + */
  8375. +extern inline void pte_free_kernel(pte_t * pte)
  8376. +{
  8377. +    pte_val(*pte) = 0;
  8378. +}
  8379. +
  8380. +extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
  8381. +{
  8382. +    return (pte_t *) pmd;
  8383. +}
  8384. +
  8385. +/*
  8386. + * allocating and freeing a pmd is trivial: the 1-entry pmd is
  8387. + * inside the pgd, so has no extra memory associated with it.
  8388. + */
  8389. +extern inline void pmd_free_kernel(pmd_t * pmd)
  8390. +{
  8391. +}
  8392. +
  8393. +extern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
  8394. +{
  8395. +        return (pmd_t *) pgd;
  8396. +}
  8397. +
  8398. +extern inline void pte_free(pte_t * pte)
  8399. +{
  8400. +}
  8401. +
  8402. +extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
  8403. +{
  8404. +    return (pte_t *) pmd;
  8405. +}
  8406. +
  8407. +/*
  8408. + * allocating and freeing a pmd is trivial: the 1-entry pmd is
  8409. + * inside the pgd, so has no extra memory associated with it.
  8410. + */
  8411. +extern inline void pmd_free(pmd_t * pmd)
  8412. +{
  8413. +}
  8414. +
  8415. +extern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
  8416. +{
  8417. +        return (pmd_t *) pgd;
  8418. +}
  8419. +
  8420. +extern inline void pgd_free(pgd_t * pgd)
  8421. +{
  8422. +    extern void kfree(void *);
  8423. +    kfree((void *)pgd);
  8424. +}
  8425. +
  8426. +extern inline pgd_t * pgd_alloc(void)
  8427. +{
  8428. +    pgd_t *pgd;
  8429. +    extern void *kmalloc(unsigned int, int);
  8430. +    
  8431. +        pgd = (pgd_t *) kmalloc(32*1024*1024*4/PAGE_SIZE, GFP_KERNEL);
  8432. +        memset(pgd, 0, 32*1024*1024*4/PAGE_SIZE);
  8433. +
  8434. +        return pgd;
  8435. +}
  8436. +
  8437. +extern pgd_t swapper_pg_dir[1024];
  8438. +
  8439. +/*
  8440. + * The i386 doesn't have any external MMU info: the kernel page
  8441. + * tables contain all the necessary information.
  8442. + */
  8443. +extern inline void update_mmu_cache(struct vm_area_struct * vma,
  8444. +        unsigned long address, pte_t pte)
  8445. +{
  8446. +}
  8447. +
  8448. +#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
  8449. +#define SWP_OFFSET(entry) ((entry) >> 8)
  8450. +#define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) <<  8))
  8451. +
  8452. +#endif /* __ASM_PROC_PAGE_H */
  8453. +
  8454. diff -urN linux.store/linux/include/asm-arm/proc-arm2/ptrace.h linux/include/asm-arm/proc-arm2/ptrace.h
  8455. --- linux.store/linux/include/asm-arm/proc-arm2/ptrace.h    Thu Jan  1 01:00:00 1970
  8456. +++ linux/include/asm-arm/proc-arm2/ptrace.h    Sun Feb 11 09:32:56 1996
  8457. @@ -0,0 +1,14 @@
  8458. +/*
  8459. + * linux/include/asm-arm/proc-arm2/ptrace.h
  8460. + *
  8461. + * Copyright (C) 1996 Russell King
  8462. + */
  8463. +
  8464. +#ifndef __ASM_PROC_PTRACE_H
  8465. +#define __ASM_PROC_PTRACE_H
  8466. +
  8467. +#define user_mode(regs)            (((regs)->ARM_pc & 3) == 0)
  8468. +#define instruction_pointer(regs)    ((regs)->ARM_pc & 0x03fffffc)
  8469. +
  8470. +#endif
  8471. +
  8472. diff -urN linux.store/linux/include/asm-arm/proc-arm2/segment.h linux/include/asm-arm/proc-arm2/segment.h
  8473. --- linux.store/linux/include/asm-arm/proc-arm2/segment.h    Thu Jan  1 01:00:00 1970
  8474. +++ linux/include/asm-arm/proc-arm2/segment.h    Sun Feb 11 09:32:56 1996
  8475. @@ -0,0 +1,121 @@
  8476. +/*
  8477. + * linux/include/asm-arm/proc-arm2/segment.h
  8478. + *
  8479. + * Copyright (C) 1996 Russell King
  8480. + */
  8481. +
  8482. +#ifndef __ASM_PROC_SEGMENT_H
  8483. +#define __ASM_PROC_SEGMENT_H
  8484. +
  8485. +static inline void __put_user(unsigned long x, void * y, int size)
  8486. +{
  8487. +    if (IS_USER_SEG) {
  8488. +        switch (size) {
  8489. +            case 1:
  8490. +                __asm__(
  8491. +                " strbt    %0, [%1]\n"
  8492. +                : : "r" (x), "r" (y)
  8493. +                : "lr", "cc");
  8494. +                break;
  8495. +            case 2:
  8496. +                { register unsigned long tmp;
  8497. +                __asm__ __volatile__(
  8498. +                " strbt %1, [%2], #1\n"
  8499. +                " mov   %0, %1, lsr #8\n"
  8500. +                " strbt %0, [%2]\n"
  8501. +                : "=&r" (tmp)
  8502. +                : "r" (x), "r" (y)
  8503. +                : "2", "lr", "cc");
  8504. +                }
  8505. +                break;
  8506. +            case 4:
  8507. +                if ((int)y & 3) {
  8508. +                register unsigned long tmp;
  8509. +                __asm__ __volatile__(
  8510. +                " strbt %1, [%2], #1\n"
  8511. +                " mov   %0, %1, lsr #8\n"
  8512. +                " strbt %0, [%2], #1\n"
  8513. +                " mov   %0, %0, lsr #8\n"
  8514. +                " strbt %0, [%2], #1\n"
  8515. +                " mov   %0, %0, lsr #8\n"
  8516. +                " strbt %0, [%2]\n"
  8517. +                : "=&r" (tmp)
  8518. +                : "r" (x), "r" (y)
  8519. +                : "2", "lr", "cc");
  8520. +                } else {
  8521. +                __asm__(
  8522. +                " strt  %0, [%1]\n"
  8523. +                : : "r" (x), "r" (y)
  8524. +                : "lr", "cc");
  8525. +                }
  8526. +                break;
  8527. +            default:
  8528. +                bad_user_access_length();
  8529. +        }
  8530. +    } else {
  8531. +        switch (size) {
  8532. +            case 1: *(unsigned char *)y = x; break;
  8533. +            case 2: *(unsigned short *)y = x; break;
  8534. +            case 4: *(unsigned long *)y = x; break;
  8535. +            default:
  8536. +                bad_user_access_length();
  8537. +        }
  8538. +    }
  8539. +}
  8540. +
  8541. +static inline unsigned long __get_user(const void *y, int size)
  8542. +{
  8543. +    unsigned long result1, result2;
  8544. +
  8545. +    if (IS_USER_SEG) {
  8546. +        switch (size) {
  8547. +            case 1:
  8548. +                __asm__(
  8549. +                " ldrbt %0, [%1]\n"
  8550. +                : "=r" (result1)
  8551. +                : "r" (y)
  8552. +                : "lr", "cc");
  8553. +                return result1;
  8554. +            case 2:
  8555. +                __asm__(
  8556. +                " ldrbt %0, [%2], #1\n"
  8557. +                " ldrbt %1, [%2]\n"
  8558. +                " orr   %0, %0, %1, lsl #8\n"
  8559. +                : "=&r" (result1), "=r" (result2)
  8560. +                : "r" (y)
  8561. +                : "lr", "cc");
  8562. +                return result1;
  8563. +            case 4:
  8564. +                if ((int)y & 3) {
  8565. +                __asm__(
  8566. +                " ldrt %0, [%2], #4\n"
  8567. +                " ldrt %1, [%2]\n"
  8568. +                : "=&r" (result1), "=r" (result2)
  8569. +                : "r" ((int)y & ~3)
  8570. +                : "lr", "cc");
  8571. +                result1 >>= ((int)y & 3)*8;
  8572. +                return result1 | (result2 << (32-((int)y & 3)*8));
  8573. +                } else {
  8574. +                __asm__(
  8575. +                " ldrt %0, [%1]\n"
  8576. +                : "=r" (result1)
  8577. +                : "r" (y)
  8578. +                : "lr", "cc");
  8579. +                return result1;
  8580. +                }
  8581. +            default:
  8582. +                return bad_user_access_length();
  8583. +        }
  8584. +    } else {
  8585. +        switch (size) {
  8586. +            case 1: return *(unsigned char *)y; break;
  8587. +            case 2: return *(unsigned short *)y; break;
  8588. +            case 4: return *(unsigned long *)y; break;
  8589. +            default:
  8590. +                return bad_user_access_length();
  8591. +        }
  8592. +    }
  8593. +}        
  8594. +
  8595. +#endif /* __ASM_PROC_SEGMENT_H */
  8596. +
  8597. diff -urN linux.store/linux/include/asm-arm/proc-arm2/shmparam.h linux/include/asm-arm/proc-arm2/shmparam.h
  8598. --- linux.store/linux/include/asm-arm/proc-arm2/shmparam.h    Thu Jan  1 01:00:00 1970
  8599. +++ linux/include/asm-arm/proc-arm2/shmparam.h    Sun Feb 11 09:32:56 1996
  8600. @@ -0,0 +1,18 @@
  8601. +/*
  8602. + * linux/include/asm-arm/proc-arm2/shmparam.h
  8603. + *
  8604. + * Copyright (C) 1996 Russell King
  8605. + *
  8606. + * definitions for the shared process memory on the ARM2
  8607. + */
  8608. +
  8609. +#ifndef __ASM_PROC_SHMPARAM_H
  8610. +#define __ASM_PROC_SHMPARAM_H
  8611. +
  8612. +#ifndef SHM_RANGE_START
  8613. +#define SHM_RANGE_START    0x00a00000
  8614. +#define SHM_RANGE_END    0x00c00000
  8615. +#endif
  8616. +
  8617. +#endif
  8618. +
  8619. diff -urN linux.store/linux/include/asm-arm/proc-arm2/system.h linux/include/asm-arm/proc-arm2/system.h
  8620. --- linux.store/linux/include/asm-arm/proc-arm2/system.h    Thu Jan  1 01:00:00 1970
  8621. +++ linux/include/asm-arm/proc-arm2/system.h    Sun Feb 11 09:32:56 1996
  8622. @@ -0,0 +1,138 @@
  8623. +/*
  8624. + * linux/include/asm-arm/proc-arm2/system.h
  8625. + *
  8626. + * Copyright (C) 1996 Russell King
  8627. + */
  8628. +
  8629. +#ifndef __ASM_PROC_SYSTEM_H
  8630. +#define __ASM_PROC_SYSTEM_H
  8631. +
  8632. +static inline unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
  8633. +{
  8634. +    unsigned long temp0, temp1;
  8635. +    switch (size) {
  8636. +        case 1: __asm__ __volatile__(
  8637. +            " mov   %0, pc\n"
  8638. +            " orr   %1, %0, #0x08000000\n"
  8639. +            " teqp  %1, #0\n"
  8640. +            " mov   %1, %3\n"    /* Safe: in case it uses the same reg */
  8641. +            " ldrb  %2, [%4]\n"
  8642. +            " strb  %1, [%4]\n"
  8643. +            " teqp  %0, #0\n"
  8644. +            : "=r" (temp0), "=r" (temp1), "=r" (x)
  8645. +            : "r" (x), "r" (ptr)
  8646. +            : "memory");
  8647. +            break;
  8648. +        case 2: { unsigned long temp0, temp1;
  8649. +            if (((long)ptr) & 1)
  8650. +            {
  8651. +                void *pc;
  8652. +                __asm__("mov\t%0, pc": "=r" (pc));
  8653. +                arm_malalignedptr("xchg", pc, ptr);
  8654. +            }
  8655. +            __asm__ __volatile__(
  8656. +            " mov   %0, pc\n"
  8657. +            " orr   %1, %0, #0x08000000\n"
  8658. +            " teqp  %1, #0\n"
  8659. +            " mov   %1, %3\n"
  8660. +            " ldr    %2, [%4]\n"
  8661. +            " strb  %1, [%4]\n"
  8662. +            " mov   %1, %1, lsr #8\n"
  8663. +            " strb  %1, [%4, #1]\n"
  8664. +            " teqp  %0, #0\n"
  8665. +            : "=r" (temp0), "=r" (temp1), "=r" (x)
  8666. +            : "r" (x), "r" (ptr)
  8667. +            : "memory");
  8668. +            val &= 0xffff;
  8669. +            break;
  8670. +            }
  8671. +        case 4: { unsigned long temp0, temp1;
  8672. +            if (((long)ptr) & 3)
  8673. +            {
  8674. +                void *pc;
  8675. +                __asm__("mov\t%0, pc": "=r" (pc));
  8676. +                arm_malalignedptr("xchg", pc, ptr);
  8677. +            }
  8678. +            __asm__ __volatile__(
  8679. +            " mov   %0, pc\n"
  8680. +            " orr   %1, %0, #0x08000000\n"
  8681. +            " teqp  %1, #0\n"
  8682. +            " mov   %1, %3\n"
  8683. +            " ldr   %2, [%4]\n"
  8684. +            " str   %1, [%4]\n"
  8685. +            " teqp  %0, #0\n"
  8686. +            : "=r" (temp0), "=r" (temp1), "=r" (x)
  8687. +            : "r" (x), "r" (ptr)
  8688. +            : "memory");
  8689. +            }
  8690. +            break;
  8691. +        default:
  8692. +            {
  8693. +                void *pc;
  8694. +                __asm__("mov\t%0, pc": "=r" (pc));
  8695. +                arm_invalidptr("xchg", pc, size);
  8696. +                x = 0;
  8697. +            }
  8698. +    }
  8699. +    return x;
  8700. +}
  8701. +
  8702. +/*
  8703. + * A couple of speedups for the ARM
  8704. + */
  8705. +#define save_flags_cli(x)        \
  8706. +    do {                \
  8707. +      unsigned long temp;        \
  8708. +      __asm__ __volatile__(        \
  8709. +"    mov    %0, pc\n"        \
  8710. +"    orr    %1, %0, #0x08000000\n"    \
  8711. +"    and    %0, %0, #0x0c000000\n"    \
  8712. +"    teqp    %1, #0\n"        \
  8713. +      : "=r" (x), "=r" (temp));    \
  8714. +    } while (0)
  8715. +    
  8716. +
  8717. +#define sti()                \
  8718. +    do {                \
  8719. +      unsigned long temp;        \
  8720. +      __asm__ __volatile__(        \
  8721. +"    mov    %0, pc\n"        \
  8722. +"    bic    %0, %0, #0x08000000\n"    \
  8723. +"    teqp    %0, #0\n"        \
  8724. +      : "=r" (temp)            \
  8725. +      : );                \
  8726. +    } while(0)
  8727. +
  8728. +#define cli()                \
  8729. +    do {                \
  8730. +      unsigned long temp;        \
  8731. +      __asm__ __volatile__(        \
  8732. +"    mov    %0, pc\n"        \
  8733. +"    orr    %0, %0, #0x08000000\n"    \
  8734. +"    teqp    %0, #0\n"        \
  8735. +      : "=r" (temp)            \
  8736. +      : );                \
  8737. +    } while(0)
  8738. +
  8739. +#define save_flags(x)            \
  8740. +    do {                \
  8741. +      __asm__ __volatile__(        \
  8742. +"    mov    %0, pc\n"        \
  8743. +"    and    %0, %0, #0x0c000000\n"    \
  8744. +      : "=r" (x) : );        \
  8745. +    } while (0)
  8746. +
  8747. +#define restore_flags(x)        \
  8748. +    do {                \
  8749. +      unsigned long temp;        \
  8750. +      __asm__ __volatile__(        \
  8751. +"    mov    %0, pc\n"        \
  8752. +"    bic    %0, %0, #0x0c000000\n"    \
  8753. +"    orr    %0, %0, %1\n"        \
  8754. +"    teqp    %0, #0\n"        \
  8755. +      : "=r" (temp)            \
  8756. +      : "r" (x)            \
  8757. +      : "cc");            \
  8758. +    } while (0)
  8759. +
  8760. +#endif
  8761. diff -urN linux.store/linux/include/asm-arm/proc-arm3/assembler.h linux/include/asm-arm/proc-arm3/assembler.h
  8762. --- linux.store/linux/include/asm-arm/proc-arm3/assembler.h    Thu Jan  1 01:00:00 1970
  8763. +++ linux/include/asm-arm/proc-arm3/assembler.h    Sun Feb 11 09:32:54 1996
  8764. @@ -0,0 +1,52 @@
  8765. +/*
  8766. + * linux/asm-arm/proc-arm3/assembler.h
  8767. + *
  8768. + * This file contains arm architecture specific defines
  8769. + * for the different processors
  8770. + */
  8771. +
  8772. +/*
  8773. + * LOADREGS: multiple register load (ldm) with pc in register list
  8774. + *        (takes account of ARM6 not using ^)
  8775. + *
  8776. + * RETINSTR: return instruction: adds the 's' in at the end of the
  8777. + *        instruction if this is not an ARM6
  8778. + *
  8779. + * SAVEIRQS: save IRQ state (not required on ARM2/ARM3 - done
  8780. + *        implicitly
  8781. + *
  8782. + * RESTOREIRQS: restore IRQ state (not required on ARM2/ARM3 - done
  8783. + *        implicitly with ldm ... ^ or movs.
  8784. + *
  8785. + * These next two need thinking about - can't easily use stack... (see system.S)
  8786. + * DISABLEIRQS: disable IRQS in SVC mode
  8787. + *
  8788. + * ENABLEIRQS: enable IRQS in SVC mode
  8789. + *
  8790. + * USERMODE: switch to USER mode
  8791. + *
  8792. + * SVCMODE: switch to SVC mode
  8793. + */
  8794. +
  8795. +#define LOADREGS(cond, base, reglist...)\
  8796. +    ldm##cond    base,reglist^
  8797. +
  8798. +#define RETINSTR(instr, regs...)\
  8799. +    instr##s    regs
  8800. +
  8801. +#define MODENOP
  8802. +
  8803. +#define SAVEIRQS
  8804. +#define RESTOREIRQS
  8805. +
  8806. +#define DISABLEIRQS\
  8807. +    teqp    pc, #0x08000003
  8808. +
  8809. +#define ENABLEIRQS\
  8810. +    teqp    pc, #0x00000003
  8811. +
  8812. +#define USERMODE\
  8813. +    teqp    pc, #0x00000000
  8814. +
  8815. +#define SVCMODE\
  8816. +    teqp    pc, #0x00000003
  8817. diff -urN linux.store/linux/include/asm-arm/proc-arm3/bugs.h linux/include/asm-arm/proc-arm3/bugs.h
  8818. --- linux.store/linux/include/asm-arm/proc-arm3/bugs.h    Thu Jan  1 01:00:00 1970
  8819. +++ linux/include/asm-arm/proc-arm3/bugs.h    Sun Feb 11 09:32:54 1996
  8820. @@ -0,0 +1,17 @@
  8821. +/*
  8822. + *  include/asm-arm/bugs.h
  8823. + *
  8824. + *  Copyright (C) 1995  Russell King
  8825. + */
  8826. +
  8827. +/*
  8828. + * This is included by init/main.c to check for architecture-dependent bugs.
  8829. + *
  8830. + * Needs:
  8831. + *      void check_bugs(void);
  8832. + */
  8833. +         
  8834. +static inline void check_bugs(void)
  8835. +{
  8836. +}
  8837. +
  8838. diff -urN linux.store/linux/include/asm-arm/proc-arm3/page.h linux/include/asm-arm/proc-arm3/page.h
  8839. --- linux.store/linux/include/asm-arm/proc-arm3/page.h    Thu Jan  1 01:00:00 1970
  8840. +++ linux/include/asm-arm/proc-arm3/page.h    Wed Mar 13 22:26:56 1996
  8841. @@ -0,0 +1,105 @@
  8842. +/*
  8843. + * linux/include/asm-arm/proc-arm3/page.h
  8844. + *
  8845. + * Copyright (C) 1995, 1996 Russell King
  8846. + */
  8847. +
  8848. +#ifndef __ASM_PROC_PAGE_H
  8849. +#define __ASM_PROC_PAGE_H
  8850. +
  8851. +#include <linux/config.h>
  8852. +
  8853. +/* PAGE_SHIFT determines the page size */
  8854. +#define PAGE_SHIFT    15
  8855. +
  8856. +#define LOGICAL_END    0x02000000
  8857. +
  8858. +#define PAGE_SIZE       (1UL << PAGE_SHIFT)
  8859. +#define PAGE_MASK       (~(PAGE_SIZE-1))
  8860. +
  8861. +#ifdef __KERNEL__
  8862. +
  8863. +#define CONFIG_STRICT_MM_TYPECHECKS
  8864. +
  8865. +#ifdef CONFIG_STRICT_MM_TYPECHECKS
  8866. +/*
  8867. + * These are used to make use of C type-checking..
  8868. + */
  8869. +typedef struct { unsigned long pte; } pte_t;
  8870. +typedef struct { unsigned long pmd; } pmd_t;
  8871. +typedef struct { unsigned long pgd; } pgd_t;
  8872. +typedef struct { unsigned long pgprot; } pgprot_t;
  8873. +
  8874. +#define pte_val(x)      ((x).pte)
  8875. +#define pmd_val(x)      ((x).pmd)
  8876. +#define pgd_val(x)      ((x).pgd)
  8877. +#define pgprot_val(x)   ((x).pgprot)
  8878. +
  8879. +#define __pte(x)        ((pte_t) { (x) } )
  8880. +#define __pmd(x)        ((pmd_t) { (x) } )
  8881. +#define __pgd(x)        ((pgd_t) { (x) } )
  8882. +#define __pgprot(x)     ((pgprot_t) { (x) } )
  8883. +
  8884. +#else
  8885. +/*
  8886. + * .. while these make it easier on the compiler
  8887. + */
  8888. +typedef unsigned long pte_t;
  8889. +typedef unsigned long pmd_t;
  8890. +typedef unsigned long pgd_t;
  8891. +typedef unsigned long pgprot_t;
  8892. +
  8893. +#define pte_val(x)      (x)
  8894. +#define pmd_val(x)      (x)
  8895. +#define pgd_val(x)      (x)
  8896. +#define pgprot_val(x)   (x)
  8897. +
  8898. +#define __pte(x)        (x)
  8899. +#define __pmd(x)        (x)
  8900. +#define __pgd(x)        (x)
  8901. +#define __pgprot(x)     (x)
  8902. +
  8903. +#endif
  8904. +
  8905. +extern void remap_task (pgd_t *);
  8906. +
  8907. +/*
  8908. + * TLB invalidation:
  8909. + *
  8910. + *  - invalidate() invalidates the current task TLBs
  8911. + *  - invalidate_all() invalidates all processes TLBs
  8912. + *  - invalidate_task(task) invalidates the specified tasks TLB's
  8913. + *  - invalidate_page(task, vmaddr) invalidates one page
  8914. + */
  8915. +#define invalidate() \
  8916. +    remap_task(current->mm->pgd)
  8917. +#define invalidate_all() invalidate()
  8918. +#define invalidate_task(task) \
  8919. +do { if ((task)->mm == current->mm) invalidate(); } while (0)
  8920. +#define invalidate_page(task,addr) \
  8921. +do { if ((task)->mm == current->mm) invalidate(); } while (0)
  8922. +
  8923. +/* Certain architectures need to do special things when pte's
  8924. + * within a page table are directly modified.  Thus, the following
  8925. + * hook is made available.
  8926. + */
  8927. +#define set_pte(pteptr, pteval) ((*(pteptr)) = (pteval))
  8928. +
  8929. +/* to align the pointer to the (next) page boundary */
  8930. +#define PAGE_ALIGN(addr)    (((addr)+PAGE_SIZE-1)&PAGE_MASK)
  8931. +
  8932. +/* This handles the memory map.. */
  8933. +#define PAGE_OFFSET        0x02000000
  8934. +#define MAP_NR(addr)        (((unsigned long)(addr) - PAGE_OFFSET) >> PAGE_SHIFT)
  8935. +
  8936. +typedef struct {
  8937. +    unsigned count:24,
  8938. +         age:6,
  8939. +         dirty:1,
  8940. +         reserved:1;
  8941. +} mem_map_t;
  8942. +
  8943. +#endif /* __KERNEL__ */
  8944. +
  8945. +#endif /* __ASM_PROC_PAGE_H */
  8946. +
  8947. diff -urN linux.store/linux/include/asm-arm/proc-arm3/param.h linux/include/asm-arm/proc-arm3/param.h
  8948. --- linux.store/linux/include/asm-arm/proc-arm3/param.h    Thu Jan  1 01:00:00 1970
  8949. +++ linux/include/asm-arm/proc-arm3/param.h    Sun Feb 11 09:32:54 1996
  8950. @@ -0,0 +1,27 @@
  8951. +/*
  8952. + * linux/include/asm-arm/proc-arm3/param.h
  8953. + *
  8954. + * Copyright (C) 1995, 1996 Russell King
  8955. + */
  8956. +
  8957. +#ifndef __ASM_PROC_PARAM_H
  8958. +#define __ASM_PROC_PARAM_H
  8959. +
  8960. +#ifndef HZ
  8961. +#define HZ 100
  8962. +#endif
  8963. +
  8964. +#define EXEC_PAGESIZE   32768
  8965. +
  8966. +#ifndef NGROUPS
  8967. +#define NGROUPS         32
  8968. +#endif
  8969. +
  8970. +#ifndef NOGROUP
  8971. +#define NOGROUP         (-1)
  8972. +#endif
  8973. +
  8974. +#define MAXHOSTNAMELEN  64      /* max length of hostname */
  8975. +
  8976. +#endif
  8977. +
  8978. diff -urN linux.store/linux/include/asm-arm/proc-arm3/pgtable.h linux/include/asm-arm/proc-arm3/pgtable.h
  8979. --- linux.store/linux/include/asm-arm/proc-arm3/pgtable.h    Thu Jan  1 01:00:00 1970
  8980. +++ linux/include/asm-arm/proc-arm3/pgtable.h    Sun Feb 11 09:32:54 1996
  8981. @@ -0,0 +1,291 @@
  8982. +/*
  8983. + * linux/include/asm-arm/proc-arm3/pgtable.h
  8984. + *
  8985. + * Copyright (C) 1995, 1996 Russell King
  8986. + */
  8987. +
  8988. +#ifndef __ASM_PROC_PGTABLE_H
  8989. +#define __ASM_PROC_PGTABLE_H
  8990. +
  8991. +/* PMD_SHIFT determines the size of the area a second-level page table can map */
  8992. +#define PMD_SHIFT       PAGE_SHIFT
  8993. +#define PMD_SIZE        (1UL << PMD_SHIFT)
  8994. +#define PMD_MASK        (~(PMD_SIZE-1))
  8995. +
  8996. +/* PGDIR_SHIFT determines what a third-level page table entry can map */
  8997. +#define PGDIR_SHIFT     PAGE_SHIFT
  8998. +#define PGDIR_SIZE      (1UL << PGDIR_SHIFT)
  8999. +#define PGDIR_MASK      (~(PGDIR_SIZE-1))
  9000. +
  9001. +/*
  9002. + * entries per page directory level: the i386 is two-level, so
  9003. + * we don't really have any PMD directory physically.
  9004. + */
  9005. +#define PTRS_PER_PTE    1
  9006. +#define PTRS_PER_PMD    1
  9007. +#define PTRS_PER_PGD    1024
  9008. +
  9009. +/* Just any arbitrary offset to the start of the vmalloc VM area: the
  9010. + * current 8MB value just means that there will be a 8MB "hole" after the
  9011. + * physical memory until the kernel virtual memory starts.  That means that
  9012. + * any out-of-bounds memory accesses will hopefully be caught.
  9013. + * The vmalloc() routines leaves a hole of 4kB between each vmalloced
  9014. + * area for the same reason. ;)
  9015. + */
  9016. +#define VMALLOC_START    0x01A00000
  9017. +#define VMALLOC_VMADDR(x) ((unsigned long)(x))
  9018. +
  9019. +#define _PAGE_PRESENT   0x001
  9020. +#define _PAGE_RW        0x002
  9021. +#define _PAGE_USER      0x004
  9022. +#define _PAGE_PCD       0x010
  9023. +#define _PAGE_ACCESSED  0x020
  9024. +#define _PAGE_DIRTY     0x040
  9025. +#define _PAGE_COW       0x200   /* implemented in software (one of the AVL bits) */
  9026. +
  9027. +#define _PAGE_TABLE     (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY)
  9028. +#define _PAGE_CHG_MASK  (PAGE_MASK | _PAGE_ACCESSED | _PAGE_DIRTY)
  9029. +
  9030. +#define PAGE_NONE       __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED)
  9031. +#define PAGE_SHARED     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED)
  9032. +#define PAGE_COPY       __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED | _PAGE_COW)
  9033. +#define PAGE_READONLY   __pgprot(_PAGE_PRESENT | _PAGE_USER | _PAGE_ACCESSED)
  9034. +#define PAGE_KERNEL     __pgprot(_PAGE_PRESENT | _PAGE_RW | _PAGE_DIRTY | _PAGE_ACCESSED)
  9035. +
  9036. +/*
  9037. + * The i386 can't do page protection for execute, and considers that the same are read.
  9038. + * Also, write permissions imply read permissions. This is the closest we can get..
  9039. + */
  9040. +#define __P000  PAGE_NONE
  9041. +#define __P001  PAGE_READONLY
  9042. +#define __P010  PAGE_COPY
  9043. +#define __P011  PAGE_COPY
  9044. +#define __P100  PAGE_READONLY
  9045. +#define __P101  PAGE_READONLY
  9046. +#define __P110  PAGE_COPY
  9047. +#define __P111  PAGE_COPY
  9048. +
  9049. +#define __S000  PAGE_NONE
  9050. +#define __S001  PAGE_READONLY
  9051. +#define __S010  PAGE_SHARED
  9052. +#define __S011  PAGE_SHARED
  9053. +#define __S100  PAGE_READONLY
  9054. +#define __S101  PAGE_READONLY
  9055. +#define __S110  PAGE_SHARED
  9056. +#define __S111  PAGE_SHARED
  9057. +
  9058. +/*
  9059. + * Define this if things work differently on a i386 and a i486:
  9060. + * it will (on a i486) warn about kernel memory accesses that are
  9061. + * done without a 'verify_area(VERIFY_WRITE,..)'
  9062. + */
  9063. +#undef CONFIG_TEST_VERIFY_AREA
  9064. +
  9065. +#ifndef not_yet_checked
  9066. +/* page table for 0-4MB for everybody */
  9067. +extern unsigned long pg0[1024];
  9068. +#endif
  9069. +
  9070. +/*
  9071. + * BAD_PAGE is used for a bogus page.
  9072. + *
  9073. + * ZERO_PAGE is a global shared page that is always zero: used
  9074. + * for zero-mapped memory areas etc..
  9075. + */
  9076. +extern pte_t __bad_page(void);
  9077. +extern unsigned long __zero_page(void);
  9078. +
  9079. +#define BAD_PAGE __bad_page()
  9080. +#define ZERO_PAGE __zero_page()
  9081. +
  9082. +/* number of bits that fit into a memory pointer */
  9083. +#define BITS_PER_PTR                    (8*sizeof(unsigned long))
  9084. +
  9085. +/* to align the pointer to a pointer address */
  9086. +#define PTR_MASK                        (~(sizeof(void*)-1))
  9087. +
  9088. +/* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
  9089. +/* 64-bit machines, beware!  SRB. */
  9090. +#define SIZEOF_PTR_LOG2                 2
  9091. +
  9092. +/* to set the page-dir */
  9093. +#define SET_PAGE_DIR(tsk,pgdir) \
  9094. +do { \
  9095. +    if ((tsk) == current) \
  9096. +        remap_task((pgdir)); \
  9097. +} while (0)
  9098. +
  9099. +extern unsigned long physical_start;
  9100. +extern unsigned long physical_end;
  9101. +
  9102. +extern inline int pte_none(pte_t pte)           { return !pte_val(pte); }
  9103. +extern inline int pte_present(pte_t pte)        { return pte_val(pte) & _PAGE_PRESENT; }
  9104. +extern inline int pte_inuse(pte_t *ptep)        { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
  9105. +extern inline void pte_clear(pte_t *ptep)       { pte_val(*ptep) = 0; }
  9106. +extern inline void pte_reuse(pte_t * ptep)
  9107. +{
  9108. +    if (!mem_map[MAP_NR(ptep)].reserved)
  9109. +        mem_map[MAP_NR(ptep)].count++;
  9110. +}
  9111. +
  9112. +extern inline int pmd_none(pmd_t pmd)           { return 0; }
  9113. +extern inline int pmd_bad(pmd_t pmd)            { return 0; }
  9114. +extern inline int pmd_present(pmd_t pmd)        { return 1; }
  9115. +extern inline int pmd_inuse(pmd_t *pmdp)        { return 0; }
  9116. +extern inline void pmd_clear(pmd_t * pmdp)      { }
  9117. +extern inline void pmd_reuse(pmd_t * pmdp)      { }
  9118. +
  9119. +
  9120. +/*
  9121. + * The "pgd_xxx()" functions here are trivial for a folded two-level
  9122. + * setup: the pgd is never bad, and a pmd always exists (as it's folded
  9123. + * into the pgd entry)
  9124. + */
  9125. +extern inline int pgd_none(pgd_t pgd)           { return 0; }
  9126. +extern inline int pgd_bad(pgd_t pgd)            { return 0; }
  9127. +extern inline int pgd_present(pgd_t pgd)        { return 1; }
  9128. +extern inline int pgd_inuse(pgd_t * pgdp)       { return 0; }
  9129. +extern inline void pgd_clear(pgd_t * pgdp)      { }
  9130. +
  9131. +/*
  9132. + * The following only work if pte_present() is true.
  9133. + * Undefined behaviour if not..
  9134. + */
  9135. +extern inline int pte_read(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
  9136. +extern inline int pte_write(pte_t pte)          { return pte_val(pte) & _PAGE_RW; }
  9137. +extern inline int pte_exec(pte_t pte)           { return pte_val(pte) & _PAGE_USER; }
  9138. +extern inline int pte_dirty(pte_t pte)          { return pte_val(pte) & _PAGE_DIRTY; }
  9139. +extern inline int pte_young(pte_t pte)          { return pte_val(pte) & _PAGE_ACCESSED; }
  9140. +extern inline int pte_cow(pte_t pte)            { return pte_val(pte) & _PAGE_COW; }
  9141. +
  9142. +extern inline pte_t pte_wrprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_RW; return pte; }
  9143. +extern inline pte_t pte_rdprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_USER; return pte; }
  9144. +extern inline pte_t pte_exprotect(pte_t pte)    { pte_val(pte) &= ~_PAGE_USER; return pte; }
  9145. +extern inline pte_t pte_mkclean(pte_t pte)      { pte_val(pte) &= ~_PAGE_DIRTY; return pte; }
  9146. +extern inline pte_t pte_mkold(pte_t pte)        { pte_val(pte) &= ~_PAGE_ACCESSED; return pte; }
  9147. +extern inline pte_t pte_uncow(pte_t pte)        { pte_val(pte) &= ~_PAGE_COW; return pte; }
  9148. +extern inline pte_t pte_mkwrite(pte_t pte)      { pte_val(pte) |= _PAGE_RW; return pte; }
  9149. +extern inline pte_t pte_mkread(pte_t pte)       { pte_val(pte) |= _PAGE_USER; return pte; }
  9150. +extern inline pte_t pte_mkexec(pte_t pte)       { pte_val(pte) |= _PAGE_USER; return pte; }
  9151. +extern inline pte_t pte_mkdirty(pte_t pte)      { pte_val(pte) |= _PAGE_DIRTY; return pte; }
  9152. +extern inline pte_t pte_mkyoung(pte_t pte)      { pte_val(pte) |= _PAGE_ACCESSED; return pte; }
  9153. +extern inline pte_t pte_mkcow(pte_t pte)        { pte_val(pte) |= _PAGE_COW; return pte; }
  9154. +
  9155. +/*
  9156. + * Conversion functions: convert a page and protection to a page entry,
  9157. + * and a page entry and page directory to the page they refer to.
  9158. + */
  9159. +extern inline pte_t mk_pte(unsigned long page, pgprot_t pgprot)
  9160. +{ pte_t pte; pte_val(pte) = page | pgprot_val(pgprot); return pte; }
  9161. +
  9162. +extern inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  9163. +{ pte_val(pte) = (pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot); return pte; }
  9164. +
  9165. +extern inline unsigned long pte_page(pte_t pte)
  9166. +{ return pte_val(pte) & PAGE_MASK; }
  9167. +
  9168. +extern inline unsigned long pmd_page(pmd_t pmd)
  9169. +{ return pmd_val(pmd) & PAGE_MASK; }
  9170. +
  9171. +/* to find an entry in a page-table-directory */
  9172. +extern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
  9173. +{
  9174. +        return mm->pgd + (address >> PGDIR_SHIFT);
  9175. +}
  9176. +
  9177. +/* Find an entry in the second-level page table.. */
  9178. +extern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
  9179. +{
  9180. +        return (pmd_t *) dir;
  9181. +}
  9182. +
  9183. +/* Find an entry in the third-level page table.. */
  9184. +extern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
  9185. +{
  9186. +        return (pte_t *) dir;
  9187. +}
  9188. +
  9189. +/*
  9190. + * Allocate and free page tables. The xxx_kernel() versions are
  9191. + * used to allocate a kernel page table - this turns on ASN bits
  9192. + * if any, and marks the page tables reserved.
  9193. + */
  9194. +extern inline void pte_free_kernel(pte_t * pte)
  9195. +{
  9196. +    pte_val(*pte) = 0;
  9197. +}
  9198. +
  9199. +extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
  9200. +{
  9201. +    return (pte_t *) pmd;
  9202. +}
  9203. +
  9204. +/*
  9205. + * allocating and freeing a pmd is trivial: the 1-entry pmd is
  9206. + * inside the pgd, so has no extra memory associated with it.
  9207. + */
  9208. +extern inline void pmd_free_kernel(pmd_t * pmd)
  9209. +{
  9210. +}
  9211. +
  9212. +extern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
  9213. +{
  9214. +        return (pmd_t *) pgd;
  9215. +}
  9216. +
  9217. +extern inline void pte_free(pte_t * pte)
  9218. +{
  9219. +}
  9220. +
  9221. +extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
  9222. +{
  9223. +    return (pte_t *) pmd;
  9224. +}
  9225. +
  9226. +/*
  9227. + * allocating and freeing a pmd is trivial: the 1-entry pmd is
  9228. + * inside the pgd, so has no extra memory associated with it.
  9229. + */
  9230. +extern inline void pmd_free(pmd_t * pmd)
  9231. +{
  9232. +}
  9233. +
  9234. +extern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
  9235. +{
  9236. +        return (pmd_t *) pgd;
  9237. +}
  9238. +
  9239. +extern inline void pgd_free(pgd_t * pgd)
  9240. +{
  9241. +    extern void kfree(void *);
  9242. +    kfree((void *)pgd);
  9243. +}
  9244. +
  9245. +extern inline pgd_t * pgd_alloc(void)
  9246. +{
  9247. +    pgd_t *pgd;
  9248. +    extern void *kmalloc(unsigned int, int);
  9249. +    
  9250. +        pgd = (pgd_t *) kmalloc(32*1024*1024*4/PAGE_SIZE, GFP_KERNEL);
  9251. +        memset(pgd, 0, 32*1024*1024*4/PAGE_SIZE);
  9252. +
  9253. +        return pgd;
  9254. +}
  9255. +
  9256. +extern pgd_t swapper_pg_dir[1024];
  9257. +
  9258. +/*
  9259. + * The i386 doesn't have any external MMU info: the kernel page
  9260. + * tables contain all the necessary information.
  9261. + */
  9262. +extern inline void update_mmu_cache(struct vm_area_struct * vma,
  9263. +        unsigned long address, pte_t pte)
  9264. +{
  9265. +}
  9266. +
  9267. +#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
  9268. +#define SWP_OFFSET(entry) ((entry) >> 8)
  9269. +#define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) <<  8))
  9270. +
  9271. +#endif /* __ASM_PROC_PAGE_H */
  9272. +
  9273. diff -urN linux.store/linux/include/asm-arm/proc-arm3/ptrace.h linux/include/asm-arm/proc-arm3/ptrace.h
  9274. --- linux.store/linux/include/asm-arm/proc-arm3/ptrace.h    Thu Jan  1 01:00:00 1970
  9275. +++ linux/include/asm-arm/proc-arm3/ptrace.h    Sun Feb 11 09:32:54 1996
  9276. @@ -0,0 +1,14 @@
  9277. +/*
  9278. + * linux/include/asm-arm/proc-arm3/ptrace.h
  9279. + *
  9280. + * Copyright (C) 1996 Russell King
  9281. + */
  9282. +
  9283. +#ifndef __ASM_PROC_PTRACE_H
  9284. +#define __ASM_PROC_PTRACE_H
  9285. +
  9286. +#define user_mode(regs)            (((regs)->ARM_pc & 3) == 0)
  9287. +#define instruction_pointer(regs)    ((regs)->ARM_pc & 0x03fffffc)
  9288. +
  9289. +#endif
  9290. +
  9291. diff -urN linux.store/linux/include/asm-arm/proc-arm3/segment.h linux/include/asm-arm/proc-arm3/segment.h
  9292. --- linux.store/linux/include/asm-arm/proc-arm3/segment.h    Thu Jan  1 01:00:00 1970
  9293. +++ linux/include/asm-arm/proc-arm3/segment.h    Sun Feb 11 09:32:54 1996
  9294. @@ -0,0 +1,121 @@
  9295. +/*
  9296. + * linux/include/asm-arm/proc-arm3/segment.h
  9297. + *
  9298. + * Copyright (C) 1996 Russell King
  9299. + */
  9300. +
  9301. +#ifndef __ASM_PROC_SEGMENT_H
  9302. +#define __ASM_PROC_SEGMENT_H
  9303. +
  9304. +static inline void __put_user(unsigned long x, void * y, int size)
  9305. +{
  9306. +    if (IS_USER_SEG) {
  9307. +        switch (size) {
  9308. +            case 1:
  9309. +                __asm__(
  9310. +                " strbt    %0, [%1]\n"
  9311. +                : : "r" (x), "r" (y)
  9312. +                : "lr", "cc");
  9313. +                break;
  9314. +            case 2:
  9315. +                { register unsigned long tmp;
  9316. +                __asm__ __volatile__(
  9317. +                " strbt %1, [%2], #1\n"
  9318. +                " mov   %0, %1, lsr #8\n"
  9319. +                " strbt %0, [%2]\n"
  9320. +                : "=&r" (tmp)
  9321. +                : "r" (x), "r" (y)
  9322. +                : "2", "lr", "cc");
  9323. +                }
  9324. +                break;
  9325. +            case 4:
  9326. +                if ((int)y & 3) {
  9327. +                register unsigned long tmp;
  9328. +                __asm__ __volatile__(
  9329. +                " strbt %1, [%2], #1\n"
  9330. +                " mov   %0, %1, lsr #8\n"
  9331. +                " strbt %0, [%2], #1\n"
  9332. +                " mov   %0, %0, lsr #8\n"
  9333. +                " strbt %0, [%2], #1\n"
  9334. +                " mov   %0, %0, lsr #8\n"
  9335. +                " strbt %0, [%2]\n"
  9336. +                : "=&r" (tmp)
  9337. +                : "r" (x), "r" (y)
  9338. +                : "2", "lr", "cc");
  9339. +                } else {
  9340. +                __asm__(
  9341. +                " strt  %0, [%1]\n"
  9342. +                : : "r" (x), "r" (y)
  9343. +                : "lr", "cc");
  9344. +                }
  9345. +                break;
  9346. +            default:
  9347. +                bad_user_access_length();
  9348. +        }
  9349. +    } else {
  9350. +        switch (size) {
  9351. +            case 1: *(unsigned char *)y = x; break;
  9352. +            case 2: *(unsigned short *)y = x; break;
  9353. +            case 4: *(unsigned long *)y = x; break;
  9354. +            default:
  9355. +                bad_user_access_length();
  9356. +        }
  9357. +    }
  9358. +}
  9359. +
  9360. +static inline unsigned long __get_user(const void *y, int size)
  9361. +{
  9362. +    unsigned long result1, result2;
  9363. +
  9364. +    if (IS_USER_SEG) {
  9365. +        switch (size) {
  9366. +            case 1:
  9367. +                __asm__(
  9368. +                " ldrbt %0, [%1]\n"
  9369. +                : "=r" (result1)
  9370. +                : "r" (y)
  9371. +                : "lr", "cc");
  9372. +                return result1;
  9373. +            case 2:
  9374. +                __asm__(
  9375. +                " ldrbt %0, [%2], #1\n"
  9376. +                " ldrbt %1, [%2]\n"
  9377. +                " orr   %0, %0, %1, lsl #8\n"
  9378. +                : "=&r" (result1), "=r" (result2)
  9379. +                : "r" (y)
  9380. +                : "lr", "cc");
  9381. +                return result1;
  9382. +            case 4:
  9383. +                if ((int)y & 3) {
  9384. +                __asm__(
  9385. +                " ldrt %0, [%2], #4\n"
  9386. +                " ldrt %1, [%2]\n"
  9387. +                : "=&r" (result1), "=r" (result2)
  9388. +                : "r" ((int)y & ~3)
  9389. +                : "lr", "cc");
  9390. +                result1 >>= ((int)y & 3)*8;
  9391. +                return result1 | (result2 << (32-((int)y & 3)*8));
  9392. +                } else {
  9393. +                __asm__(
  9394. +                " ldrt %0, [%1]\n"
  9395. +                : "=r" (result1)
  9396. +                : "r" (y)
  9397. +                : "lr", "cc");
  9398. +                return result1;
  9399. +                }
  9400. +            default:
  9401. +                return bad_user_access_length();
  9402. +        }
  9403. +    } else {
  9404. +        switch (size) {
  9405. +            case 1: return *(unsigned char *)y; break;
  9406. +            case 2: return *(unsigned short *)y; break;
  9407. +            case 4: return *(unsigned long *)y; break;
  9408. +            default:
  9409. +                return bad_user_access_length();
  9410. +        }
  9411. +    }
  9412. +}        
  9413. +
  9414. +#endif /* __ASM_PROC_SEGMENT_H */
  9415. +
  9416. diff -urN linux.store/linux/include/asm-arm/proc-arm3/shmparam.h linux/include/asm-arm/proc-arm3/shmparam.h
  9417. --- linux.store/linux/include/asm-arm/proc-arm3/shmparam.h    Thu Jan  1 01:00:00 1970
  9418. +++ linux/include/asm-arm/proc-arm3/shmparam.h    Sun Feb 11 09:32:54 1996
  9419. @@ -0,0 +1,18 @@
  9420. +/*
  9421. + * linux/include/asm-arm/proc-arm3/shmparam.h
  9422. + *
  9423. + * Copyright (C) 1996 Russell King
  9424. + *
  9425. + * definitions for the shared process memory on the ARM3
  9426. + */
  9427. +
  9428. +#ifndef __ASM_PROC_SHMPARAM_H
  9429. +#define __ASM_PROC_SHMPARAM_H
  9430. + 
  9431. +#ifndef SHM_RANGE_START
  9432. +#define SHM_RANGE_START    0x00a00000
  9433. +#define SHM_RANGE_END    0x00c00000
  9434. +#endif
  9435. +
  9436. +#endif
  9437. +
  9438. diff -urN linux.store/linux/include/asm-arm/proc-arm3/system.h linux/include/asm-arm/proc-arm3/system.h
  9439. --- linux.store/linux/include/asm-arm/proc-arm3/system.h    Thu Jan  1 01:00:00 1970
  9440. +++ linux/include/asm-arm/proc-arm3/system.h    Sun Feb 11 09:32:54 1996
  9441. @@ -0,0 +1,124 @@
  9442. +/*
  9443. + * linux/include/asm-arm/proc-arm3/system.h
  9444. + *
  9445. + * Copyright (C) 1995, 1996 Russell King
  9446. + */
  9447. +
  9448. +#ifndef __ASM_PROC_SYSTEM_H
  9449. +#define __ASM_PROC_SYSTEM_H
  9450. +
  9451. +static inline unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
  9452. +{
  9453. +    switch (size) {
  9454. +        case 1:
  9455. +            __asm__ __volatile__(
  9456. +            " swpb   %0, %1, [%2]\n\t"
  9457. +            : "=r" (x)
  9458. +            : "r" (x), "r" (ptr)
  9459. +            : "memory");
  9460. +            break;
  9461. +        case 2: { unsigned long temp0, temp1;
  9462. +            if (((long)ptr) & 1)
  9463. +            {
  9464. +                void *pc;
  9465. +                __asm__("mov\t%0, pc": "=r" (pc));
  9466. +                arm_malalignedptr("xchg", pc, ptr);
  9467. +            }
  9468. +            __asm__ __volatile__(
  9469. +            " mov   %0, pc\n"
  9470. +            " orr   %1, %0, #0x08000000\n"
  9471. +            " teqp  %1, #0\n"
  9472. +            " mov   %1, %3\n"
  9473. +            " ldr    %2, [%4]\n"
  9474. +            " strb  %1, [%4]\n"
  9475. +            " mov   %1, %1, lsr #8\n"
  9476. +            " strb  %1, [%4, #1]\n"
  9477. +            " teqp  %0, #0\n"
  9478. +            : "=r" (temp0), "=r" (temp1), "=r" (x)
  9479. +            : "r" (x), "r" (ptr)
  9480. +            : "memory");
  9481. +            x &= 0xffff;
  9482. +            break;
  9483. +            }
  9484. +        case 4: if (((long)ptr) & 3)
  9485. +            {
  9486. +                void *pc;
  9487. +                __asm__("mov\t%0, pc": "=r" (pc));
  9488. +                arm_malalignedptr("xchg", pc, ptr);
  9489. +            }
  9490. +            __asm__ __volatile__(
  9491. +            " swp   %0, %1, [%2]\n"
  9492. +            : "=r" (x)
  9493. +            : "r" (x), "r" (ptr)
  9494. +            : "memory");
  9495. +            break;
  9496. +        default:
  9497. +            {
  9498. +                void *pc;
  9499. +                __asm__("mov\t%0, pc": "=r" (pc));
  9500. +                arm_invalidptr("xchg", pc, size);
  9501. +                x = 0;
  9502. +            }
  9503. +    }
  9504. +    return x;
  9505. +}
  9506. +
  9507. +/*
  9508. + * A couple of speedups for the ARM
  9509. + */
  9510. +#define save_flags_cli(x)        \
  9511. +    do {                \
  9512. +      unsigned long temp;        \
  9513. +      __asm__ __volatile__(        \
  9514. +"    mov    %0, pc\n"        \
  9515. +"    orr    %1, %0, #0x08000000\n"    \
  9516. +"    and    %0, %0, #0x0c000000\n"    \
  9517. +"    teqp    %1, #0\n"        \
  9518. +      : "=r" (x), "=r" (temp));    \
  9519. +    } while (0)
  9520. +    
  9521. +
  9522. +#define sti()                \
  9523. +    do {                \
  9524. +      unsigned long temp;        \
  9525. +      __asm__ __volatile__(        \
  9526. +"    mov    %0, pc\n"        \
  9527. +"    bic    %0, %0, #0x08000000\n"    \
  9528. +"    teqp    %0, #0\n"        \
  9529. +      : "=r" (temp)            \
  9530. +      : );                \
  9531. +    } while(0)
  9532. +
  9533. +#define cli()                \
  9534. +    do {                \
  9535. +      unsigned long temp;        \
  9536. +      __asm__ __volatile__(        \
  9537. +"    mov    %0, pc\n"        \
  9538. +"    orr    %0, %0, #0x08000000\n"    \
  9539. +"    teqp    %0, #0\n"        \
  9540. +      : "=r" (temp)            \
  9541. +      : );                \
  9542. +    } while(0)
  9543. +
  9544. +#define save_flags(x)            \
  9545. +    do {                \
  9546. +      __asm__ __volatile__(        \
  9547. +"    mov    %0, pc\n"        \
  9548. +"    and    %0, %0, #0x0c000000\n"    \
  9549. +      : "=r" (x) : );        \
  9550. +    } while (0)
  9551. +
  9552. +#define restore_flags(x)        \
  9553. +    do {                \
  9554. +      unsigned long temp;        \
  9555. +      __asm__ __volatile__(        \
  9556. +"    mov    %0, pc\n"        \
  9557. +"    bic    %0, %0, #0x0c000000\n"    \
  9558. +"    orr    %0, %0, %1\n"        \
  9559. +"    teqp    %0, #0\n"        \
  9560. +      : "=r" (temp)            \
  9561. +      : "r" (x)            \
  9562. +      : "cc");            \
  9563. +    } while (0)
  9564. +
  9565. +#endif
  9566. diff -urN linux.store/linux/include/asm-arm/proc-arm6/assembler.h linux/include/asm-arm/proc-arm6/assembler.h
  9567. --- linux.store/linux/include/asm-arm/proc-arm6/assembler.h    Thu Jan  1 01:00:00 1970
  9568. +++ linux/include/asm-arm/proc-arm6/assembler.h    Sun Feb 11 09:32:54 1996
  9569. @@ -0,0 +1,45 @@
  9570. +/*
  9571. + * linux/asm/assembler.h
  9572. + *
  9573. + * This file contains arm architecture specific defines
  9574. + * for the different processors
  9575. + */
  9576. +
  9577. +/*
  9578. + * LOADREGS: multiple register load (ldm) with pc in register list
  9579. + *        (takes account of ARM6 not using ^)
  9580. + *
  9581. + * RETINSTR: return instruction: adds the 's' in at the end of the
  9582. + *        instruction if this is not an ARM6
  9583. + *
  9584. + * SAVEIRQS: save IRQ state (not required on ARM2/ARM3 - done
  9585. + *        implicitly
  9586. + *
  9587. + * RESTOREIRQS: restore IRQ state (not required on ARM2/ARM3 - done
  9588. + *        implicitly with ldm ... ^ or movs.
  9589. + *
  9590. + * These next two need thinking about - can't easily use stack... (see system.S)
  9591. + * DISABLEIRQS: disable IRQS in SVC mode
  9592. + *
  9593. + * ENABLEIRQS: enable IRQS in SVC mode
  9594. + *
  9595. + * USERMODE: switch to USER mode
  9596. + *
  9597. + * SVCMODE: switch to SVC mode
  9598. + */
  9599. +
  9600. +#define LOADREGS(cond, base, reglist...)\
  9601. +    ldm##cond    base,reglist
  9602. +
  9603. +#define RETINSTR(instr, regs...)\
  9604. +    instr    regs
  9605. +
  9606. +#define MODENOP
  9607. +
  9608. +#define SAVEIRQS
  9609. +#define RESTOREIRQS
  9610. +
  9611. +#define DISABLEIRQS
  9612. +#define ENABLEIRQS
  9613. +#define USERMODE
  9614. +#define SVCMODE
  9615. diff -urN linux.store/linux/include/asm-arm/proc-arm6/param.h linux/include/asm-arm/proc-arm6/param.h
  9616. --- linux.store/linux/include/asm-arm/proc-arm6/param.h    Thu Jan  1 01:00:00 1970
  9617. +++ linux/include/asm-arm/proc-arm6/param.h    Sun Feb 11 09:32:55 1996
  9618. @@ -0,0 +1,21 @@
  9619. +#ifndef __ASM_ARM_PARAM_H
  9620. +#define __ASM_ARM_PARAM_H
  9621. +
  9622. +#ifndef HZ
  9623. +#define HZ 100
  9624. +#endif
  9625. +
  9626. +#define EXEC_PAGESIZE   32768
  9627. +
  9628. +#ifndef NGROUPS
  9629. +#define NGROUPS         32
  9630. +#endif
  9631. +
  9632. +#ifndef NOGROUP
  9633. +#define NOGROUP         (-1)
  9634. +#endif
  9635. +
  9636. +#define MAXHOSTNAMELEN  64      /* max length of hostname */
  9637. +
  9638. +#endif
  9639. +
  9640. diff -urN linux.store/linux/include/asm-arm/proc-arm6/ptrace.h linux/include/asm-arm/proc-arm6/ptrace.h
  9641. --- linux.store/linux/include/asm-arm/proc-arm6/ptrace.h    Thu Jan  1 01:00:00 1970
  9642. +++ linux/include/asm-arm/proc-arm6/ptrace.h    Sun Feb 11 09:32:54 1996
  9643. @@ -0,0 +1,15 @@
  9644. +/*
  9645. + * linux/include/asm-arm/proc-arm6/ptrace.h
  9646. + *
  9647. + * Copyright (C) 1996 Russell King
  9648. + */
  9649. +
  9650. +#ifndef __ASM_PROC_PTRACE_H
  9651. +#define __ASM_PROC_PTRACE_H
  9652. +
  9653. +#error Have to modify this
  9654. +#define user_mode(regs)            (((regs)->ARM_pc & 3) == 0)
  9655. +#define instruction_pointer(regs)    ((regs)->ARM_pc & 0x03fffffc)
  9656. +
  9657. +#endif
  9658. +
  9659. diff -urN linux.store/linux/include/asm-arm/proc-arm6/shmparam.h linux/include/asm-arm/proc-arm6/shmparam.h
  9660. --- linux.store/linux/include/asm-arm/proc-arm6/shmparam.h    Thu Jan  1 01:00:00 1970
  9661. +++ linux/include/asm-arm/proc-arm6/shmparam.h    Sun Feb 11 09:32:56 1996
  9662. @@ -0,0 +1,12 @@
  9663. +/*
  9664. + * linux/include/asm-arm/proc-arm6/shmparam.h
  9665. + *
  9666. + * Copyright (C) 1996 Russell King
  9667. + *
  9668. + * definitions for the shared process memory on the ARM6
  9669. + */
  9670. +
  9671. +#ifndef SHM_RANGE_START
  9672. +#define SHM_RANGE_START    0x50000000
  9673. +#define SHM_RANGE_END    0x60000000
  9674. +#endif
  9675. diff -urN linux.store/linux/include/asm-arm/ptrace.h linux/include/asm-arm/ptrace.h
  9676. --- linux.store/linux/include/asm-arm/ptrace.h    Sun Feb 11 09:32:56 1996
  9677. +++ linux/include/asm-arm/ptrace.h    Sun Feb 11 09:32:56 1996
  9678. @@ -28,8 +28,7 @@
  9679.  #define ARM_ORIG_r0    uregs[16] /* -1 */
  9680.  
  9681.  #ifdef __KERNEL__
  9682. -#define user_mode(regs)            (((regs)->ARM_pc & 3) == 0)
  9683. -#define instruction_pointer(regs)    ((regs)->ARM_pc & 0x03fffffc)
  9684. +#include <asm/proc/ptrace.h>
  9685.  extern void show_regs(struct pt_regs *);
  9686.  #endif
  9687.  
  9688. diff -urN linux.store/linux/include/asm-arm/segment.h linux/include/asm-arm/segment.h
  9689. --- linux.store/linux/include/asm-arm/segment.h    Sun Feb 11 09:32:56 1996
  9690. +++ linux/include/asm-arm/segment.h    Sun Feb 11 09:32:56 1996
  9691. @@ -40,136 +40,11 @@
  9692.   */
  9693.  extern int bad_user_access_length(void);
  9694.  
  9695. -/*
  9696. - * dummy pointer type structure.. gcc won't try to do something strange
  9697. - * this way..
  9698. - */
  9699. -struct __segment_dummy { unsigned long a[100]; };
  9700. -#define __sd(x) ((struct __segment_dummy *) (x))
  9701. -#define __const_sd(x) ((const struct __segment_dummy *) (x))
  9702. -
  9703. -#if defined(__arm2__) || defined(__arm3__)
  9704. -/*
  9705. - * These *have* to tell gcc that lr may be clobbered (if there is an abort)
  9706. - * and the psw (if it tries too hard to optimize this
  9707. - */
  9708. -static inline void __put_user(unsigned long x, void * y, int size)
  9709. -{
  9710. -    if (IS_USER_SEG) {
  9711. -        switch (size) {
  9712. -            case 1:
  9713. -                __asm__(
  9714. -                " strbt    %0, [%1]\n"
  9715. -                : : "r" (x), "r" (y)
  9716. -                : "lr", "cc");
  9717. -                break;
  9718. -            case 2:
  9719. -                { register unsigned long tmp;
  9720. -                __asm__ __volatile__(
  9721. -                " strbt %1, [%2], #1\n"
  9722. -                " mov   %0, %1, lsr #8\n"
  9723. -                " strbt %0, [%2]\n"
  9724. -                : "=&r" (tmp)
  9725. -                : "r" (x), "r" (y)
  9726. -                : "2", "lr", "cc");
  9727. -                }
  9728. -                break;
  9729. -            case 4:
  9730. -                if ((int)y & 3) {
  9731. -                register unsigned long tmp;
  9732. -                __asm__ __volatile__(
  9733. -                " strbt %1, [%2], #1\n"
  9734. -                " mov   %0, %1, lsr #8\n"
  9735. -                " strbt %0, [%2], #1\n"
  9736. -                " mov   %0, %0, lsr #8\n"
  9737. -                " strbt %0, [%2], #1\n"
  9738. -                " mov   %0, %0, lsr #8\n"
  9739. -                " strbt %0, [%2]\n"
  9740. -                : "=&r" (tmp)
  9741. -                : "r" (x), "r" (y)
  9742. -                : "2", "lr", "cc");
  9743. -                } else {
  9744. -                __asm__(
  9745. -                " strt  %0, [%1]\n"
  9746. -                : : "r" (x), "r" (y)
  9747. -                : "lr", "cc");
  9748. -                }
  9749. -                break;
  9750. -            default:
  9751. -                bad_user_access_length();
  9752. -        }
  9753. -    } else {
  9754. -        switch (size) {
  9755. -            case 1: *(unsigned char *)y = x; break;
  9756. -            case 2: *(unsigned short *)y = x; break;
  9757. -            case 4: *(unsigned long *)y = x; break;
  9758. -            default:
  9759. -                bad_user_access_length();
  9760. -        }
  9761. -    }
  9762. -}
  9763. -
  9764. -static inline unsigned long __get_user(const void *y, int size)
  9765. -{
  9766. -    unsigned long result1, result2;
  9767. -
  9768. -    if (IS_USER_SEG) {
  9769. -        switch (size) {
  9770. -            case 1:
  9771. -                __asm__(
  9772. -                " ldrbt %0, [%1]\n"
  9773. -                : "=r" (result1)
  9774. -                : "r" (y)
  9775. -                : "lr", "cc");
  9776. -                return result1;
  9777. -            case 2:
  9778. -                __asm__(
  9779. -                " ldrbt %0, [%2], #1\n"
  9780. -                " ldrbt %1, [%2]\n"
  9781. -                " orr   %0, %0, %1, lsl #8\n"
  9782. -                : "=&r" (result1), "=r" (result2)
  9783. -                : "r" (y)
  9784. -                : "lr", "cc");
  9785. -                return result1;
  9786. -            case 4:
  9787. -                if ((int)y & 3) {
  9788. -                __asm__(
  9789. -                " ldrt %0, [%2], #4\n"
  9790. -                " ldrt %1, [%2]\n"
  9791. -                : "=&r" (result1), "=r" (result2)
  9792. -                : "r" ((int)y & ~3)
  9793. -                : "lr", "cc");
  9794. -                result1 >>= ((int)y & 3)*8;
  9795. -                return result1 | (result2 << (32-((int)y & 3)*8));
  9796. -                } else {
  9797. -                __asm__(
  9798. -                " ldrt %0, [%1]\n"
  9799. -                : "=r" (result1)
  9800. -                : "r" (y)
  9801. -                : "lr", "cc");
  9802. -                return result1;
  9803. -                }
  9804. -            default:
  9805. -                return bad_user_access_length();
  9806. -        }
  9807. -    } else {
  9808. -        switch (size) {
  9809. -            case 1: return *(unsigned char *)y; break;
  9810. -            case 2: return *(unsigned short *)y; break;
  9811. -            case 4: return *(unsigned long *)y; break;
  9812. -            default:
  9813. -                return bad_user_access_length();
  9814. -        }
  9815. -    }
  9816. -}        
  9817. -#else
  9818. -#error Adjust this for your processor
  9819. -#endif
  9820. +#include <asm/proc/segment.h>
  9821.  
  9822.  /*
  9823.   * these are depreciated..
  9824.   */
  9825. -
  9826.  static __INLINE__ unsigned char get_user_byte(const char *addr)
  9827.  {
  9828.      return __get_user(addr, 1);
  9829. diff -urN linux.store/linux/include/asm-arm/shmparam.h linux/include/asm-arm/shmparam.h
  9830. --- linux.store/linux/include/asm-arm/shmparam.h    Sun Feb 11 09:32:56 1996
  9831. +++ linux/include/asm-arm/shmparam.h    Sun Feb 11 09:32:56 1996
  9832. @@ -1,9 +1,13 @@
  9833.  #ifndef _ASMARM_SHMPARAM_H
  9834.  #define _ASMARM_SHMPARAM_H
  9835.  
  9836. -/* address range for shared memory attaches if no address passed to shmat() */
  9837. -#define SHM_RANGE_START    0x00a00000
  9838. -#define SHM_RANGE_END    0x00c00000
  9839. +/*
  9840. + * Include the machine specific shm parameters before the processor
  9841. + * dependent parameters so that the machine parameters can override
  9842. + * the processor parameters
  9843. + */
  9844. +#include <asm/arch/shmparam.h>
  9845. +#include <asm/proc/shmparam.h>
  9846.  
  9847.  /*
  9848.   * Format of a swap-entry for shared memory pages currently out in
  9849. diff -urN linux.store/linux/include/asm-arm/system.h linux/include/asm-arm/system.h
  9850. --- linux.store/linux/include/asm-arm/system.h    Sun Feb 11 09:32:57 1996
  9851. +++ linux/include/asm-arm/system.h    Sun Feb 11 09:32:57 1996
  9852. @@ -7,7 +7,6 @@
  9853.  extern void arm_invalidptr(const char *, void *, int);
  9854.  
  9855.  /* This special macro can be used to load a debugging register */
  9856. -
  9857.  #define loaddebug(register)
  9858.  
  9859.  /*
  9860. @@ -22,184 +21,13 @@
  9861.  #define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
  9862.  #define tas(ptr) (xchg((ptr),1))
  9863.  
  9864. -struct __xchg_dummy { unsigned long a[100]; };
  9865. -#define __xg(x) ((volatile struct __xchg_dummy *)(x))
  9866. -
  9867. -#if defined (__arm2__)
  9868. -static inline unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
  9869. -{
  9870. -    unsigned long temp0, temp1;
  9871. -    switch (size) {
  9872. -        case 1: __asm__ __volatile__(
  9873. -            " mov   %0, pc\n"
  9874. -            " orr   %1, %0, #0x08000000\n"
  9875. -            " teqp  %1, #0\n"
  9876. -            " mov   %1, %3\n"    /* Safe: in case it uses the same reg */
  9877. -            " ldrb  %2, [%4]\n"
  9878. -            " strb  %1, [%4]\n"
  9879. -            " teqp  %0, #0\n"
  9880. -            : "=r" (temp0), "=r" (temp1), "=r" (x)
  9881. -            : "r" (x), "r" (ptr)
  9882. -            : "memory");
  9883. -            break;
  9884. -        case 2: { unsigned long temp0, temp1;
  9885. -            if (((long)ptr) & 1)
  9886. -            {
  9887. -                void *pc;
  9888. -                __asm__("mov\t%0, pc": "=r" (pc));
  9889. -                arm_malalignedptr("xchg", pc, ptr);
  9890. -            }
  9891. -            __asm__ __volatile__(
  9892. -            " mov   %0, pc\n"
  9893. -            " orr   %1, %0, #0x08000000\n"
  9894. -            " teqp  %1, #0\n"
  9895. -            " mov   %1, %3\n"
  9896. -            " ldr    %2, [%4]\n"
  9897. -            " strb  %1, [%4]\n"
  9898. -            " mov   %1, %1, lsr #8\n"
  9899. -            " strb  %1, [%4, #1]\n"
  9900. -            " teqp  %0, #0\n"
  9901. -            : "=r" (temp0), "=r" (temp1), "=r" (x)
  9902. -            : "r" (x), "r" (ptr)
  9903. -            : "memory");
  9904. -            val &= 0xffff;
  9905. -            break;
  9906. -            }
  9907. -        case 4: { unsigned long temp0, temp1;
  9908. -            if (((long)ptr) & 3)
  9909. -            {
  9910. -                void *pc;
  9911. -                __asm__("mov\t%0, pc": "=r" (pc));
  9912. -                arm_malalignedptr("xchg", pc, ptr);
  9913. -            }
  9914. -            __asm__ __volatile__(
  9915. -            " mov   %0, pc\n"
  9916. -            " orr   %1, %0, #0x08000000\n"
  9917. -            " teqp  %1, #0\n"
  9918. -            " mov   %1, %3\n"
  9919. -            " ldr   %2, [%4]\n"
  9920. -            " str   %1, [%4]\n"
  9921. -            " teqp  %0, #0\n"
  9922. -            : "=r" (temp0), "=r" (temp1), "=r" (x)
  9923. -            : "r" (x), "r" (ptr)
  9924. -            : "memory");
  9925. -            }
  9926. -            break;
  9927. -        default:
  9928. -            {
  9929. -                void *pc;
  9930. -                __asm__("mov\t%0, pc": "=r" (pc));
  9931. -                arm_invalidptr("xchg", pc, size);
  9932. -                x = 0;
  9933. -            }
  9934. -    }
  9935. -    return x;
  9936. -}
  9937. -#elif defined (__arm3__)
  9938. -static inline unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
  9939. -{
  9940. -    switch (size) {
  9941. -        case 1:
  9942. -            __asm__ __volatile__(
  9943. -            " swpb   %0, %1, [%2]\n\t"
  9944. -            : "=r" (x)
  9945. -            : "r" (x), "r" (ptr)
  9946. -            : "memory");
  9947. -            break;
  9948. -        case 2: { unsigned long temp0, temp1;
  9949. -            if (((long)ptr) & 1)
  9950. -            {
  9951. -                void *pc;
  9952. -                __asm__("mov\t%0, pc": "=r" (pc));
  9953. -                arm_malalignedptr("xchg", pc, ptr);
  9954. -            }
  9955. -            __asm__ __volatile__(
  9956. -            " mov   %0, pc\n"
  9957. -            " orr   %1, %0, #0x08000000\n"
  9958. -            " teqp  %1, #0\n"
  9959. -            " mov   %1, %3\n"
  9960. -            " ldr    %2, [%4]\n"
  9961. -            " strb  %1, [%4]\n"
  9962. -            " mov   %1, %1, lsr #8\n"
  9963. -            " strb  %1, [%4, #1]\n"
  9964. -            " teqp  %0, #0\n"
  9965. -            : "=r" (temp0), "=r" (temp1), "=r" (x)
  9966. -            : "r" (x), "r" (ptr)
  9967. -            : "memory");
  9968. -            x &= 0xffff;
  9969. -            break;
  9970. -            }
  9971. -        case 4: if (((long)ptr) & 3)
  9972. -            {
  9973. -                void *pc;
  9974. -                __asm__("mov\t%0, pc": "=r" (pc));
  9975. -                arm_malalignedptr("xchg", pc, ptr);
  9976. -            }
  9977. -            __asm__ __volatile__(
  9978. -            " swp   %0, %1, [%2]\n"
  9979. -            : "=r" (x)
  9980. -            : "r" (x), "r" (ptr)
  9981. -            : "memory");
  9982. -            break;
  9983. -        default:
  9984. -            {
  9985. -                void *pc;
  9986. -                __asm__("mov\t%0, pc": "=r" (pc));
  9987. -                arm_invalidptr("xchg", pc, size);
  9988. -                x = 0;
  9989. -            }
  9990. -    }
  9991. -    return x;
  9992. -}
  9993. -#else
  9994. -#error Adjust this routine for your processor
  9995. -#endif
  9996. +/*
  9997. + * Include processor dependent parts
  9998. + */
  9999. +#include <asm/proc/system.h>
  10000. +#include <asm/arch/system.h>
  10001.  
  10002.  #define mb() __asm__ __volatile__ ("" : : : "memory")
  10003. -
  10004. -#define sti()                \
  10005. -    do {                \
  10006. -      unsigned long temp;        \
  10007. -      __asm__ __volatile__(        \
  10008. -      " mov %0, pc\n"        \
  10009. -      " bic %0, %0, #0x08000000\n"    \
  10010. -      " teqp %0, #0\n"        \
  10011. -      : "=r" (temp)            \
  10012. -      : );                \
  10013. -    } while(0)
  10014. -
  10015. -#define cli()                \
  10016. -    do {                \
  10017. -      unsigned long temp;        \
  10018. -      __asm__ __volatile__(        \
  10019. -      " mov %0, pc\n"        \
  10020. -      " orr %0, %0, #0x08000000\n"    \
  10021. -      " teqp %0, #0\n"        \
  10022. -      : "=r" (temp)            \
  10023. -      : );                \
  10024. -    } while(0)
  10025. -
  10026. -#define save_flags(x)            \
  10027. -    do {                \
  10028. -      __asm__ __volatile__(        \
  10029. -      " mov %0, pc\n"        \
  10030. -      : "=r" (x) : );        \
  10031. -    } while (0)
  10032. -
  10033. -#define restore_flags(x)        \
  10034. -    do {                \
  10035. -      unsigned long temp;        \
  10036. -      __asm__ __volatile__(        \
  10037. -      " mov %0, pc\n"        \
  10038. -      " bic %0, %0, #0x08000000\n"    \
  10039. -      " and %1, %1, #0x08000000\n"    \
  10040. -      " orr %0, %0, %1\n"        \
  10041. -      " teqp %0, #0\n"        \
  10042. -      : "=r" (temp)            \
  10043. -      : "r" (x)            \
  10044. -      : "cc");            \
  10045. -    } while (0)
  10046. -
  10047.  #define nop() __asm__ __volatile__("mov r0,r0\n\t");
  10048.  
  10049.  #endif
  10050. diff -urN linux.store/linux/include/linux/fd1772.h linux/include/linux/fd1772.h
  10051. --- linux.store/linux/include/linux/fd1772.h    Thu Jan  1 01:00:00 1970
  10052. +++ linux/include/linux/fd1772.h    Wed Mar 13 14:56:15 1996
  10053. @@ -0,0 +1,80 @@
  10054. +#ifndef _LINUX_FD1772REG_H
  10055. +#define _LINUX_FD1772REG_H
  10056. +
  10057. +/*
  10058. +** WD1772 stuff - originally from the M68K Linux
  10059. + * Modified for Archimedes by Dave Gilbert (gilbertd@cs.man.ac.uk)
  10060. + */
  10061. +
  10062. +/* register codes */
  10063. +
  10064. +#define FDC1772SELREG_STP   (0x80)   /* command/status register */
  10065. +#define FDC1772SELREG_TRA   (0x82)   /* track register */
  10066. +#define FDC1772SELREG_SEC   (0x84)   /* sector register */
  10067. +#define FDC1772SELREG_DTA   (0x86)   /* data register */
  10068. +
  10069. +/* register names for FDC1772_READ/WRITE macros */
  10070. +
  10071. +#define FDC1772REG_CMD        0
  10072. +#define FDC1772REG_STATUS    0
  10073. +#define FDC1772REG_TRACK    2
  10074. +#define FDC1772REG_SECTOR    4
  10075. +#define FDC1772REG_DATA        6
  10076. +
  10077. +/* command opcodes */
  10078. +
  10079. +#define FDC1772CMD_RESTORE  (0x00)   /*  -                   */
  10080. +#define FDC1772CMD_SEEK     (0x10)   /*   |                  */
  10081. +#define FDC1772CMD_STEP     (0x20)   /*   |  TYP 1 Commands  */
  10082. +#define FDC1772CMD_STIN     (0x40)   /*   |                  */
  10083. +#define FDC1772CMD_STOT     (0x60)   /*  -                   */
  10084. +#define FDC1772CMD_RDSEC    (0x80)   /*  -   TYP 2 Commands  */
  10085. +#define FDC1772CMD_WRSEC    (0xa0)   /*  -          "        */
  10086. +#define FDC1772CMD_RDADR    (0xc0)   /*  -                   */
  10087. +#define FDC1772CMD_RDTRA    (0xe0)   /*   |  TYP 3 Commands  */
  10088. +#define FDC1772CMD_WRTRA    (0xf0)   /*  -                   */
  10089. +#define FDC1772CMD_FORCI    (0xd0)   /*  -   TYP 4 Command   */
  10090. +
  10091. +/* command modifier bits */
  10092. +
  10093. +#define FDC1772CMDADD_SR6   (0x00)   /* step rate settings */
  10094. +#define FDC1772CMDADD_SR12  (0x01)
  10095. +#define FDC1772CMDADD_SR2   (0x02)
  10096. +#define FDC1772CMDADD_SR3   (0x03)
  10097. +#define FDC1772CMDADD_V     (0x04)   /* verify */
  10098. +#define FDC1772CMDADD_H     (0x08)   /* wait for spin-up */
  10099. +#define FDC1772CMDADD_U     (0x10)   /* update track register */
  10100. +#define FDC1772CMDADD_M     (0x10)   /* multiple sector access */
  10101. +#define FDC1772CMDADD_E     (0x04)   /* head settling flag */
  10102. +#define FDC1772CMDADD_P     (0x02)   /* precompensation */
  10103. +#define FDC1772CMDADD_A0    (0x01)   /* DAM flag */
  10104. +
  10105. +/* status register bits */
  10106. +
  10107. +#define    FDC1772STAT_MOTORON    (0x80)   /* motor on */
  10108. +#define    FDC1772STAT_WPROT    (0x40)   /* write protected (FDC1772CMD_WR*) */
  10109. +#define    FDC1772STAT_SPINUP    (0x20)   /* motor speed stable (Type I) */
  10110. +#define    FDC1772STAT_DELDAM    (0x20)   /* sector has deleted DAM (Type II+III) */
  10111. +#define    FDC1772STAT_RECNF    (0x10)   /* record not found */
  10112. +#define    FDC1772STAT_CRC        (0x08)   /* CRC error */
  10113. +#define    FDC1772STAT_TR00    (0x04)   /* Track 00 flag (Type I) */
  10114. +#define    FDC1772STAT_LOST    (0x04)   /* Lost Data (Type II+III) */
  10115. +#define    FDC1772STAT_IDX        (0x02)   /* Index status (Type I) */
  10116. +#define    FDC1772STAT_DRQ        (0x02)   /* DRQ status (Type II+III) */
  10117. +#define    FDC1772STAT_BUSY    (0x01)   /* FDC1772 is busy */
  10118. +
  10119. +
  10120. +/* PSG Port A Bit Nr 0 .. Side Sel .. 0 -> Side 1  1 -> Side 2 */
  10121. +#define DSKSIDE     (0x01)
  10122. +        
  10123. +#define DSKDRVNONE  (0x06)
  10124. +#define DSKDRV0     (0x02)
  10125. +#define DSKDRV1     (0x04)
  10126. +
  10127. +/* step rates */
  10128. +#define    FDC1772STEP_6    0x00
  10129. +#define    FDC1772STEP_12    0x01
  10130. +#define    FDC1772STEP_2    0x02
  10131. +#define    FDC1772STEP_3    0x03
  10132. +
  10133. +#endif
  10134.